QgsPointSequence QgsRegularPolygon::points() const { QgsPointSequence pts; if ( isEmpty() ) { return pts; } double azimuth = mCenter.azimuth( mFirstVertex ); double azimuth_add = centralAngle(); // TODO: inclination unsigned int n = 1; while ( n <= mNumberSides ) { pts.push_back( mCenter.project( mRadius, azimuth ) ); azimuth += azimuth_add; if ( ( azimuth_add > 0 ) && ( azimuth > 180.0 ) ) { azimuth -= 360.0; } n++; } return pts; }
QgsRectangle QgsCircularString::segmentBoundingBox( const QgsPointV2 &pt1, const QgsPointV2 &pt2, const QgsPointV2 &pt3 ) { double centerX, centerY, radius; QgsGeometryUtils::circleCenterRadius( pt1, pt2, pt3, radius, centerX, centerY ); double p1Angle = QgsGeometryUtils::ccwAngle( pt1.y() - centerY, pt1.x() - centerX ); if ( p1Angle > 360 ) { p1Angle -= 360; } double p2Angle = QgsGeometryUtils::ccwAngle( pt2.y() - centerY, pt2.x() - centerX ); if ( p2Angle > 360 ) { p2Angle -= 360; } double p3Angle = QgsGeometryUtils::ccwAngle( pt3.y() - centerY, pt3.x() - centerX ); if ( p3Angle > 360 ) { p3Angle -= 360; } //start point, end point and compass points in between can be on bounding box QgsRectangle bbox( pt1.x(), pt1.y(), pt1.x(), pt1.y() ); bbox.combineExtentWith( pt3.x(), pt3.y() ); QgsPointSequence compassPoints = compassPointsOnSegment( p1Angle, p2Angle, p3Angle, centerX, centerY, radius ); QgsPointSequence::const_iterator cpIt = compassPoints.constBegin(); for ( ; cpIt != compassPoints.constEnd(); ++cpIt ) { bbox.combineExtentWith( cpIt->x(), cpIt->y() ); } return bbox; }
void QgsMapToolAddCircularString::activate() { if ( mParentTool ) { mParentTool->deleteTempRubberBand(); if ( mPoints.isEmpty() ) { // if the parent tool has a curve, use its last point as the first point in this curve const QgsCompoundCurve *compoundCurve = mParentTool->captureCurve(); if ( compoundCurve && compoundCurve->nCurves() > 0 ) { const QgsCurve *curve = compoundCurve->curveAt( compoundCurve->nCurves() - 1 ); if ( curve ) { //mParentTool->captureCurve() is in layer coordinates, but we need map coordinates QgsPointV2 endPointLayerCoord = curve->endPoint(); QgsPoint mapPoint = toMapCoordinates( mCanvas->currentLayer(), QgsPoint( endPointLayerCoord.x(), endPointLayerCoord.y() ) ); mPoints.append( QgsPointV2( mapPoint ) ); if ( !mTempRubberBand ) { mTempRubberBand = createGeometryRubberBand( ( mode() == CapturePolygon ) ? QgsWkbTypes::PolygonGeometry : QgsWkbTypes::LineGeometry, true ); mTempRubberBand->show(); } QgsCircularString *c = new QgsCircularString(); QgsPointSequence rubberBandPoints = mPoints; rubberBandPoints.append( QgsPointV2( mapPoint ) ); c->setPoints( rubberBandPoints ); mTempRubberBand->setGeometry( c ); } } } } QgsMapToolCapture::activate(); }
void QgsCircularString::addToPainterPath( QPainterPath &path ) const { int nPoints = numPoints(); if ( nPoints < 1 ) { return; } if ( path.isEmpty() || path.currentPosition() != QPointF( mX[0], mY[0] ) ) { path.moveTo( QPointF( mX[0], mY[0] ) ); } for ( int i = 0; i < ( nPoints - 2 ) ; i += 2 ) { QgsPointSequence pt; segmentize( QgsPointV2( mX[i], mY[i] ), QgsPointV2( mX[i + 1], mY[i + 1] ), QgsPointV2( mX[i + 2], mY[i + 2] ), pt ); for ( int j = 1; j < pt.size(); ++j ) { path.lineTo( pt.at( j ).x(), pt.at( j ).y() ); } //arcTo( path, QPointF( mX[i], mY[i] ), QPointF( mX[i + 1], mY[i + 1] ), QPointF( mX[i + 2], mY[i + 2] ) ); } //if number of points is even, connect to last point with straight line (even though the circular string is not valid) if ( nPoints % 2 == 0 ) { path.lineTo( mX[ nPoints - 1 ], mY[ nPoints - 1 ] ); } }
void QgsCircularString::points( QgsPointSequence &pts ) const { pts.clear(); int nPts = numPoints(); for ( int i = 0; i < nPts; ++i ) { pts.push_back( pointN( i ) ); } }
int QgsVectorLayerEditUtils::addRing( const QList<QgsPoint>& ring, const QgsFeatureIds& targetFeatureIds, QgsFeatureId* modifiedFeatureId ) { QgsLineString* ringLine = new QgsLineString(); QgsPointSequence ringPoints; QList<QgsPoint>::const_iterator ringIt = ring.constBegin(); for ( ; ringIt != ring.constEnd(); ++ringIt ) { ringPoints.append( QgsPointV2( ringIt->x(), ringIt->y() ) ); } ringLine->setPoints( ringPoints ); return addRing( ringLine, targetFeatureIds, modifiedFeatureId ); }
QgsTriangle QgsRegularPolygon::toTriangle() const { if ( isEmpty() || ( mNumberSides != 3 ) ) { return QgsTriangle(); } QgsPointSequence pts; pts = points(); return QgsTriangle( pts.at( 0 ), pts.at( 1 ), pts.at( 2 ) ); }
void QgsMapToolCircularStringCurvePoint::cadCanvasReleaseEvent( QgsMapMouseEvent *e ) { QgsPointV2 mapPoint( e->mapPoint() ); if ( e->button() == Qt::LeftButton ) { mPoints.append( mapPoint ); if ( !mCenterPointRubberBand && mShowCenterPointRubberBand ) { createCenterPointRubberBand(); } if ( !mPoints.isEmpty() ) { if ( !mTempRubberBand ) { mTempRubberBand = createGeometryRubberBand( ( mode() == CapturePolygon ) ? QgsWkbTypes::PolygonGeometry : QgsWkbTypes::LineGeometry, true ); mTempRubberBand->show(); } QgsCircularString *c = new QgsCircularString(); QgsPointSequence rubberBandPoints = mPoints.mid( mPoints.size() - 1 - ( mPoints.size() + 1 ) % 2 ); rubberBandPoints.append( mapPoint ); c->setPoints( rubberBandPoints ); mTempRubberBand->setGeometry( c ); } if ( mPoints.size() > 1 && mPoints.size() % 2 ) { if ( !mRubberBand ) { mRubberBand = createGeometryRubberBand( ( mode() == CapturePolygon ) ? QgsWkbTypes::PolygonGeometry : QgsWkbTypes::LineGeometry ); mRubberBand->show(); } QgsCircularString *c = new QgsCircularString(); QgsPointSequence rubberBandPoints = mPoints; rubberBandPoints.append( mapPoint ); c->setPoints( rubberBandPoints ); mRubberBand->setGeometry( c ); removeCenterPointRubberBand(); } } else if ( e->button() == Qt::RightButton ) { deactivate(); if ( mParentTool ) { mParentTool->canvasReleaseEvent( e ); } } }
void QgsLineString::setPoints( const QgsPointSequence &points ) { clearCache(); //set bounding box invalid if ( points.isEmpty() ) { clear(); return; } //get wkb type from first point const QgsPoint &firstPt = points.at( 0 ); bool hasZ = firstPt.is3D(); bool hasM = firstPt.isMeasure(); setZMTypeFromSubGeometry( &firstPt, QgsWkbTypes::LineString ); mX.resize( points.size() ); mY.resize( points.size() ); if ( hasZ ) { mZ.resize( points.size() ); } else { mZ.clear(); } if ( hasM ) { mM.resize( points.size() ); } else { mM.clear(); } for ( int i = 0; i < points.size(); ++i ) { mX[i] = points.at( i ).x(); mY[i] = points.at( i ).y(); if ( hasZ ) { double z = points.at( i ).z(); mZ[i] = std::isnan( z ) ? 0 : z; } if ( hasM ) { double m = points.at( i ).m(); mM[i] = std::isnan( m ) ? 0 : m; } } }
int QgsMapToolCapture::addCurve( QgsCurve *c ) { if ( !c ) { return 1; } if ( !mRubberBand ) { mRubberBand = createRubberBand( mCaptureMode == CapturePolygon ? QgsWkbTypes::PolygonGeometry : QgsWkbTypes::LineGeometry ); } QgsLineString *lineString = c->curveToLine(); QgsPointSequence linePoints; lineString->points( linePoints ); delete lineString; QgsPointSequence::const_iterator ptIt = linePoints.constBegin(); for ( ; ptIt != linePoints.constEnd(); ++ptIt ) { mRubberBand->addPoint( QgsPointXY( ptIt->x(), ptIt->y() ) ); } if ( !mTempRubberBand ) { mTempRubberBand = createRubberBand( mCaptureMode == CapturePolygon ? QgsWkbTypes::PolygonGeometry : QgsWkbTypes::LineGeometry, true ); } else { mTempRubberBand->reset(); } QgsPoint endPt = c->endPoint(); mTempRubberBand->addPoint( QgsPointXY( 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() ); QgsCoordinateTransform ct = mCanvas->mapSettings().layerTransform( vlayer ); if ( ct.isValid() ) { c->transform( ct, QgsCoordinateTransform::ReverseTransform ); } mCaptureCurve.addCurve( c ); for ( int i = 0; i < c->length(); ++i ) mSnappingMatches.append( QgsPointLocator::Match() ); return 0; }
void QgsCompoundCurve::points( QgsPointSequence &pts ) const { pts.clear(); if ( mCurves.empty() ) { return; } mCurves[0]->points( pts ); for ( int i = 1; i < mCurves.size(); ++i ) { QgsPointSequence pList; mCurves[i]->points( pList ); pList.removeFirst(); //first vertex already added in previous line pts.append( pList ); } }
QList<QgsTriangle> QgsRegularPolygon::triangulate() const { QList<QgsTriangle> l_tri; if ( isEmpty() ) { return l_tri; } QgsPointSequence pts; pts = points(); unsigned int n = 0; while ( n < mNumberSides - 1 ) { l_tri.append( QgsTriangle( pts.at( n ), pts.at( n + 1 ), mCenter ) ); n++; } l_tri.append( QgsTriangle( pts.at( n ), pts.at( 0 ), mCenter ) ); return l_tri; }
void QgsMapToolCircularStringRadius::recalculateTempRubberBand( const QgsPointXY &mousePosition ) { QgsPointSequence rubberBandPoints; if ( !( mPoints.size() % 2 ) ) { //recalculate midpoint on circle segment QgsPoint midPoint; if ( !QgsGeometryUtils::segmentMidPoint( mPoints.at( mPoints.size() - 2 ), mTemporaryEndPoint, midPoint, mRadius, QgsPoint( mousePosition ) ) ) { return; } mPoints.replace( mPoints.size() - 1, midPoint ); rubberBandPoints.append( mPoints.at( mPoints.size() - 2 ) ); rubberBandPoints.append( mPoints.last() ); rubberBandPoints.append( mTemporaryEndPoint ); } else { rubberBandPoints.append( mPoints.last() ); rubberBandPoints.append( mapPoint( mousePosition ) ); } QgsCircularString *cString = new QgsCircularString(); cString->setPoints( rubberBandPoints ); delete mTempRubberBand; mTempRubberBand = createGeometryRubberBand( mLayerType, true ); mTempRubberBand->setGeometry( cString ); mTempRubberBand->show(); }
QgsCircularString *QgsCircle::toCircularString( bool oriented ) const { std::unique_ptr<QgsCircularString> circString( new QgsCircularString() ); QgsPointSequence points; QVector<QgsPoint> quad; if ( oriented ) { quad = quadrant(); } else { quad = northQuadrant(); } quad.append( quad.at( 0 ) ); for ( QVector<QgsPoint>::const_iterator it = quad.constBegin(); it != quad.constEnd(); ++it ) { points.append( *it ); } circString->setPoints( points ); return circString.release(); }
void QgsCircularString::setPoints( const QgsPointSequence &points ) { clearCache(); if ( points.size() < 1 ) { mWkbType = QgsWkbTypes::Unknown; mX.clear(); mY.clear(); mZ.clear(); mM.clear(); return; } //get wkb type from first point const QgsPointV2 &firstPt = points.at( 0 ); bool hasZ = firstPt.is3D(); bool hasM = firstPt.isMeasure(); setZMTypeFromSubGeometry( &firstPt, QgsWkbTypes::CircularString ); mX.resize( points.size() ); mY.resize( points.size() ); if ( hasZ ) { mZ.resize( points.size() ); } else { mZ.clear(); } if ( hasM ) { mM.resize( points.size() ); } else { mM.clear(); } for ( int i = 0; i < points.size(); ++i ) { mX[i] = points[i].x(); mY[i] = points[i].y(); if ( hasZ ) { mZ[i] = points[i].z(); } if ( hasM ) { mM[i] = points[i].m(); } } }
void QgsMapToolAddCircularString::updateCenterPointRubberBand( const QgsPointV2 &pt ) { if ( !mShowCenterPointRubberBand || !mCenterPointRubberBand || mPoints.size() < 2 ) { return; } if ( ( mPoints.size() ) % 2 != 0 ) { return; } //create circular string QgsCircularString *cs = new QgsCircularString(); QgsPointSequence csPoints; csPoints.append( mPoints.at( mPoints.size() - 2 ) ); csPoints.append( mPoints.at( mPoints.size() - 1 ) ); csPoints.append( pt ); cs->setPoints( csPoints ); QgsPointV2 center; double radius; QgsGeometryUtils::circleCenterRadius( csPoints.at( 0 ), csPoints.at( 1 ), csPoints.at( 2 ), radius, center.rx(), center.ry() ); QgsLineString *segment1 = new QgsLineString(); segment1->addVertex( center ); segment1->addVertex( csPoints.at( 0 ) ); QgsLineString *segment2 = new QgsLineString(); segment2->addVertex( csPoints.at( 2 ) ); segment2->addVertex( center ); QgsCompoundCurve *cc = new QgsCompoundCurve(); cc->addCurve( segment1 ); cc->addCurve( cs ); cc->addCurve( segment2 ); QgsCurvePolygon *cp = new QgsCurvePolygon(); cp->setExteriorRing( cc ); mCenterPointRubberBand->setGeometry( cp ); mCenterPointRubberBand->show(); }
bool QgsEllipseSymbolLayer::writeDxf( QgsDxfExport &e, double mmMapUnitScaleFactor, const QString &layerName, QgsSymbolRenderContext &context, QPointF shift ) const { //width double symbolWidth = mSymbolWidth; if ( mDataDefinedProperties.isActive( QgsSymbolLayer::PropertyWidth ) ) //1. priority: data defined setting on symbol layer le { context.setOriginalValueVariable( mSymbolWidth ); symbolWidth = mDataDefinedProperties.valueAsDouble( QgsSymbolLayer::PropertyWidth, context.renderContext().expressionContext(), mSymbolWidth ); } if ( mSymbolWidthUnit == QgsUnitTypes::RenderMillimeters ) { symbolWidth *= mmMapUnitScaleFactor; } //height double symbolHeight = mSymbolHeight; if ( mDataDefinedProperties.isActive( QgsSymbolLayer::PropertyHeight ) ) //1. priority: data defined setting on symbol layer level { context.setOriginalValueVariable( mSymbolHeight ); symbolWidth = mDataDefinedProperties.valueAsDouble( QgsSymbolLayer::PropertyHeight, context.renderContext().expressionContext(), mSymbolHeight ); } if ( mSymbolHeightUnit == QgsUnitTypes::RenderMillimeters ) { symbolHeight *= mmMapUnitScaleFactor; } //stroke width double strokeWidth = mStrokeWidth; if ( mDataDefinedProperties.isActive( QgsSymbolLayer::PropertyStrokeWidth ) ) { context.setOriginalValueVariable( mStrokeWidth ); strokeWidth = mDataDefinedProperties.valueAsDouble( QgsSymbolLayer::PropertyStrokeWidth, context.renderContext().expressionContext(), mStrokeWidth ); } if ( mStrokeWidthUnit == QgsUnitTypes::RenderMillimeters ) { strokeWidth *= strokeWidth; } //fill color QColor fc = mColor; if ( mDataDefinedProperties.isActive( QgsSymbolLayer::PropertyFillColor ) ) { context.setOriginalValueVariable( QgsSymbolLayerUtils::encodeColor( mColor ) ); fc = mDataDefinedProperties.valueAsColor( QgsSymbolLayer::PropertyFillColor, context.renderContext().expressionContext(), mColor ); } //stroke color QColor oc = mStrokeColor; if ( mDataDefinedProperties.isActive( QgsSymbolLayer::PropertyStrokeColor ) ) { context.setOriginalValueVariable( QgsSymbolLayerUtils::encodeColor( mStrokeColor ) ); oc = mDataDefinedProperties.valueAsColor( QgsSymbolLayer::PropertyStrokeColor, context.renderContext().expressionContext(), mStrokeColor ); } //symbol name QString symbolName = mSymbolName; if ( mDataDefinedProperties.isActive( QgsSymbolLayer::PropertyName ) ) { context.setOriginalValueVariable( mSymbolName ); symbolName = mDataDefinedProperties.valueAsString( QgsSymbolLayer::PropertyName, context.renderContext().expressionContext(), mSymbolName ); } //offset double offsetX = 0; double offsetY = 0; markerOffset( context, offsetX, offsetY ); QPointF off( offsetX, offsetY ); //priority for rotation: 1. data defined symbol level, 2. symbol layer rotation (mAngle) double rotation = 0.0; if ( mDataDefinedProperties.isActive( QgsSymbolLayer::PropertyAngle ) ) { context.setOriginalValueVariable( mAngle ); rotation = mDataDefinedProperties.valueAsDouble( QgsSymbolLayer::PropertyAngle, context.renderContext().expressionContext(), mAngle ) + mLineAngle; } else if ( !qgsDoubleNear( mAngle + mLineAngle, 0.0 ) ) { rotation = mAngle + mLineAngle; } rotation = -rotation; //rotation in Qt is counterclockwise if ( rotation ) off = _rotatedOffset( off, rotation ); QTransform t; t.translate( shift.x() + offsetX, shift.y() + offsetY ); if ( !qgsDoubleNear( rotation, 0.0 ) ) t.rotate( rotation ); double halfWidth = symbolWidth / 2.0; double halfHeight = symbolHeight / 2.0; if ( symbolName == QLatin1String( "circle" ) ) { if ( qgsDoubleNear( halfWidth, halfHeight ) ) { QgsPoint pt( t.map( QPointF( 0, 0 ) ) ); e.writeFilledCircle( layerName, oc, pt, halfWidth ); } else { QgsPointSequence line; double stepsize = 2 * M_PI / 40; for ( int i = 0; i < 39; ++i ) { double angle = stepsize * i; double x = halfWidth * std::cos( angle ); double y = halfHeight * std::sin( angle ); line << QgsPoint( t.map( QPointF( x, y ) ) ); } //close ellipse with first point line << line.at( 0 ); if ( mBrush.style() != Qt::NoBrush ) e.writePolygon( QgsRingSequence() << line, layerName, QStringLiteral( "SOLID" ), fc ); if ( mPen.style() != Qt::NoPen ) e.writePolyline( line, layerName, QStringLiteral( "CONTINUOUS" ), oc, strokeWidth ); } } else if ( symbolName == QLatin1String( "rectangle" ) ) { QgsPointSequence p; p << QgsPoint( t.map( QPointF( -halfWidth, -halfHeight ) ) ) << QgsPoint( t.map( QPointF( halfWidth, -halfHeight ) ) ) << QgsPoint( t.map( QPointF( halfWidth, halfHeight ) ) ) << QgsPoint( t.map( QPointF( -halfWidth, halfHeight ) ) ); p << p[0]; if ( mBrush.style() != Qt::NoBrush ) e.writePolygon( QgsRingSequence() << p, layerName, QStringLiteral( "SOLID" ), fc ); if ( mPen.style() != Qt::NoPen ) e.writePolyline( p, layerName, QStringLiteral( "CONTINUOUS" ), oc, strokeWidth ); return true; } else if ( symbolName == QLatin1String( "cross" ) && mPen.style() != Qt::NoPen ) { e.writePolyline( QgsPointSequence() << QgsPoint( t.map( QPointF( -halfWidth, 0 ) ) ) << QgsPoint( t.map( QPointF( halfWidth, 0 ) ) ), layerName, QStringLiteral( "CONTINUOUS" ), oc, strokeWidth ); e.writePolyline( QgsPointSequence() << QgsPoint( t.map( QPointF( 0, halfHeight ) ) ) << QgsPoint( t.map( QPointF( 0, -halfHeight ) ) ), layerName, QStringLiteral( "CONTINUOUS" ), oc, strokeWidth ); return true; } else if ( symbolName == QLatin1String( "triangle" ) ) { QgsPointSequence p; p << QgsPoint( t.map( QPointF( -halfWidth, -halfHeight ) ) ) << QgsPoint( t.map( QPointF( halfWidth, -halfHeight ) ) ) << QgsPoint( t.map( QPointF( 0, halfHeight ) ) ); p << p[0]; if ( mBrush.style() != Qt::NoBrush ) e.writePolygon( QgsRingSequence() << p, layerName, QStringLiteral( "SOLID" ), fc ); if ( mPen.style() != Qt::NoPen ) e.writePolyline( p, layerName, QStringLiteral( "CONTINUOUS" ), oc, strokeWidth ); return true; } return false; //soon... }
QgsPointSequence QgsCircularString::compassPointsOnSegment( double p1Angle, double p2Angle, double p3Angle, double centerX, double centerY, double radius ) { QgsPointSequence pointList; QgsPointV2 nPoint( centerX, centerY + radius ); QgsPointV2 ePoint( centerX + radius, centerY ); QgsPointV2 sPoint( centerX, centerY - radius ); QgsPointV2 wPoint( centerX - radius, centerY ); if ( p3Angle >= p1Angle ) { if ( p2Angle > p1Angle && p2Angle < p3Angle ) { if ( p1Angle <= 90 && p3Angle >= 90 ) { pointList.append( nPoint ); } if ( p1Angle <= 180 && p3Angle >= 180 ) { pointList.append( wPoint ); } if ( p1Angle <= 270 && p3Angle >= 270 ) { pointList.append( sPoint ); } } else { pointList.append( ePoint ); if ( p1Angle >= 90 || p3Angle <= 90 ) { pointList.append( nPoint ); } if ( p1Angle >= 180 || p3Angle <= 180 ) { pointList.append( wPoint ); } if ( p1Angle >= 270 || p3Angle <= 270 ) { pointList.append( sPoint ); } } } else { if ( p2Angle < p1Angle && p2Angle > p3Angle ) { if ( p1Angle >= 270 && p3Angle <= 270 ) { pointList.append( sPoint ); } if ( p1Angle >= 180 && p3Angle <= 180 ) { pointList.append( wPoint ); } if ( p1Angle >= 90 && p3Angle <= 90 ) { pointList.append( nPoint ); } } else { pointList.append( ePoint ); if ( p1Angle <= 270 || p3Angle >= 270 ) { pointList.append( sPoint ); } if ( p1Angle <= 180 || p3Angle >= 180 ) { pointList.append( wPoint ); } if ( p1Angle <= 90 || p3Angle >= 90 ) { pointList.append( nPoint ); } } } return pointList; }
void QgsCircularString::segmentize( const QgsPointV2 &p1, const QgsPointV2 &p2, const QgsPointV2 &p3, QgsPointSequence &points, double tolerance, SegmentationToleranceType toleranceType ) const { bool clockwise = false; int segSide = segmentSide( p1, p3, p2 ); if ( segSide == -1 ) { clockwise = true; } QgsPointV2 circlePoint1 = clockwise ? p3 : p1; QgsPointV2 circlePoint2 = p2; QgsPointV2 circlePoint3 = clockwise ? p1 : p3 ; //adapted code from postgis double radius = 0; double centerX = 0; double centerY = 0; QgsGeometryUtils::circleCenterRadius( circlePoint1, circlePoint2, circlePoint3, radius, centerX, centerY ); if ( circlePoint1 != circlePoint3 && ( radius < 0 || qgsDoubleNear( segSide, 0.0 ) ) ) //points are colinear { points.append( p1 ); points.append( p2 ); points.append( p3 ); return; } double increment = tolerance; //one segment per degree if ( toleranceType == QgsAbstractGeometry::MaximumDifference ) { double halfAngle = acos( -tolerance / radius + 1 ); increment = 2 * halfAngle; } //angles of pt1, pt2, pt3 double a1 = atan2( circlePoint1.y() - centerY, circlePoint1.x() - centerX ); double a2 = atan2( circlePoint2.y() - centerY, circlePoint2.x() - centerX ); double a3 = atan2( circlePoint3.y() - centerY, circlePoint3.x() - centerX ); /* Adjust a3 up so we can increment from a1 to a3 cleanly */ if ( a3 <= a1 ) a3 += 2.0 * M_PI; if ( a2 < a1 ) a2 += 2.0 * M_PI; bool hasZ = is3D(); bool hasM = isMeasure(); double x, y; double z = 0; double m = 0; QList<QgsPointV2> stringPoints; stringPoints.insert( clockwise ? 0 : stringPoints.size(), circlePoint1 ); if ( circlePoint2 != circlePoint3 && circlePoint1 != circlePoint2 ) //draw straight line segment if two points have the same position { QgsWkbTypes::Type pointWkbType = QgsWkbTypes::Point; if ( hasZ ) pointWkbType = QgsWkbTypes::addZ( pointWkbType ); if ( hasM ) pointWkbType = QgsWkbTypes::addM( pointWkbType ); //make sure the curve point p2 is part of the segmentized vertices. But only if p1 != p3 bool addP2 = true; if ( qgsDoubleNear( circlePoint1.x(), circlePoint3.x() ) && qgsDoubleNear( circlePoint1.y(), circlePoint3.y() ) ) { addP2 = false; } for ( double angle = a1 + increment; angle < a3; angle += increment ) { if ( ( addP2 && angle > a2 ) ) { stringPoints.insert( clockwise ? 0 : stringPoints.size(), circlePoint2 ); addP2 = false; } x = centerX + radius * cos( angle ); y = centerY + radius * sin( angle ); if ( !hasZ && !hasM ) { stringPoints.insert( clockwise ? 0 : stringPoints.size(), QgsPointV2( x, y ) ); continue; } if ( hasZ ) { z = interpolateArc( angle, a1, a2, a3, circlePoint1.z(), circlePoint2.z(), circlePoint3.z() ); } if ( hasM ) { m = interpolateArc( angle, a1, a2, a3, circlePoint1.m(), circlePoint2.m(), circlePoint3.m() ); } stringPoints.insert( clockwise ? 0 : stringPoints.size(), QgsPointV2( pointWkbType, x, y, z, m ) ); } } stringPoints.insert( clockwise ? 0 : stringPoints.size(), circlePoint3 ); points.append( stringPoints ); }