int QgsGml::pointsFromCoordinateString( QList<QgsPoint>& points, const QString& coordString ) const
{
//tuples are separated by space, x/y by ','
QStringList tuples = coordString.split( mTupleSeparator, QString::SkipEmptyParts );
QStringList tuples_coordinates;
double x, y;
bool conversionSuccess;
QStringList::const_iterator tupleIterator;
for ( tupleIterator = tuples.constBegin(); tupleIterator != tuples.constEnd(); ++tupleIterator )
{
tuples_coordinates = tupleIterator->split( mCoordinateSeparator, QString::SkipEmptyParts );
if ( tuples_coordinates.size() < 2 )
{
continue;
}
x = tuples_coordinates.at( 0 ).toDouble( &conversionSuccess );
if ( !conversionSuccess )
{
continue;
}
y = tuples_coordinates.at( 1 ).toDouble( &conversionSuccess );
if ( !conversionSuccess )
{
continue;
}
points.push_back( QgsPoint( x, y ) );
}
return 0;
}
void QgsMapToolCapture::canvasMapMoveEvent( QgsMapMouseEvent * e )
{
bool snapped = e->isSnapped();
QgsPoint point = e->mapPoint();
if ( !snapped )
{
delete mSnappingMarker;
mSnappingMarker = 0;
}
else
{
if ( !mSnappingMarker )
{
mSnappingMarker = new QgsVertexMarker( mCanvas );
mSnappingMarker->setIconType( QgsVertexMarker::ICON_CROSS );
mSnappingMarker->setColor( Qt::magenta );
mSnappingMarker->setPenWidth( 3 );
}
mSnappingMarker->setCenter( point );
}
if ( !mTempRubberBand && mCaptureCurve.numPoints() > 0 )
{
mTempRubberBand = createRubberBand( mCaptureMode == CapturePolygon ? QGis::Polygon : QGis::Line, true );
QgsPointV2 pt = mCaptureCurve.endPoint();
mTempRubberBand->addPoint( QgsPoint( pt.x(), pt.y() ) );
mTempRubberBand->addPoint( point );
}
if ( mCaptureMode != CapturePoint && mTempRubberBand && mCapturing )
{
mTempRubberBand->movePoint( point );
}
} // mouseMoveEvent
int QgsGml::pointsFromPosListString( QList<QgsPoint>& points, const QString& coordString, int dimension ) const
{
// coordinates separated by spaces
QStringList coordinates = coordString.split( ' ', QString::SkipEmptyParts );
if ( coordinates.size() % dimension != 0 )
{
QgsDebugMsg( "Wrong number of coordinates" );
}
int ncoor = coordinates.size() / dimension;
for ( int i = 0; i < ncoor; i++ )
{
bool conversionSuccess;
double x = coordinates.value( i * dimension ).toDouble( &conversionSuccess );
if ( !conversionSuccess )
{
continue;
}
double y = coordinates.value( i * dimension + 1 ).toDouble( &conversionSuccess );
if ( !conversionSuccess )
{
continue;
}
points.append( QgsPoint( x, y ) );
}
return 0;
}
double QgsComposerScaleBar::mapDiagonal() const
{
if ( !mComposerMap )
{
return 0.0;
}
QgsRectangle composerMapRect = mComposerMap->extent();
if ( mUnits == MapUnits )
{
return sqrt( composerMapRect.width() * composerMapRect.width() + composerMapRect.height() * composerMapRect.height() );
}
else
{
QgsDistanceArea da;
da.setProjectionsEnabled( true );
da.setSourceCrs( mComposerMap->mapRenderer()->destinationCrs().srsid() );
QSettings s;
da.setEllipsoid( s.value( "/qgis/measure/ellipsoid", "WGS84" ).toString() );
double measure = da.measureLine( QgsPoint( composerMapRect.xMinimum(), composerMapRect.yMaximum() ), QgsPoint( composerMapRect.xMaximum(), composerMapRect.yMinimum() ) );
if ( mUnits == Feet )
{
measure /= 0.3048;
}
return measure;
}
}
void RgShortestPathWidget::setFrontPoint( const QgsPoint& pt )
{
mPlugin->iface()->mapCanvas()->unsetMapTool( mFrontPointMapTool );
mFrontPointLineEdit->setText( QString( "(" ) + QString().setNum( pt.x() ) + QString( "," ) +
QString().setNum( pt.y() ) + QString( ")" ) );
mFrontPoint = pt;
double mupp = mPlugin->iface()->mapCanvas()->getCoordinateTransform()->mapUnitsPerPixel() * 2;
mrbFrontPoint->reset( QGis::Polygon );
mrbFrontPoint->addPoint( QgsPoint( pt.x() - mupp, pt.y() - mupp ), false );
mrbFrontPoint->addPoint( QgsPoint( pt.x() + mupp, pt.y() - mupp ), false );
mrbFrontPoint->addPoint( QgsPoint( pt.x() + mupp, pt.y() + mupp ), false );
mrbFrontPoint->addPoint( QgsPoint( pt.x() - mupp, pt.y() + mupp ), true );
mrbFrontPoint->show();
} //RgShortestPathWidget::setFrontPoint( const QgsPoint& pt )
void testSnapModeAll()
{
QgsMapSettings mapSettings;
mapSettings.setOutputSize( QSize( 100, 100 ) );
mapSettings.setExtent( QgsRectangle( 0, 0, 1, 1 ) );
QVERIFY( mapSettings.hasValidSettings() );
QgsSnappingUtils u;
QgsSnappingConfig snappingConfig = u.config();
u.setMapSettings( mapSettings );
snappingConfig.setMode( QgsSnappingConfig::AllLayers );
u.setConfig( snappingConfig );
// right now there are no layers in map settings - snapping will fail
QgsPointLocator::Match m = u.snapToMap( QPoint( 100, 100 ) );
QVERIFY( !m.isValid() );
// now check with our layer
mapSettings.setLayers( QStringList() << mVL->id() );
u.setMapSettings( mapSettings );
QgsPointLocator::Match m2 = u.snapToMap( QPoint( 100, 100 ) );
QVERIFY( m2.isValid() );
QCOMPARE( m2.point(), QgsPoint( 1, 0 ) );
}
unsigned char* QgsDistanceArea::measureLine( unsigned char* feature, double* area, bool hasZptr )
{
unsigned char *ptr = feature + 5;
unsigned int nPoints = *(( int* )ptr );
ptr = feature + 9;
QList<QgsPoint> points;
double x, y;
QgsDebugMsg( "This feature WKB has " + QString::number( nPoints ) + " points" );
// Extract the points from the WKB format into the vector
for ( unsigned int i = 0; i < nPoints; ++i )
{
x = *(( double * ) ptr );
ptr += sizeof( double );
y = *(( double * ) ptr );
ptr += sizeof( double );
if ( hasZptr )
{
// totally ignore Z value
ptr += sizeof( double );
}
points.append( QgsPoint( x, y ) );
}
*area = measureLine( points );
return ptr;
}
static QgsCurve *_transform_ring_to_new_base( const QgsCurve &curve, const QgsPoint &pt0, const QMatrix4x4 *toNewBase )
{
int count = curve.numPoints();
QVector<QgsPoint> pts;
pts.reserve( count );
QgsVertexId::VertexType vt;
for ( int i = 0; i < count; ++i )
{
QgsPoint pt;
curve.pointAt( i, pt, vt );
QgsPoint pt2( QgsWkbTypes::PointZ, pt.x() - pt0.x(), pt.y() - pt0.y(), std::isnan( pt.z() ) ? 0 : pt.z() - pt0.z() );
QVector4D v( pt2.x(), pt2.y(), pt2.z(), 0 );
if ( toNewBase )
v = toNewBase->map( v );
// we also round coordinates before passing them to poly2tri triangulation in order to fix possible numerical
// stability issues. We had crashes with nearly collinear points where one of the points was off by a tiny bit (e.g. by 1e-20).
// See TestQgsTessellator::testIssue17745().
//
// A hint for a similar issue: https://github.com/greenm01/poly2tri/issues/99
//
// The collinear tests uses epsilon 1e-12. Seems rounding to 12 places you still
// can get problems with this test when points are pretty much on a straight line.
// I suggest you round to 10 decimals for stability and you can live with that
// precision.
pts << QgsPoint( QgsWkbTypes::PointZ, _round_coord( v.x() ), _round_coord( v.y() ), _round_coord( v.z() ) );
}
return new QgsLineString( pts );
}
void eval_geometry_data()
{
QTest::addColumn<QString>( "string" );
QTest::addColumn<void*>( "geomptr" );
QTest::addColumn<bool>( "evalError" );
QTest::addColumn<double>( "result" );
QgsPoint point( 123, 456 );
QgsPolyline line;
line << QgsPoint( 1, 1 ) << QgsPoint( 4, 2 ) << QgsPoint( 3, 1 );
QTest::newRow( "geom x" ) << "$x" << ( void* ) QgsGeometry::fromPoint( point ) << false << 123.;
QTest::newRow( "geom y" ) << "$y" << ( void* ) QgsGeometry::fromPoint( point ) << false << 456.;
QTest::newRow( "geom xat" ) << "xat(-1)" << ( void* ) QgsGeometry::fromPolyline( line ) << false << 3.;
QTest::newRow( "geom yat" ) << "yat(1)" << ( void* ) QgsGeometry::fromPolyline( line ) << false << 2.;
}
void RgShortestPathWidget::setFrontPoint( const QgsPoint& pt )
{
mPlugin->iface()->mapCanvas()->unsetMapTool( mFrontPointMapTool );
mFrontPointLineEdit->setText( QStringLiteral( "(%1, %2)" ).arg( QString::number( pt.x(), 'f' ),
QString::number( pt.y(), 'f' ) ) );
mFrontPoint = pt;
double mupp = mPlugin->iface()->mapCanvas()->getCoordinateTransform()->mapUnitsPerPixel() * 2;
mrbFrontPoint->reset( QgsWkbTypes::PolygonGeometry );
mrbFrontPoint->addPoint( QgsPoint( pt.x() - mupp, pt.y() - mupp ), false );
mrbFrontPoint->addPoint( QgsPoint( pt.x() + mupp, pt.y() - mupp ), false );
mrbFrontPoint->addPoint( QgsPoint( pt.x() + mupp, pt.y() + mupp ), false );
mrbFrontPoint->addPoint( QgsPoint( pt.x() - mupp, pt.y() + mupp ), true );
mrbFrontPoint->show();
} //RgShortestPathWidget::setFrontPoint( const QgsPoint& pt )
double QgsComposerScaleBar::mapWidth() const
{
if ( !mComposerMap )
{
return 0.0;
}
QgsRectangle composerMapRect = mComposerMap->extent();
if ( mUnits == MapUnits )
{
return composerMapRect.width();
}
else
{
QgsDistanceArea da;
da.setEllipsoidalMode( mComposerMap->mapRenderer()->hasCrsTransformEnabled() );
da.setSourceCrs( mComposerMap->mapRenderer()->destinationCrs().srsid() );
da.setEllipsoid( QgsProject::instance()->readEntry( "Measure", "/Ellipsoid", "WGS84" ) );
double measure = da.measureLine( QgsPoint( composerMapRect.xMinimum(), composerMapRect.yMinimum() ), QgsPoint( composerMapRect.xMaximum(), composerMapRect.yMinimum() ) );
if ( mUnits == Feet )
{
measure /= 0.3048;
}
return measure;
}
}
const unsigned char* QgsDistanceArea::measureLine( const unsigned char* feature, double* area, bool hasZptr )
{
QgsConstWkbPtr wkbPtr( feature + 1 + sizeof( int ) );
int nPoints;
wkbPtr >> nPoints;
QList<QgsPoint> points;
double x, y;
QgsDebugMsg( "This feature WKB has " + QString::number( nPoints ) + " points" );
// Extract the points from the WKB format into the vector
for ( int i = 0; i < nPoints; ++i )
{
wkbPtr >> x >> y;
if ( hasZptr )
{
// totally ignore Z value
wkbPtr += sizeof( double );
}
points.append( QgsPoint( x, y ) );
}
*area = measureLine( points );
return wkbPtr;
}
void QgsMapToolPinLabels::highlightLabel( const QgsLabelPosition& labelpos,
const QString& id,
const QColor& color )
{
QgsRectangle rect = labelpos.labelRect;
QgsRubberBand *rb = new QgsRubberBand( mCanvas, QGis::Polygon );
rb->addPoint( QgsPoint( rect.xMinimum(), rect.yMinimum() ) );
rb->addPoint( QgsPoint( rect.xMinimum(), rect.yMaximum() ) );
rb->addPoint( QgsPoint( rect.xMaximum(), rect.yMaximum() ) );
rb->addPoint( QgsPoint( rect.xMaximum(), rect.yMinimum() ) );
rb->addPoint( QgsPoint( rect.xMinimum(), rect.yMinimum() ) );
rb->setColor( color );
rb->setWidth( 0 );
rb->show();
mHighlights.insert( id, rb );
}
void QgsRubberBand::setToCanvasRectangle( const QRect& rect )
{
if ( !mMapCanvas )
{
return;
}
const QgsMapToPixel* transform = mMapCanvas->getCoordinateTransform();
QgsPoint ll = transform->toMapCoordinates( rect.left(), rect.bottom() );
QgsPoint ur = transform->toMapCoordinates( rect.right(), rect.top() );
reset( QGis::Polygon );
addPoint( ll, false );
addPoint( QgsPoint( ur.x(), ll.y() ), false );
addPoint( ur, false );
addPoint( QgsPoint( ll.x(), ur.y() ), true );
}
QgsPoint QgsLineString::startPoint() const
{
if ( numPoints() < 1 )
{
return QgsPoint();
}
return pointN( 0 );
}
QgsPoint QgsLineString::endPoint() const
{
if ( numPoints() < 1 )
{
return QgsPoint();
}
return pointN( numPoints() - 1 );
}
/**
* Check to see if the point is within the selection rectangle
*/
bool QgsDelimitedTextProvider::boundsCheck( double x, double y )
{
// no selection rectangle or geometry => always in the bounds
if ( mSelectionRectangle.isEmpty() || !mFetchGeom )
return true;
return mSelectionRectangle.contains( QgsPoint( x, y ) );
}
void testNearestEdge()
{
QgsPointLocator loc( mVL );
QgsPoint pt( 1.1, 0.5 );
QgsPointLocator::Match m = loc.nearestEdge( pt, 999 );
QVERIFY( m.isValid() );
QVERIFY( m.hasEdge() );
QCOMPARE( m.layer(), mVL );
QCOMPARE( m.featureId(), ( QgsFeatureId )1 );
QCOMPARE( m.point(), QgsPoint( 1, 0.5 ) );
QCOMPARE( m.distance(), 0.1 );
QCOMPARE( m.vertexIndex(), 1 );
QgsPoint pt1, pt2;
m.edgePoints( pt1, pt2 );
QCOMPARE( pt1, QgsPoint( 1, 0 ) );
QCOMPARE( pt2, QgsPoint( 1, 1 ) );
}
QgsMapToolCircularStringRadius::QgsMapToolCircularStringRadius( QgsMapToolCapture *parentTool, QgsMapCanvas *canvas, CaptureMode mode )
: QgsMapToolAddCircularString( parentTool, canvas, mode )
, mTemporaryEndPoint( QgsPoint() )
, mRadius( 0.0 )
{
}
QgsPoint QgsCompoundCurve::endPoint() const
{
if ( mCurves.empty() )
{
return QgsPoint();
}
return mCurves.at( mCurves.size() - 1 )->endPoint();
}
QgsPoint QgsCompoundCurve::startPoint() const
{
if ( mCurves.empty() )
{
return QgsPoint();
}
return mCurves.at( 0 )->startPoint();
}
void eval_geometry_method_data()
{
QTest::addColumn<QString>( "string" );
QTest::addColumn<void*>( "geomptr" );
QTest::addColumn<bool>( "evalError" );
QTest::addColumn<bool>( "needGeom" );
QTest::addColumn<void*>( "resultptr" );
QgsPolyline polygon_ring;
polygon_ring << QgsPoint( 0, 0 ) << QgsPoint( 10, 10 ) << QgsPoint( 10, 0 ) << QgsPoint( 0, 0 );
QgsPolygon polygon;
polygon << polygon_ring;
QgsGeometry* geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "buffer" ) << "buffer( $geometry, 1.0, 3)" << ( void* ) geom << false << true << ( void* ) geom->buffer( 1.0, 3 );
geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "buffer" ) << "buffer( $geometry, 2.0)" << ( void* ) geom << false << true << ( void* ) geom->buffer( 2.0, 8 );
QgsPoint point1( 10, 20 );
QgsPoint point2( 30, 20 );
QgsGeometry* pnt1 = QgsGeometry::fromPoint( point1 );
QgsGeometry* pnt2 = QgsGeometry::fromPoint( point2 );
QTest::newRow( "union" ) << "union( $geometry, geomFromWKT('" + pnt2->exportToWkt() + "') )" << ( void* ) pnt1 << false << true << ( void* ) pnt1->combine( pnt2 );
geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "intersection" ) << "intersection( $geometry, geomFromWKT('POLYGON((0 0, 0 10, 10 0, 0 0))') )" << ( void* ) geom << false << true << ( void* ) QgsGeometry::fromWkt( "POLYGON ((0 0,5 5,10 0,0 0))" );
geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "difference" ) << "difference( $geometry, geomFromWKT('POLYGON((0 0, 0 10, 10 0, 0 0))') )" << ( void* ) geom << false << true << ( void* ) QgsGeometry::fromWkt( "POLYGON ((5 5,10 10,10 0,5 5))" );
geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "symDifference" ) << "symDifference( $geometry, geomFromWKT('POLYGON((0 0, 0 10, 10 0, 0 0))') )" << ( void* ) geom << false << true << ( void* ) QgsGeometry::fromWkt( "MULTIPOLYGON(((5 5,0 0,0 10,5 5)),((5 5,10 10,10 0,5 5)))" );
geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "centroid polygon" ) << "centroid( $geometry )" << ( void* ) geom << false << true << ( void* ) geom->centroid();
geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "centroid self intersecting polygon" ) << "centroid( geomFromWKT('POLYGON((0 0, 0 2, 2 -0.1, 2 2.1, 0 0))') )" << ( void* ) geom << false << false << ( void* ) QgsGeometry::fromWkt( "POINT (8.0 1.0)" );
geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "centroid multi polygon" ) << "centroid( geomFromWKT('MULTIPOLYGON(((0 0,0 1,1 1,1 0,0 0)),((2 0,2 1,3 1,3 0,2 0)))') )" << ( void* ) geom << false << false << ( void* ) QgsGeometry::fromWkt( "POINT (1.5 0.5)" );
geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "convexHull simple" ) << "convexHull( $geometry )" << ( void* ) geom << false << true << ( void* ) geom->convexHull();
geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "convexHull multi" ) << "convexHull( geomFromWKT('GEOMETRYCOLLECTION(POINT(0 1), POINT(0 0), POINT(1 0), POINT(1 1))') )" << ( void* ) geom << false << false << ( void* ) QgsGeometry::fromWkt( "POLYGON ((0 0,0 1,1 1,1 0,0 0))" );
geom = QgsGeometry::fromPolygon( polygon );
QTest::newRow( "bounds" ) << "bounds( $geometry )" << ( void* ) geom << false << true << ( void* ) QgsGeometry::fromRect( geom->boundingBox() );
}
void QgsStatusBarCoordinatesWidget::validateCoordinates()
{
if ( !mMapCanvas )
{
return;
}
if ( mLineEdit->text() == "dizzy" )
{
// sometimes you may feel a bit dizzy...
if ( mDizzyTimer->isActive() )
{
mDizzyTimer->stop();
mMapCanvas->setSceneRect( mMapCanvas->viewport()->rect() );
mMapCanvas->setTransform( QTransform() );
}
else
{
mDizzyTimer->start( 100 );
}
return;
}
else if ( mLineEdit->text() == "retro" )
{
mMapCanvas->setProperty( "retro", !mMapCanvas->property( "retro" ).toBool() );
refreshMapCanvas();
return;
}
bool xOk = false;
bool yOk = false;
double x = 0., y = 0.;
QString coordText = mLineEdit->text();
coordText.replace( QRegExp( " {2,}" ), " " );
QStringList parts = coordText.split( ',' );
if ( parts.size() == 2 )
{
x = parts.at( 0 ).toDouble( &xOk );
y = parts.at( 1 ).toDouble( &yOk );
}
if ( !xOk || !yOk )
{
parts = coordText.split( ' ' );
if ( parts.size() == 2 )
{
x = parts.at( 0 ).toDouble( &xOk );
y = parts.at( 1 ).toDouble( &yOk );
}
}
if ( !xOk || !yOk )
return;
mMapCanvas->setCenter( QgsPoint( x, y ) );
mMapCanvas->refresh();
}
QgsPoint QgsMapToPixel::transform( const QgsPoint& p ) const
{
double dx = p.x();
double dy = p.y();
transformInPlace( dx, dy );
// QgsDebugMsg(QString("Point to pixel...X : %1-->%2, Y: %3 -->%4").arg(p.x()).arg(dx).arg(p.y()).arg(dy));
return QgsPoint( dx, dy );
}
void TestQgsGeometryUtils::testAngleThreePoints()
{
QgsPoint p1( 0, 0 );
QgsPoint p2( 1, 0 );
QgsPoint p3( 1, 1 );
QGSCOMPARENEAR( QgsGeometryUtils::angleBetweenThreePoints( p1.x(), p1.y(), p2.x(), p2.y(), p3.x(), p3.y() ), M_PI / 2.0, 0.00000001 );
p3 = QgsPoint( 1, -1 );
QGSCOMPARENEAR( QgsGeometryUtils::angleBetweenThreePoints( p1.x(), p1.y(), p2.x(), p2.y(), p3.x(), p3.y() ), 3 * M_PI / 2.0, 0.00000001 );
p3 = QgsPoint( 2, 0 );
QGSCOMPARENEAR( QgsGeometryUtils::angleBetweenThreePoints( p1.x(), p1.y(), p2.x(), p2.y(), p3.x(), p3.y() ), M_PI, 0.00000001 );
p3 = QgsPoint( 0, 0 );
QGSCOMPARENEAR( QgsGeometryUtils::angleBetweenThreePoints( p1.x(), p1.y(), p2.x(), p2.y(), p3.x(), p3.y() ), 0.0, 0.00000001 );
p3 = QgsPoint( 1, 0 );
//undefined, but want no crash
( void )QgsGeometryUtils::angleBetweenThreePoints( p1.x(), p1.y(), p2.x(), p2.y(), p3.x(), p3.y() );
p2 = QgsPoint( 0, 0 );
( void )QgsGeometryUtils::angleBetweenThreePoints( p1.x(), p1.y(), p2.x(), p2.y(), p3.x(), p3.y() );
}
QgsGeometry::OperationResult QgsVectorLayerEditUtils::addPart( const QList<QgsPointXY> &points, QgsFeatureId featureId )
{
QgsPointSequence l;
for ( QList<QgsPointXY>::const_iterator it = points.constBegin(); it != points.constEnd(); ++it )
{
l << QgsPoint( *it );
}
return addPart( l, featureId );
}
int QgsMapToolCapture::addCurve( QgsCurveV2* c )
{
if ( !c )
{
return 1;
}
if ( !mRubberBand )
{
mRubberBand = createRubberBand( mCaptureMode == CapturePolygon ? QGis::Polygon : QGis::Line );
}
QgsLineStringV2* lineString = c->curveToLine();
QList<QgsPointV2> linePoints;
lineString->points( linePoints );
delete lineString;
QList<QgsPointV2>::const_iterator ptIt = linePoints.constBegin();
for ( ; ptIt != linePoints.constEnd(); ++ptIt )
{
mRubberBand->addPoint( QgsPoint( ptIt->x(), ptIt->y() ) );
}
if ( !mTempRubberBand )
{
mTempRubberBand = createRubberBand( mCaptureMode == CapturePolygon ? QGis::Polygon : QGis::Line, true );
}
else
{
mTempRubberBand->reset();
}
QgsPointV2 endPt = c->endPoint();
mTempRubberBand->addPoint( QgsPoint( endPt.x(), endPt.y() ) ); //add last point of c
//transform back to layer CRS in case map CRS and layer CRS are different
QgsVectorLayer* vlayer = qobject_cast<QgsVectorLayer *>( mCanvas->currentLayer() );
const QgsCoordinateTransform* ct = mCanvas->mapSettings().layerTransform( vlayer );
if ( ct )
{
c->transform( *ct, QgsCoordinateTransform::ReverseTransform );
}
mCaptureCurve.addCurve( c );
return 0;
}
void QgsMapToolRotateFeature::canvasReleaseEvent( QMouseEvent * e )
{
Q_UNUSED( e );
if ( !mRubberBand )
{
return;
}
QgsVectorLayer* vlayer = currentVectorLayer();
if ( !vlayer )
{
return;
}
//calculations for affine transformation
double angle = -1 * mRotation * ( PI / 180 );
QgsPoint anchorPoint = toLayerCoordinates( vlayer, mStartPointMapCoords );
double a = cos( angle );
double b = -1 * sin( angle );
double c = anchorPoint.x() - cos( angle ) * anchorPoint.x() + sin( angle ) * anchorPoint.y();
double d = sin( angle );
double ee = cos( angle );
double f = anchorPoint.y() - sin( angle ) * anchorPoint.x() - cos( angle ) * anchorPoint.y();
vlayer->beginEditCommand( tr( "Features Rotated" ) );
int start;
if ( vlayer->geometryType() == 2 )
{
start = 1;
}
else
{
start = 0;
}
int i = 0;
foreach ( QgsFeatureId id, mRotatedFeatures )
{
QgsFeature feat;
vlayer->getFeatures( QgsFeatureRequest().setFilterFid( id ) ).nextFeature( feat );
QgsGeometry* geom = feat.geometry();
i = start;
QgsPoint vertex = geom->vertexAt( i );
while ( vertex != QgsPoint( 0, 0 ) )
{
double newX = a * vertex.x() + b * vertex.y() + c;
double newY = d * vertex.x() + ee * vertex.y() + f;
vlayer->moveVertex( newX, newY, id, i );
i = i + 1;
vertex = geom->vertexAt( i );
}
}
bool QgsRasterProjector::approximateSrcRowCol( int theDestRow, int theDestCol, int *theSrcRow, int *theSrcCol )
{
int myMatrixRow = matrixRow( theDestRow );
int myMatrixCol = matrixCol( theDestCol );
if ( myMatrixRow > mHelperTopRow )
{
// TODO: make it more robust (for random, not sequential reading)
nextHelper();
}
double myDestY = mDestExtent.yMaximum() - ( theDestRow + 0.5 ) * mDestYRes;
// See the schema in javax.media.jai.WarpGrid doc (but up side down)
// TODO: use some kind of cache of values which can be reused
double myDestXMin, myDestYMin, myDestXMax, myDestYMax;
destPointOnCPMatrix( myMatrixRow + 1, myMatrixCol, &myDestXMin, &myDestYMin );
destPointOnCPMatrix( myMatrixRow, myMatrixCol + 1, &myDestXMax, &myDestYMax );
double yfrac = ( myDestY - myDestYMin ) / ( myDestYMax - myDestYMin );
QgsPoint &myTop = pHelperTop[theDestCol];
QgsPoint &myBot = pHelperBottom[theDestCol];
// Warning: this is very SLOW compared to the following code!:
//double mySrcX = myBot.x() + (myTop.x() - myBot.x()) * yfrac;
//double mySrcY = myBot.y() + (myTop.y() - myBot.y()) * yfrac;
double tx = myTop.x();
double ty = myTop.y();
double bx = myBot.x();
double by = myBot.y();
double mySrcX = bx + ( tx - bx ) * yfrac;
double mySrcY = by + ( ty - by ) * yfrac;
if ( !mExtent.contains( QgsPoint( mySrcX, mySrcY ) ) )
{
return false;
}
// TODO: check again cell selection (coor is in the middle)
*theSrcRow = ( int ) floor(( mSrcExtent.yMaximum() - mySrcY ) / mSrcYRes );
*theSrcCol = ( int ) floor(( mySrcX - mSrcExtent.xMinimum() ) / mSrcXRes );
// For now silently correct limits to avoid crashes
// TODO: review
// should not happen
if ( *theSrcRow >= mSrcRows ) return false;
if ( *theSrcRow < 0 ) return false;
if ( *theSrcCol >= mSrcCols ) return false;
if ( *theSrcCol < 0 ) return false;
return true;
}
void TestQgsMapToPixel::rotation()
{
QgsMapToPixel m2p( 1, 5, 5, 10, 10, 90 );
QgsPoint p( 5, 5 ); // in geographical units
QgsPoint d = m2p.transform( p ); // to device pixels
QCOMPARE( d.x(), 5.0 ); // center doesn't move
QCOMPARE( d.y(), 5.0 );
QgsPoint b = m2p.toMapCoordinatesF( d.x(), d.y() ); // transform back
QCOMPARE( p, b );
m2p.transform( &p ); // in place transform
QCOMPARE( p, d );
m2p.setParameters( 0.1, 5, 5, 10, 10, -90 );
p = m2p.toMapCoordinates( 5, 5 );
QCOMPARE( p.x(), 5.0 ); // center doesn't move
QCOMPARE( p.y(), 5.0 );
d = m2p.transform( p );
QCOMPARE( d, QgsPoint( 5, 5 ) );
p = m2p.toMapCoordinates( 10, 0 );
QCOMPARE( p.x(), 5.5 ); // corner scales and rotates
QCOMPARE( p.y(), 4.5 );
d = m2p.transform( p );
QCOMPARE( d, QgsPoint( 10, 0 ) );
m2p.setParameters( 0.1, 5, 5, 10, 10, 360 );
p = m2p.toMapCoordinates( 10, 0 );
QCOMPARE( p.x(), 5.5 ); // corner scales
QCOMPARE( p.y(), 5.5 );
d = m2p.transform( p );
QCOMPARE( d, QgsPoint( 10, 0 ) );
m2p.setParameters( 0.1, 5, 5, 10, 10, 0 );
p = m2p.toMapCoordinates( 10, 0 );
QCOMPARE( p.x(), 5.5 ); // corner scales
QCOMPARE( p.y(), 5.5 );
d = m2p.transform( p );
QCOMPARE( d, QgsPoint( 10, 0 ) );
}
