00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012 #include <qimage.h>
00013 #include <qstring.h>
00014 #include <qapplication.h>
00015 #include <math.h>
00016
00017
00018 #include "tilt.h"
00019 #include "tilt_internal.h"
00020 #include "../../gui/statusWidget.h"
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100 QImage* correctImageTilt( QString filename, QPoint p1, QPoint p2,
00101 StatusWidget* status)
00102 {
00103
00104 int dx = p2.x() - p1.x();
00105 int dy = p2.y() - p1.y();
00106
00107
00108 int delta = 0;
00109
00110
00111 double recip_r = 1.0 / sqrt( (double) (dx*dx + dy*dy) );
00112
00113
00114 if( QABS(dx) > QABS(dy) )
00115 {
00116 delta = dy;
00117 if(dx > 0) delta = -delta;
00118 }
00119
00120 else
00121 {
00122 delta = dx;
00123 if(dy < 0) delta = -delta;
00124 }
00125
00126 double sinTheta = (delta * recip_r);
00127 double theta = asin( sinTheta );
00128 double cosTheta = cos( theta );
00129
00130
00131 if( theta == 0 )
00132 return NULL;
00133
00134
00135 QImage originalImage( filename );
00136
00137
00138 if( originalImage.depth() < 32 ) { originalImage = originalImage.convertDepth( 32, Qt::AutoColor ); }
00139
00140 QImage rotatedImage( originalImage.width(), originalImage.height(), originalImage.depth() );
00141
00142
00143 QString statusMessage = qApp->translate( "correctImageTilt", "Correcting Tilt:" );
00144 status->showProgressBar( statusMessage, 200 );
00145 qApp->processEvents();
00146
00147
00148 int updateIncrement = (int) ( 0.01 * originalImage.width() * originalImage.height() );
00149 int newProgress = 0;
00150
00151
00152 double xp, yp;
00153
00154 double w2 = 0.5 * rotatedImage.width();
00155 double h2 = 0.5 * rotatedImage.height();
00156
00157 int x,y;
00158 uchar* scanLine;
00159 QRgb* rgb;
00160 for( y=0; y<rotatedImage.height(); y++)
00161 {
00162
00163 scanLine = rotatedImage.scanLine(y);
00164 for( x=0; x<rotatedImage.width(); x++)
00165 {
00166
00167 xp = cosTheta*(x-w2) + sinTheta*(y-h2) + w2;
00168 yp = -sinTheta*(x-w2) + cosTheta*(y-h2) + h2;
00169
00170
00171 rgb = ((QRgb*)scanLine+x);
00172 *rgb = interpolatedPixelValue( xp, yp, &originalImage);
00173
00174
00175 newProgress++;
00176 if(newProgress >= updateIncrement)
00177 {
00178 newProgress = 0;
00179 status->incrementProgress();
00180 qApp->processEvents();
00181 }
00182
00183 }
00184 }
00185
00186
00187 double nTheta = -theta;
00188 double sinNTheta = sin( nTheta );
00189 double cosNTheta = cos( nTheta );
00190
00191 DPoint topLeft = DPoint( cosNTheta*(-w2) + sinNTheta*(-h2) + w2,
00192 -sinNTheta*(-w2) + cosNTheta*(-h2) + h2 );
00193
00194 DPoint topRight = DPoint( cosNTheta*(w2) + sinNTheta*(-h2) + w2,
00195 -sinNTheta*(w2) + cosNTheta*(-h2) + h2 );
00196
00197 DPoint bottomLeft = DPoint( cosNTheta*(-w2) + sinNTheta*(h2) + w2,
00198 -sinNTheta*(-w2) + cosNTheta*(h2) + h2 );
00199
00200 DPoint bottomRight = DPoint( cosNTheta*(w2) + sinNTheta*(h2) + w2,
00201 -sinNTheta*(w2) + cosNTheta*(h2) + h2 );
00202
00203
00204 DPoint top, bottom, left, right;
00205 if( theta < 0 )
00206 {
00207 top = topRight;
00208 bottom = bottomLeft;
00209 left = topLeft;
00210 right = bottomRight;
00211 }
00212 else
00213 {
00214 top = topLeft;
00215 bottom = bottomRight;
00216 left = bottomLeft;
00217 right = topRight;
00218 }
00219
00220
00221 DPoint trueTopLeft ( 0, 0 );
00222 DPoint trueTopRight ( rotatedImage.width()-1, 0 );
00223 DPoint trueBottomLeft ( 0, rotatedImage.height()-1 );
00224 DPoint trueBottomRight( rotatedImage.width()-1, rotatedImage.height()-1 );
00225
00226
00227 DPoint topEdgeL = findTwoLineIntersection( left, top, trueTopLeft, trueTopRight );
00228 DPoint topEdgeR = findTwoLineIntersection( top, right, trueTopLeft, trueTopRight );
00229
00230 DPoint bottomEdgeL = findTwoLineIntersection( left, bottom, trueBottomLeft, trueBottomRight );
00231 DPoint bottomEdgeR = findTwoLineIntersection( bottom, right, trueBottomLeft, trueBottomRight );
00232
00233 DPoint leftEdgeT = findTwoLineIntersection( left, top, trueTopLeft, trueBottomLeft );
00234 DPoint leftEdgeB = findTwoLineIntersection( left, bottom, trueTopLeft, trueBottomLeft );
00235
00236 DPoint rightEdgeT = findTwoLineIntersection( right, top, trueTopRight, trueBottomRight );
00237 DPoint rightEdgeB = findTwoLineIntersection( right, bottom, trueTopRight, trueBottomRight );
00238
00239
00240 DPoint center( (int)w2, (int)h2 );
00241 DPoint safeTopLeft = findTwoLineIntersection( center, trueTopLeft, leftEdgeT, topEdgeL );
00242 DPoint safeTopRight = findTwoLineIntersection( center, trueTopRight, rightEdgeT, topEdgeR );
00243 DPoint safeBottomLeft = findTwoLineIntersection( center, trueBottomLeft, leftEdgeB, bottomEdgeL );
00244 DPoint safeBottomRight = findTwoLineIntersection( center, trueBottomRight, rightEdgeB, bottomEdgeR );
00245
00246
00247 double minY = QMAX( safeTopLeft.y(), safeTopRight.y() );
00248 double maxY = QMIN( safeBottomLeft.y(), safeBottomRight.y() );
00249
00250 double minX = QMAX( safeTopLeft.x(), safeBottomLeft.x() );
00251 double maxX = QMIN( safeTopRight.x(), safeBottomRight.x() );
00252
00253
00254
00255
00256 int xMin = (int) minX;
00257 int xMax = (int) maxX;
00258
00259 int yMin = (int) minY;
00260 int yMax = (int) maxY;
00261
00262 if( xMin < minX ) xMin++;
00263 if( yMin < minY ) yMin++;
00264
00265
00266 QImage* editedImage = new QImage( xMax - xMin + 1,
00267 yMax - yMin + 1,
00268 rotatedImage.depth() );
00269
00270
00271 updateIncrement = (int) ( 0.01 * editedImage->width() * editedImage->height() );
00272 newProgress = 0;
00273
00274 int x2,y2;
00275 uchar* scanLine2;
00276 QRgb* rgb2;
00277
00278 y2 = 0;
00279 for( y=yMin; y<=yMax; y++, y2++)
00280 {
00281
00282 scanLine = rotatedImage.scanLine(y);
00283 scanLine2 = editedImage->scanLine(y2);
00284
00285 x2 = 0;
00286 for( x=xMin; x<=xMax; x++, x2++)
00287 {
00288 rgb = ((QRgb*)scanLine +x );
00289 rgb2 = ((QRgb*)scanLine2+x2);
00290 *rgb2 = *rgb;
00291
00292
00293 newProgress++;
00294 if(newProgress >= updateIncrement)
00295 {
00296 newProgress = 0;
00297 status->incrementProgress();
00298 qApp->processEvents();
00299 }
00300
00301 }
00302 }
00303
00304
00305 status->setStatus( "" );
00306 qApp->processEvents();
00307
00308
00309 return editedImage;
00310 }
00311
00312 QRgb interpolatedPixelValue( double xp, double yp,
00313 QImage* image )
00314 {
00315
00316
00317 if(xp < 0 || xp >= image->width() ||
00318 yp < 0 || yp >= image->height() )
00319 return qRgb( 0, 0, 0 );
00320
00321
00322 int x = (int)xp;
00323 int y = (int)yp;
00324
00325 uchar* scanLine1 = image->scanLine( y );
00326
00327 uchar* scanLine2;
00328 if( y < image->height() - 1 )
00329 scanLine2 = image->scanLine( y+1 );
00330 else
00331 scanLine2 = scanLine1;
00332
00333 QRgb p1,p2,p3,p4;
00334
00335 p1 = *((QRgb*)scanLine1+x);
00336 p3 = *((QRgb*)scanLine2+x);
00337
00338 if( x < image->width() - 1)
00339 {
00340 p2 = *((QRgb*)scanLine1+x+1);
00341 p4 = *((QRgb*)scanLine2+x+1);
00342 }
00343 else
00344 {
00345 p2 = p1;
00346 p4 = p3;
00347 }
00348
00349
00350 double alphaY = yp - y;
00351 double alphaX = xp - x;
00352
00353 p1 = blendColors( p1, p2, alphaX );
00354 p3 = blendColors( p3, p4, alphaX );
00355 p1 = blendColors( p1, p3, alphaY );
00356 return p1;
00357 }
00358
00359 QRgb blendColors( QRgb color1, QRgb color2, double alpha )
00360 {
00361 double alpha2 = 1.0-alpha;
00362 return qRgb( (int) QMAX( QMIN( 255, alpha2*qRed (color1) + alpha*qRed(color2) ), 0 ),
00363 (int) QMAX( QMIN( 255, alpha2*qGreen(color1) + alpha*qGreen(color2) ), 0 ),
00364 (int) QMAX( QMIN( 255, alpha2*qBlue (color1) + alpha*qBlue(color2) ), 0 ) );
00365 }
00366
00367 DPoint findTwoLineIntersection(DPoint p1, DPoint p2,
00368 DPoint p3, DPoint p4)
00369 {
00370
00371
00372
00373
00374
00375 if(p1.x() == p2.x() &&
00376 p4.x() == p3.x())
00377 {
00378
00379
00380
00381
00382
00383 if( p1.x() == p3.x() )
00384 { return DPoint( p1.x(), p1.y() ); }
00385
00386
00387 else
00388 { return DPoint( -32000, -32000 ); }
00389 }
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400 else if( p1.x() == p2.x() )
00401 {
00402 double slopeB = ((double) (p4.y() - p3.y()) ) / (p4.x() - p3.x());
00403
00404 double yInterceptB = p3.y() - slopeB*p3.x();
00405
00406
00407 return DPoint( p2.x(), slopeB*p2.x() + yInterceptB );
00408 }
00409
00410
00411
00412
00413
00414 else if( p4.x() == p3.x() )
00415 {
00416 double slopeA = ((double) (p2.y() - p1.y()) ) / (p2.x() - p1.x());
00417
00418 double yInterceptA = p1.y() - slopeA*p1.x();
00419
00420
00421 return DPoint( p4.x(), slopeA*p4.x() + yInterceptA );
00422 }
00423
00424
00425
00426 else
00427 {
00428 double slopeA = ((double) (p2.y() - p1.y()) ) / (p2.x() - p1.x());
00429 double slopeB = ((double) (p4.y() - p3.y()) ) / (p4.x() - p3.x());
00430 double yInterceptA = p1.y() - slopeA*p1.x();
00431 double yInterceptB = p3.y() - slopeB*p3.x();
00432
00433
00434
00435
00436
00437
00438
00439
00440
00441
00442 double x = (yInterceptB - yInterceptA) / (slopeA - slopeB);
00443 return DPoint( x, (slopeA * x) + yInterceptA );
00444 }
00445 }
00446
00447 DPoint::DPoint()
00448 { xpos=0; ypos=0; }
00449
00450 DPoint::DPoint( double x, double y )
00451 {
00452 this->xpos = x;
00453 this->ypos = y;
00454 }
00455
00456 double DPoint::x() const { return xpos; }
00457 double DPoint::y() const { return ypos; }
00458
00459
00460