108 
108 

109 
109 
QgsGeorefPluginGui::~QgsGeorefPluginGui()

110 
110 
{

111 

QgsTransformSettingsDialog::resetSettings();

112 
111 
clearGCPData();

113 
112 

114 
113 
// delete layer (and don't signal it as it's our private layer)

...  ...  
307 
306 
mActionLinkQGisToGeoref>setEnabled( false );

308 
307 
}

309 
308 


309 
updateTransformParamLabel();

310 
310 
return true;

311 
311 
}

312 
312 

...  ...  
443 
443 
}

444 
444 

445 
445 
connect( mCanvas, SIGNAL( extentsChanged() ), pnt, SLOT( updateCoords() ) );


446 
updateGeorefTransform();

446 
447 

447 
448 
// if (verbose)

448 
449 
// logRequaredGCPs();

...  ...  
469 
470 
break;

470 
471 
}

471 
472 
}


473 
updateGeorefTransform();

472 
474 
}

473 
475 

474 
476 
void QgsGeorefPluginGui::deleteDataPoint( int index )

...  ...  
476 
478 
mGCPListWidget>model()>removeRow( index );

477 
479 
delete mPoints.takeAt( index );

478 
480 
mGCPListWidget>updateGCPList();


481 
updateGeorefTransform();

479 
482 
}

480 
483 

481 
484 
void QgsGeorefPluginGui::selectPoint( const QPoint &p )

...  ...  
890 
893 
this, SLOT( replaceDataPoint( QgsGeorefDataPoint*, int ) ) );

891 
894 
connect( mGCPListWidget, SIGNAL( deleteDataPoint( int ) ),

892 
895 
this, SLOT( deleteDataPoint( int ) ) );


896 
connect( mGCPListWidget, SIGNAL( pointEnabled( QgsGeorefDataPoint*, int ) ), this, SLOT( updateGeorefTransform() ) );

893 
897 
}

894 
898 

895 
899 
void QgsGeorefPluginGui::createStatusBar()

896 
900 
{

897 
901 
QFont myFont( "Arial", 9 );

898 
902 


903 
mTransformParamLabel = new QLabel( statusBar() );


904 
mTransformParamLabel>setFont( myFont );


905 
mTransformParamLabel>setMinimumWidth( 10 );


906 
mTransformParamLabel>setMaximumHeight( 20 );


907 
mTransformParamLabel>setMargin( 3 );


908 
mTransformParamLabel>setAlignment( Qt::AlignCenter );


909 
mTransformParamLabel>setFrameStyle( QFrame::NoFrame );


910 
mTransformParamLabel>setText( tr( "Transform: " ) + convertTransformEnumToString( mTransformParam ) );


911 
mTransformParamLabel>setToolTip( tr( "Current transform parametrisation" ) );


912 
statusBar()>addPermanentWidget( mTransformParamLabel, 0 );


913 

899 
914 
mCoordsLabel = new QLabel( QString(), statusBar() );

900 
915 
mCoordsLabel>setFont( myFont );

901 
916 
mCoordsLabel>setMinimumWidth( 10 );

...  ...  
907 
922 
mCoordsLabel>setText( tr( "Coordinate: " ) );

908 
923 
mCoordsLabel>setToolTip( tr( "Current map coordinate" ) );

909 
924 
statusBar()>addPermanentWidget( mCoordsLabel, 0 );

910 


911 

mTransformParamLabel = new QLabel( statusBar() );

912 

mTransformParamLabel>setFont( myFont );

913 

mTransformParamLabel>setMinimumWidth( 10 );

914 

mTransformParamLabel>setMaximumHeight( 20 );

915 

mTransformParamLabel>setMargin( 3 );

916 

mTransformParamLabel>setAlignment( Qt::AlignCenter );

917 

mTransformParamLabel>setFrameStyle( QFrame::NoFrame );

918 

mTransformParamLabel>setText( tr( "Transform: " ) + convertTransformEnumToString( mTransformParam ) );

919 

mTransformParamLabel>setToolTip( tr( "Current transform parametrisation" ) );

920 

statusBar()>addPermanentWidget( mTransformParamLabel, 0 );

921 
925 
}

