void QgsMapToolOffsetCurve::canvasMoveEvent( QgsMapMouseEvent* e )
{
delete mSnapVertexMarker;
mSnapVertexMarker = nullptr;
if ( !mOriginalGeometry || !mRubberBand )
{
return;
}
QgsVectorLayer* layer = currentVectorLayer();
if ( !layer )
{
return;
}
mGeometryModified = true;
//get offset from current position rectangular to feature
QgsPoint layerCoords = toLayerCoordinates( layer, e->pos() );
//snap cursor to background layers
QgsPointLocator::Match m = mCanvas->snappingUtils()->snapToMap( e->pos() );
if ( m.isValid() )
{
if (( m.layer() && m.layer()->id() != mSourceLayerId ) || m.featureId() != mModifiedFeature )
{
layerCoords = toLayerCoordinates( layer, m.point() );
mSnapVertexMarker = new QgsVertexMarker( mCanvas );
mSnapVertexMarker->setIconType( QgsVertexMarker::ICON_CROSS );
mSnapVertexMarker->setColor( Qt::green );
mSnapVertexMarker->setPenWidth( 1 );
mSnapVertexMarker->setCenter( m.point() );
}
}
QgsPoint minDistPoint;
int beforeVertex;
double leftOf;
double offset = sqrt( mOriginalGeometry->closestSegmentWithContext( layerCoords, minDistPoint, beforeVertex, &leftOf ) );
if ( offset == 0.0 )
{
return;
}
if ( mDistanceWidget )
{
// this will also set the rubber band
mDistanceWidget->setValue( leftOf < 0 ? offset : -offset );
mDistanceWidget->setFocus( Qt::TabFocusReason );
}
else
{
//create offset geometry using geos
setOffsetForRubberBand( leftOf < 0 ? offset : -offset );
}
}
void QgsMapToolOffsetCurve::canvasPressEvent( QMouseEvent* e )
{
deleteRubberBandAndGeometry();
mGeometryModified = false;
mForceCopy = false;
if ( !mCanvas )
{
return;
}
//get selected features or snap to nearest feature if no selection
QgsVectorLayer* layer = currentVectorLayer();
if ( !layer )
{
notifyNotVectorLayer();
return;
}
QgsSnappingUtils* snapping = mCanvas->snappingUtils();
// store previous settings
int oldType;
double oldSearchRadius;
QgsTolerance::UnitType oldSearchRadiusUnit;
QgsSnappingUtils::SnapToMapMode oldMode = snapping->snapToMapMode();
snapping->defaultSettings( oldType, oldSearchRadius, oldSearchRadiusUnit );
// setup new settings (temporary)
QSettings settings;
snapping->setSnapToMapMode( QgsSnappingUtils::SnapAllLayers );
snapping->setDefaultSettings( QgsPointLocator::Edge,
settings.value( "/Qgis/digitizing/search_radius_vertex_edit", 10 ).toDouble(),
( QgsTolerance::UnitType ) settings.value( "/Qgis/digitizing/search_radius_vertex_edit_unit", QgsTolerance::Pixels ).toInt() );
QgsPointLocator::Match match = snapping->snapToMap( e->pos() );
// restore old settings
snapping->setSnapToMapMode( oldMode );
snapping->setDefaultSettings( oldType, oldSearchRadius, oldSearchRadiusUnit );
if ( match.hasEdge() && match.layer() )
{
mSourceLayerId = match.layer()->id();
QgsFeature fet;
if ( match.layer()->getFeatures( QgsFeatureRequest( match.featureId() ) ).nextFeature( fet ) )
{
mForceCopy = ( e->modifiers() & Qt::ControlModifier ); //no geometry modification if ctrl is pressed
mOriginalGeometry = createOriginGeometry( match.layer(), match, fet );
mRubberBand = createRubberBand();
if ( mRubberBand )
{
mRubberBand->setToGeometry( mOriginalGeometry, layer );
}
mModifiedFeature = fet.id();
createDistanceItem();
}
}
}
void QgsSnapIndicator::setMatch( const QgsPointLocator::Match &match )
{
mMatch = match;
if ( !mMatch.isValid() )
{
mSnappingMarker.reset();
QToolTip::hideText();
}
else
{
if ( !mSnappingMarker )
{
mSnappingMarker.reset( new QgsVertexMarker( mCanvas ) );
mSnappingMarker->setPenWidth( 3 );
}
QgsSettings s;
QColor color = s.value( QStringLiteral( "/qgis/digitizing/snap_color" ), QColor( Qt::magenta ) ).value<QColor>();
mSnappingMarker->setColor( color );
int iconType;
if ( match.hasVertex() )
{
if ( match.layer() )
iconType = QgsVertexMarker::ICON_BOX; // vertex snap
else
iconType = QgsVertexMarker::ICON_X; // intersection snap
}
else // must be segment snap
{
iconType = QgsVertexMarker::ICON_DOUBLE_TRIANGLE;
}
mSnappingMarker->setIconType( iconType );
mSnappingMarker->setCenter( match.point() );
// tooltip
if ( s.value( QStringLiteral( "/qgis/digitizing/snap_tooltip" ), false ).toBool() )
{
QPoint ptCanvas = mSnappingMarker->toCanvasCoordinates( match.point() ).toPoint();
QPoint ptGlobal = mCanvas->mapToGlobal( ptCanvas );
QRect rect( ptCanvas.x(), ptCanvas.y(), 1, 1 ); // area where is the tooltip valid
QString layerName = match.layer() ? match.layer()->name() : QString();
QToolTip::showText( ptGlobal, layerName, mCanvas, rect );
}
}
}
int QgsMapToolCapture::fetchLayerPoint( const QgsPointLocator::Match &match, QgsPoint &layerPoint )
{
QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( mCanvas->currentLayer() );
QgsVectorLayer *sourceLayer = match.layer();
if ( match.isValid() && match.hasVertex() && sourceLayer &&
( sourceLayer->crs() == vlayer->crs() ) )
{
QgsFeature f;
QgsFeatureRequest request;
request.setFilterFid( match.featureId() );
bool fetched = match.layer()->getFeatures( request ).nextFeature( f );
if ( fetched )
{
QgsVertexId vId;
if ( !f.geometry().vertexIdFromVertexNr( match.vertexIndex(), vId ) )
return 2;
layerPoint = f.geometry().constGet()->vertexAt( vId );
// ZM support depends on the target layer
if ( !QgsWkbTypes::hasZ( vlayer->wkbType() ) )
{
layerPoint.dropZValue();
}
if ( !QgsWkbTypes::hasM( vlayer->wkbType() ) )
{
layerPoint.dropMValue();
}
return 0;
}
else
{
return 2;
}
}
else
{
return 1;
}
}
void testNearestVertex()
{
QgsPointLocator loc( mVL );
QgsPointXY pt( 2, 2 );
QgsPointLocator::Match m = loc.nearestVertex( pt, 999 );
QVERIFY( m.isValid() );
QVERIFY( m.hasVertex() );
QCOMPARE( m.layer(), mVL );
QCOMPARE( m.featureId(), ( QgsFeatureId )1 );
QCOMPARE( m.point(), QgsPointXY( 1, 1 ) );
QCOMPARE( m.distance(), std::sqrt( 2.0 ) );
QCOMPARE( m.vertexIndex(), 2 );
}
void testPointInPolygon()
{
QgsPointLocator loc( mVL );
QgsPointLocator::MatchList mValid = loc.pointInPolygon( QgsPointXY( 0.8, 0.8 ) );
QCOMPARE( mValid.count(), 1 );
QgsPointLocator::Match m = mValid[0];
QVERIFY( m.isValid() );
QVERIFY( m.hasArea() );
QCOMPARE( m.layer(), mVL );
QCOMPARE( m.featureId(), ( QgsFeatureId )1 );
QgsPointLocator::MatchList mInvalid = loc.pointInPolygon( QgsPointXY( 0, 0 ) );
QCOMPARE( mInvalid.count(), 0 );
}
QgsPoint QgsMapToolCapture::mapPoint( const QgsMapMouseEvent &e ) const
{
QgsPoint newPoint = mapPoint( e.mapPoint() );
// set z value from snapped point if necessary
if ( QgsWkbTypes::hasZ( newPoint.wkbType() ) )
{
// if snapped, z dimension is taken from the corresponding snapped
// point.
if ( e.isSnapped() )
{
const QgsPointLocator::Match match = e.mapPointMatch();
if ( match.layer() && QgsWkbTypes::hasZ( match.layer()->wkbType() ) )
{
const QgsFeature ft = match.layer()->getFeature( match.featureId() );
newPoint.setZ( ft.geometry().vertexAt( match.vertexIndex() ).z() );
}
}
}
return newPoint;
}
void testNearestEdge()
{
QgsPointLocator loc( mVL );
QgsPointXY 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(), QgsPointXY( 1, 0.5 ) );
QCOMPARE( m.distance(), 0.1 );
QCOMPARE( m.vertexIndex(), 1 );
QgsPointXY pt1, pt2;
m.edgePoints( pt1, pt2 );
QCOMPARE( pt1, QgsPointXY( 1, 0 ) );
QCOMPARE( pt2, QgsPointXY( 1, 1 ) );
}
void QgsMapToolOffsetCurve::canvasReleaseEvent( QgsMapMouseEvent *e )
{
mCtrlHeldOnFirstClick = false;
if ( e->button() == Qt::RightButton )
{
cancel();
return;
}
if ( mOriginalGeometry.isNull() )
{
// first click, get feature to modify
deleteRubberBandAndGeometry();
mGeometryModified = false;
QgsPointLocator::Match match = mCanvas->snappingUtils()->snapToCurrentLayer( e->pos(),
QgsPointLocator::Types( QgsPointLocator::Edge | QgsPointLocator::Area ) );
if ( ( match.hasEdge() || match.hasArea() ) && match.layer() )
{
mLayer = match.layer();
QgsFeature fet;
if ( match.layer()->getFeatures( QgsFeatureRequest( match.featureId() ) ).nextFeature( fet ) )
{
mCtrlHeldOnFirstClick = ( e->modifiers() & Qt::ControlModifier ); //no geometry modification if ctrl is pressed
prepareGeometry( match, fet );
mRubberBand = createRubberBand();
if ( mRubberBand )
{
mRubberBand->setToGeometry( mManipulatedGeometry, match.layer() );
}
mModifiedFeature = fet.id();
createUserInputWidget();
bool hasZ = QgsWkbTypes::hasZ( mLayer->wkbType() );
bool hasM = QgsWkbTypes::hasZ( mLayer->wkbType() );
if ( hasZ || hasM )
{
emit messageEmitted( QStringLiteral( "layer %1 has %2%3%4 geometry. %2%3%4 values be set to 0 when using offset tool." )
.arg( mLayer->name() )
.arg( hasZ ? "Z" : "" )
.arg( hasZ && hasM ? "/" : "" )
.arg( hasM ? "M" : "" )
, Qgis::Warning );
}
}
}
if ( mOriginalGeometry.isNull() )
{
emit messageEmitted( tr( "Could not find a nearby feature in any vector layer." ) );
cancel();
notifyNotVectorLayer();
}
}
else
{
// second click - apply changes
double offset = calculateOffset( e->snapPoint() );
applyOffset( offset, e->modifiers() );
}
}
void QgsMapToolOffsetCurve::prepareGeometry( const QgsPointLocator::Match &match, QgsFeature &snappedFeature )
{
QgsVectorLayer *vl = match.layer();
if ( !vl )
{
return;
}
mOriginalGeometry = QgsGeometry();
mManipulatedGeometry = QgsGeometry();
mModifiedPart = -1;
mModifiedRing = -1;
//assign feature part by vertex number (snap to vertex) or by before vertex number (snap to segment)
QgsGeometry geom = snappedFeature.geometry();
if ( geom.isNull() )
{
return;
}
mOriginalGeometry = geom;
QgsWkbTypes::Type geomType = geom.wkbType();
if ( QgsWkbTypes::geometryType( geomType ) == QgsWkbTypes::LineGeometry )
{
if ( !match.hasEdge() )
{
return;
}
if ( !geom.isMultipart() )
{
mManipulatedGeometry = geom;
}
else
{
int vertex = match.vertexIndex();
QgsVertexId vertexId;
geom.vertexIdFromVertexNr( vertex, vertexId );
mModifiedPart = vertexId.part;
QgsMultiPolylineXY multiLine = geom.asMultiPolyline();
mManipulatedGeometry = QgsGeometry::fromPolylineXY( multiLine.at( mModifiedPart ) );
}
}
else if ( QgsWkbTypes::geometryType( geomType ) == QgsWkbTypes::PolygonGeometry )
{
if ( !match.hasEdge() && match.hasArea() )
{
if ( !geom.isMultipart() )
{
mManipulatedGeometry = geom;
}
else
{
// get the correct part
QgsMultiPolygonXY mpolygon = geom.asMultiPolygon();
for ( int part = 0; part < mpolygon.count(); part++ ) // go through the polygons
{
const QgsPolygonXY &polygon = mpolygon[part];
QgsGeometry partGeo = QgsGeometry::fromPolygonXY( polygon );
const QgsPointXY layerCoords = match.point();
if ( partGeo.contains( &layerCoords ) )
{
mModifiedPart = part;
mManipulatedGeometry = partGeo;
}
}
}
}
else if ( match.hasEdge() )
{
int vertex = match.vertexIndex();
QgsVertexId vertexId;
geom.vertexIdFromVertexNr( vertex, vertexId );
QgsDebugMsg( QStringLiteral( "%1" ).arg( vertexId.ring ) );
if ( !geom.isMultipart() )
{
QgsPolygonXY poly = geom.asPolygon();
// if has rings
if ( poly.count() > 0 )
{
mModifiedRing = vertexId.ring;
mManipulatedGeometry = QgsGeometry::fromPolygonXY( QgsPolygonXY() << poly.at( mModifiedRing ) );
}
else
{
mManipulatedGeometry = QgsGeometry::fromPolygonXY( poly );
}
}
else
{
mModifiedPart = vertexId.part;
// get part, get ring
QgsMultiPolygonXY multiPoly = geom.asMultiPolygon();
// if has rings
if ( multiPoly.at( mModifiedPart ).count() > 0 )
{
mModifiedRing = vertexId.ring;
mManipulatedGeometry = QgsGeometry::fromPolygonXY( QgsPolygonXY() << multiPoly.at( mModifiedPart ).at( mModifiedRing ) );
}
else
{
mManipulatedGeometry = QgsGeometry::fromPolygonXY( multiPoly.at( mModifiedPart ) );
}
}
}
}
}