922 
926 

923 
927 
void QgsGeorefPluginGui::setupConnections()

...  ...  
1168 
1172 
return true;

1169 
1173 
}

1170 
1174 


1175 
bool QgsGeorefPluginGui::calculateMeanError( double& error ) const


1176 
{


1177 
if ( mGeorefTransform.transformParametrisation() == QgsGeorefTransform::InvalidTransform )


1178 
{


1179 
return false;


1180 
}


1181 


1182 
int nPointsEnabled = 0;


1183 
QgsGCPList::const_iterator gcpIt = mPoints.constBegin();


1184 
for ( ; gcpIt != mPoints.constEnd(); ++gcpIt )


1185 
{


1186 
if (( *gcpIt )>isEnabled() )


1187 
{


1188 
++nPointsEnabled;


1189 
}


1190 
}


1191 


1192 
if ( nPointsEnabled == mGeorefTransform.getMinimumGCPCount() )


1193 
{


1194 
error = 0;


1195 
return true;


1196 
}


1197 
else if ( nPointsEnabled < mGeorefTransform.getMinimumGCPCount() )


1198 
{


1199 
return false;


1200 
}


1201 


1202 
double sumVxSquare = 0;


1203 
double sumVySquare = 0;


1204 
double resXMap, resYMap;


1205 


1206 
gcpIt = mPoints.constBegin();


1207 
for ( ; gcpIt != mPoints.constEnd(); ++gcpIt )


1208 
{


1209 
if (( *gcpIt )>isEnabled() )


1210 
{


1211 
sumVxSquare += (( *gcpIt )>residual().x() * ( *gcpIt )>residual().x() );


1212 
sumVySquare += (( *gcpIt )>residual().y() * ( *gcpIt )>residual().y() );


1213 
}


1214 
}


1215 


1216 
error = sqrt(( sumVxSquare + sumVySquare ) / ( 2 * ( nPointsEnabled  mGeorefTransform.getMinimumGCPCount() ) ) ) * sqrt( 2.0 );


1217 
return true;


1218 
}


1219 

1171 
1220 
bool QgsGeorefPluginGui::writePDFReportFile( const QString& fileName, const QgsGeorefTransform& transform )

1172 
1221 
{

1173 
1222 
if ( !mCanvas )

...  ...  
1210 
1259 
titleLabel>setFrame( false );

1211 
1260 

1212 
1261 
//composer map

1213 

QgsComposerMap* composerMap = new QgsComposerMap( composition, 2, titleLabel>rect().bottom() + titleLabel>transform().dy(), 206, 277 );


1262 
QgsRectangle canvasExtent = mCanvas>extent();


1263 
//calculate width and height considering extent aspect ratio and max Width 206, maxHeight 70


1264 
double widthExtentRatio = 206 / canvasExtent.width();


1265 
double heightExtentRatio = 70 / canvasExtent.height();


1266 
double mapWidthMM = 0;


1267 
double mapHeightMM = 0;


1268 
if ( widthExtentRatio < heightExtentRatio )


1269 
{


1270 
mapWidthMM = 206;


1271 
mapHeightMM = 206 / canvasExtent.width() * canvasExtent.height();


1272 
}


1273 
else


1274 
{


1275 
mapHeightMM = 70;


1276 
mapWidthMM = 70 / canvasExtent.height() * canvasExtent.width();


1277 
}


1278 


1279 
QgsComposerMap* composerMap = new QgsComposerMap( composition, 2, titleLabel>rect().bottom() + titleLabel>transform().dy(), mapWidthMM, mapHeightMM );

1214 
1280 
composerMap>setLayerSet( canvasRenderer>layerSet() );

1215 
1281 
composerMap>setNewExtent( mCanvas>extent() );

1216 
1282 
composerMap>setMapCanvas( mCanvas );

...  ...  
1226 
1292 
//transformation that involves only scaling and rotation (linear or helmert) ?

1227 
1293 
bool wldTransform = transform.getOriginScaleRotation( origin, scaleX, scaleY, rotation );

1228 
1294 

1229 

//consider rotation in scale parameter

1230 

double wldScaleX = scaleX;

1231 

double wldScaleY = scaleY;

1232 

if ( wldTransform && !doubleNear( rotation, 0.0 ) )

1233 

{

1234 

wldScaleX *= cos( rotation );

1235 

wldScaleY *= cos( rotation );

1236 

}

1237 


1238 
1295 
if ( wldTransform )

1239 
1296 
{

1240 

QString parameterTitle = tr( "Transformation parameters" );

1241 

if ( transform.transformParametrisation() == QgsGeorefTransform::Helmert )

1242 

{

1243 

parameterTitle += " (Helmert)";

1244 

}

1245 

else if ( transform.transformParametrisation() == QgsGeorefTransform::Linear )

1246 

{

1247 

parameterTitle += " (Linear)";

1248 

}


1297 
QString parameterTitle = tr( "Transformation parameters" ) + QString( " (" ) + convertTransformEnumToString( transform.transformParametrisation() ) + QString( ")" );

1249 
1298 
parameterLabel = new QgsComposerLabel( composition );

1250 
1299 
parameterLabel>setFont( titleFont );

1251 
1300 
parameterLabel>setText( parameterTitle );

...  ...  
1264 
1313 
}

1265 
1314 
}

1266 
1315 

1267 

//calculate mean error (in map units)


1316 
//calculate mean error

1268 
1317 
double meanError = 0;

1269 

if ( nPointsEnabled > 2 )

1270 

{

1271 

double sumVxSquare = 0;

1272 

double sumVySquare = 0;

1273 

double resXMap, resYMap;


1318 
calculateMeanError( meanError );

1274 
1319 

1275 

QgsGCPList::const_iterator gcpIt = mPoints.constBegin();

1276 

for ( ; gcpIt != mPoints.constEnd(); ++gcpIt )

1277 

{

1278 

if (( *gcpIt )>isEnabled() )

1279 

{

1280 

resXMap = ( *gcpIt )>residual().x() * wldScaleX;

1281 

resYMap = ( *gcpIt )>residual().y() * wldScaleY;

1282 

sumVxSquare += ( resXMap * resXMap );

1283 

sumVySquare += ( resYMap * resYMap );

1284 

}

1285 

}

1286 


1287 

meanError = sqrt(( sumVxSquare + sumVySquare ) / ( 2 * nPointsEnabled  4 ) ) * sqrt( 2.0 );

1288 

}

1289 


1290 


1291 
1320 
parameterTable = new QgsComposerTextTable( composition );

1292 
1321 
parameterTable>setHeaderFont( tableHeaderFont );

1293 
1322 
parameterTable>setContentFont( tableContentFont );

...  ...  
1326 
1355 
//convert residual scale bar plot to map units if scaling is equal in x and ydirection (e.g. helmert)

1327 
1356 
if ( wldTransform )

1328 
1357 
{

1329 

if ( doubleNear( wldScaleX, wldScaleY ) )


1358 
if ( doubleNear( scaleX, scaleX ) )

1330 
1359 
{

1331 
1360 
resPlotItem>setPixelToMapUnits( scaleX );

1332 
1361 
resPlotItem>setConvertScaleToMapUnits( true );

...  ...  
1354 
1383 
{

1355 
1384 
QStringList currentGCPStrings;

1356 
1385 
QPointF residual = ( *gcpIt )>residual();

1357 

double residualX = residual.x();

1358 

if ( wldTransform )

1359 

{

1360 

residualX *= wldScaleX;

1361 

}

1362 

double residualY = residual.y();

1363 

if ( wldTransform )

1364 

{

1365 

residualY *= wldScaleY;

1366 

}

1367 

double residualTot = sqrt( residualX * residualX + residualY * residualY );


1386 
double residualTot = sqrt( residual.x() * residual.x() + residual.y() * residual.y() );

1368 
1387 

1369 
1388 
currentGCPStrings << QString::number(( *gcpIt )>id() );

1370 
1389 
if (( *gcpIt )>isEnabled() )

...  ...  
1376 
1395 
currentGCPStrings << tr( "no" );

1377 
1396 
}

1378 
1397 
currentGCPStrings << QString::number(( *gcpIt )>pixelCoords().x(), 'f', 2 ) << QString::number(( *gcpIt )>pixelCoords().y(), 'f', 2 ) << QString::number(( *gcpIt )>mapCoords().x(), 'f', 2 )\

1379 

<< QString::number(( *gcpIt )>mapCoords().y(), 'f', 2 ) << QString::number( residualX ) << QString::number( residualY ) << QString::number( residualTot );


1398 
<< QString::number(( *gcpIt )>mapCoords().y(), 'f', 2 ) << QString::number( residual.x() ) << QString::number( residual.y() ) << QString::number( residualTot );

1380 
1399 
gcpTable>addRow( currentGCPStrings );

1381 
1400 
}

1382 
1401 

...  ...  
1403 
1422 
return true;

1404 
1423 
}

1405 
1424 


1425 
void QgsGeorefPluginGui::updateTransformParamLabel()


1426 
{


1427 
if ( !mTransformParamLabel )


1428 
{


1429 
return;


1430 
}


1431 


1432 
QString transformName = convertTransformEnumToString( mGeorefTransform.transformParametrisation() );


1433 
QString labelString = tr( "Transform: " ) + transformName;


1434 


1435 
QgsPoint origin;


1436 
double scaleX, scaleY, rotation;


1437 
if ( mGeorefTransform.getOriginScaleRotation( origin, scaleX, scaleY, rotation ) )


1438 
{


1439 
labelString += " ";


1440 
labelString += tr( "Translation (%1, %2)" ).arg( origin.x() ).arg( origin.y() ); labelString += " ";


1441 
labelString += tr( "Scale (%1, %2)" ).arg( scaleX ).arg( scaleY ); labelString += " ";


1442 
labelString += tr( "Rotation: %1" ).arg( rotation );


1443 
}


1444 


1445 
double meanError = 0;


1446 
if ( calculateMeanError( meanError ) )


1447 
{


1448 
labelString += " ";


1449 
labelString += tr( "Mean error: %1" ).arg( meanError );


1450 
}


1451 
mTransformParamLabel>setText( labelString );


1452 
}


1453 

1406 
1454 
// Gdal script

1407 
1455 
void QgsGeorefPluginGui::showGDALScript( int argNum... )

1408 
1456 
{

...  ...  
1565 
1613 

1566 
1614 
bool QgsGeorefPluginGui::updateGeorefTransform()

1567 
1615 
{

1568 

if ( mGCPsDirty  !mGeorefTransform.parametersInitialized() )


1616 
std::vector<QgsPoint> mapCoords, pixelCoords;


1617 
if ( mGCPListWidget>gcpList() )


1618 
mGCPListWidget>gcpList()>createGCPVectors( mapCoords, pixelCoords );


1619 
else


1620 
return false;


1621 


1622 
// Parametrize the transform with GCPs


1623 
if ( !mGeorefTransform.updateParametersFromGCPs( mapCoords, pixelCoords ) )

1569 
1624 
{

1570 

std::vector<QgsPoint> mapCoords, pixelCoords;

1571 

if ( mGCPListWidget>gcpList() )

1572 

mGCPListWidget>gcpList()>createGCPVectors( mapCoords, pixelCoords );

1573 

else

1574 

return false;


1625 
return false;


1626 
}

1575 
1627 

1576 

// Parametrize the transform with GCPs

1577 

if ( !mGeorefTransform.updateParametersFromGCPs( mapCoords, pixelCoords ) )

1578 

{

1579 

return false;

1580 

}

1581 


1582 

mGCPsDirty = false;

1583 

}


1628 
mGCPsDirty = false;


1629 
updateTransformParamLabel();

1584 
1630 
return true;

1585 
1631 
}

1586 
1632 
