class Qad_stretch_maptool(QadGetPoint): def __init__(self, plugIn): QadGetPoint.__init__(self, plugIn) self.basePt = None self.SSGeomList = [] # lista di entità da stirare con geom di selezione self.__rubberBand = QadRubberBand(self.canvas) def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) self.__rubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) self.__rubberBand.show() def clear(self): QadGetPoint.clear(self) self.__rubberBand.reset() self.mode = None #============================================================================ # stretch #============================================================================ def stretch(self, f, containerGeom, offSetX, offSetY, tolerance2ApproxCurve, layerEntitySet, entitySet): # verifico se l'entità appartiene ad uno stile di quotatura dimEntity = self.plugIn.dimStyles.getDimEntity(layerEntitySet.layer, f.id()) if dimEntity is None: # stiro la feature e la rimuovo da entitySet (é la prima) stretchedGeom = qad_utils.stretchQgsGeometry(f.geometry(), containerGeom, \ offSetX, offSetY, \ tolerance2ApproxCurve) if stretchedGeom is not None: f.setGeometry(stretchedGeom) self.__rubberBand.addGeometry(f.geometry(), layerEntitySet.layer) del layerEntitySet.featureIds[0] else: # stiro la quota e la rimuovo da entitySet dimEntitySet = dimEntity.getEntitySet() dimEntity.stretch(self.plugIn, containerGeom, offSetX, offSetY) self.__rubberBand.addGeometry(dimEntity.textualFeature.geometry(), dimEntity.getTextualLayer()) self.__rubberBand.addGeometries(dimEntity.getLinearGeometryCollection(), dimEntity.getLinearLayer()) self.__rubberBand.addGeometries(dimEntity.getSymbolGeometryCollection(), dimEntity.getSymbolLayer()) entitySet.subtract(dimEntitySet) #============================================================================ # addStretchedGeometries #============================================================================ def addStretchedGeometries(self, newPt): self.__rubberBand.reset() for SSGeom in self.SSGeomList: # copio entitySet entitySet = QadEntitySet(SSGeom[0]) geomSel = SSGeom[1] for layerEntitySet in entitySet.layerEntitySetList: layer = layerEntitySet.layer tolerance2ApproxCurve = qad_utils.distMapToLayerCoordinates(QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE")), \ self.canvas,\ layer) g = QgsGeometry(geomSel) if self.plugIn.canvas.mapRenderer().destinationCrs() != layer.crs(): # Trasformo la geometria nel sistema di coordinate del layer coordTransform = QgsCoordinateTransform(self.canvas.mapRenderer().destinationCrs(), \ layer.crs()) g.transform(coordTransform) transformedBasePt = self.canvas.mapRenderer().mapToLayerCoordinates(layer, self.basePt) transformedNewPt = self.canvas.mapRenderer().mapToLayerCoordinates(layer, newPt) offSetX = transformedNewPt.x() - transformedBasePt.x() offSetY = transformedNewPt.y() - transformedBasePt.y() else: offSetX = newPt.x() - self.basePt.x() offSetY = newPt.y() - self.basePt.y() while len(layerEntitySet.featureIds) > 0: featureId = layerEntitySet.featureIds[0] f = layerEntitySet.getFeature(featureId) self.stretch(f, g, offSetX, offSetY, tolerance2ApproxCurve, layerEntitySet, entitySet) def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) # noto il punto base si richiede il secondo punto per l'angolo di rotazione if self.mode == Qad_stretch_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_MOVE_PT: self.addStretchedGeometries(self.tmpPoint) def activate(self): QadGetPoint.activate(self) self.__rubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) self.__rubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # si richiede la selezione del primo punto del rettangolo per selezionare gli oggetti if self.mode == Qad_stretch_maptool_ModeEnum.ASK_FOR_FIRST_PT_RECTANGLE: self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION) self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto niente il primo punto del rettangolo si richiede il secondo punto elif self.mode == Qad_stretch_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT_RECTANGLE: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_RECTANGLE) # noto niente si richiede il punto base elif self.mode == Qad_stretch_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_BASE_PT: self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION) self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il punto base si richiede il secondo punto elif self.mode == Qad_stretch_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_MOVE_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.basePt)
class Qad_arc_maptool(QadGetPoint): def __init__(self, plugIn, asToolForMPolygon = False): QadGetPoint.__init__(self, plugIn) self.arcStartPt = None self.arcSecondPt = None self.arcEndPt = None self.arcCenterPt = None self.arcTanOnStartPt = None self.arcAngle = None self.arcStartPtForRadius = None self.arcRadius = None self.__rubberBand = QadRubberBand(self.canvas) self.asToolForMPolygon = asToolForMPolygon # se True significa che è usato per disegnare un poligono if self.asToolForMPolygon: self.__polygonRubberBand = QadRubberBand(self.plugIn.canvas, True) self.endVertex = None # punta al vertice iniziale e finale del poligono di QadPLINECommandClass def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) self.__rubberBand.hide() if self.asToolForMPolygon: self.__polygonRubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) self.__rubberBand.show() if self.asToolForMPolygon: self.__polygonRubberBand.show() def clear(self): QadGetPoint.clear(self) self.__rubberBand.reset() if self.asToolForMPolygon: self.__polygonRubberBand.reset() self.mode = None def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) self.__rubberBand.reset() if self.asToolForMPolygon: self.__polygonRubberBand.reset() result = False arc = QadArc() # noti il primo e il secondo punto dell'arco si richiede il terzo punto if self.mode == Qad_arc_maptool_ModeEnum.START_SECOND_PT_KNOWN_ASK_FOR_END_PT: result = arc.fromStartSecondEndPts(self.arcStartPt, self.arcSecondPt, self.tmpPoint) # noti il primo punto e il centro dell'arco si richiede il punto finale elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_END_PT: result = arc.fromStartCenterEndPts(self.arcStartPt, self.arcCenterPt, self.tmpPoint) # noti il primo punto e il centro dell'arco si richiede l'angolo inscritto elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_ANGLE: angle = qad_utils.getAngleBy2Pts(self.arcCenterPt, self.tmpPoint) result = arc.fromStartCenterPtsAngle(self.arcStartPt, self.arcCenterPt, angle) # noti il primo punto e il centro dell'arco si richiede la lunghezza della corda elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_CHORD: chord = qad_utils.getDistance(self.arcStartPt, self.tmpPoint) result = arc.fromStartCenterPtsChord(self.arcStartPt, self.arcCenterPt, chord) # noti il punto iniziale e finale dell'arco si richiede il centro elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_CENTER: result = arc.fromStartCenterEndPts(self.arcStartPt, self.tmpPoint, self.arcEndPt) # noti il punto iniziale e finale dell'arco si richiede l'angolo inscritto elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_ANGLE: angle = qad_utils.getAngleBy2Pts(self.arcStartPt, self.tmpPoint) result = arc.fromStartEndPtsAngle(self.arcStartPt, self.arcEndPt, angle) # noti il punto iniziale e finale dell'arco si richiede la direzione della tangente elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_TAN: tan = qad_utils.getAngleBy2Pts(self.arcStartPt, self.tmpPoint) result = arc.fromStartEndPtsTan(self.arcStartPt, self.arcEndPt, tan) # noti il punto iniziale e finale dell'arco si richiede il raggio elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_RADIUS: radius = qad_utils.getDistance(self.arcEndPt, self.tmpPoint) result = arc.fromStartEndPtsRadius(self.arcStartPt, self.arcEndPt, radius) # noti il punto iniziale e la tangente al punto iniziale si richiede il punto finale elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_TAN_KNOWN_ASK_FOR_END_PT: result = arc.fromStartEndPtsTan(self.arcStartPt, self.tmpPoint, self.arcTanOnStartPt) # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il punto finale elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_END_PT: result = arc.fromStartEndPtsAngle(self.arcStartPt, self.tmpPoint, self.arcAngle) # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il centro elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_CENTER_PT: result = arc.fromStartCenterPtsAngle(self.arcStartPt, self.tmpPoint, self.arcAngle) # noti il punto iniziale, l'angolo inscritto e il raggio dell'arco si richiede la direzione della corda elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_RADIUS_KNOWN_ASK_FOR_CHORDDIRECTION: chordDirection = qad_utils.getAngleBy2Pts(self.arcStartPt, self.tmpPoint) result = arc.fromStartPtAngleRadiusChordDirection(self.arcStartPt, self.arcAngle, \ self.arcRadius, chordDirection) # noti il punto iniziale e il raggio dell'arco si richiede il punto finale elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_RADIUS_KNOWN_ASK_FOR_END_PT: result = arc.fromStartEndPtsRadius(self.arcStartPt, self.tmpPoint, self.arcRadius) if result == True: points = arc.asPolyline() if points is not None: self.__rubberBand.setLine(points) if self.asToolForMPolygon == True: # se True significa che è usato per disegnare un poligono if self.endVertex is not None: points.insert(0, self.endVertex) self.__polygonRubberBand.setPolygon(points) def activate(self): QadGetPoint.activate(self) self.__rubberBand.show() if self.asToolForMPolygon: self.__polygonRubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) self.__rubberBand.hide() if self.asToolForMPolygon: self.__polygonRubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # noto niente si richiede il primo punto if self.mode == Qad_arc_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_START_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il primo punto dell'arco si richiede il secondo punto elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_KNOWN_ASK_FOR_SECOND_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt) # noti il primo e il secondo punto dell'arco si richiede il terzo punto elif self.mode == Qad_arc_maptool_ModeEnum.START_SECOND_PT_KNOWN_ASK_FOR_END_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il primo punto dell'arco si richiede il centro elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_KNOWN_ASK_FOR_CENTER_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt) # noti il primo punto e il centro dell'arco si richiede il punto finale elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_END_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcCenterPt) # noti il primo punto e il centro dell'arco si richiede l'angolo inscritto elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_ANGLE: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcCenterPt) # noti il primo punto e il centro dell'arco si richiede la lunghezza della corda elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_CHORD: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt) # noto il punto iniziale dell'arco si richiede il punto finale elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_KNOWN_ASK_FOR_END_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt) # noti il punto iniziale e finale dell'arco si richiede il centro elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_CENTER: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noti il punto iniziale e finale dell'arco si richiede l'angolo inscritto elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_ANGLE: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt) # noti il punto iniziale e finale dell'arco si richiede la direzione della tangente elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_TAN: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt) # noti il punto iniziale e finale dell'arco si richiede il raggio elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_RADIUS: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcEndPt) # noto niente si richiede il centro elif self.mode == Qad_arc_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_CENTER_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il centro dell'arco si richiede il punto iniziale elif self.mode == Qad_arc_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_START_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcCenterPt) # noti il punto iniziale e la tangente al punto iniziale si richiede il punto finale elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_TAN_KNOWN_ASK_FOR_END_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt) # noto il punto iniziale dell'arco si richiede l'angolo inscritto elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_KNOWN_ASK_FOR_ANGLE: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt) # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il punto finale elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_END_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt) # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il centro elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_CENTER_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il raggio elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_RADIUS: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il secondo punto per misurare il raggio elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_SECONDPTRADIUS: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPtForRadius) # noti il punto iniziale, l'angolo inscritto e il raggio dell'arco si richiede la direzione della corda elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_RADIUS_KNOWN_ASK_FOR_CHORDDIRECTION: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt) # noti il punto iniziale e il raggio dell'arco si richiede il punto finale elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_RADIUS_KNOWN_ASK_FOR_END_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt)
class Qad_fillet_maptool(QadGetPoint): def __init__(self, plugIn): QadGetPoint.__init__(self, plugIn) self.filletMode = 1 # modalità di raccordo; 1=Taglia-estendi, 2=Non taglia-estendi self.radius = 0.0 self.layer = None self.linearObjectList = qad_utils.QadLinearObjectList() self.partAt1 = 0 self.vertexAt1 = 0 self.tolerance2ApproxCurve = None self.__rubberBand = QadRubberBand(self.canvas) def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) self.__rubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) self.__rubberBand.show() def clear(self): QadGetPoint.clear(self) self.__rubberBand.reset() self.mode = None def setEntityInfo(self, layer, featureId, linearObjectList, partAt, pointAt): """ Setta self.entity, self.atSubGeom, self.linearObjectList, self.partAt, self.pointAt di primo o del secondo oggetto da raccordare (vedi <firstObj>) """ self.layer = layer self.featureId = featureId self.linearObjectList.set(linearObjectList) self.partAt = partAt self.pointAt = pointAt self.tolerance2ApproxCurve = QadVariables.get( QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE")) def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) self.__rubberBand.reset() tmpLinearObjectList = None # si richiede la selezione del secondo oggetto if self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_SECOND_LINESTRING: if self.tmpEntity.isInitialized(): # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy geom = self.layerToMapCoordinates(self.tmpEntity.layer, self.tmpEntity.getGeometry()) # ritorna una tupla (<The squared cartesian distance>, # <minDistPoint> # <afterVertex> # <leftOf>) dummy = qad_utils.closestSegmentWithContext( self.tmpPoint, geom) if dummy[2] is not None: # ritorna la sotto-geometria al vertice <atVertex> e la sua posizione nella geometria (0-based) subGeom, atSubGeom = qad_utils.getSubGeomAtVertex( geom, dummy[2]) tmpLinearObjectList = qad_utils.QadLinearObjectList() tmpLinearObjectList.fromPolyline(subGeom.asPolyline()) # la funzione ritorna una lista con (<minima distanza al quadrato>, # <punto più vicino> # <indice della parte più vicina> # <"a sinistra di">) dummy = tmpLinearObjectList.closestPartWithContext( self.tmpPoint) tmpPartAt = dummy[2] tmpPointAt = dummy[1] # stessa entità e stessa parte if self.layer.id() == self.tmpEntity.layer.id() and \ self.featureId == self.tmpEntity.featureId and \ self.partAt == tmpPartAt: return # uso il crs del canvas per lavorare con coordinate piane xy epsg = self.canvas.mapRenderer().destinationCrs().authid() if self.tmpShiftKey == True: # tasto shift premuto durante il movimento del mouse # filletMode = 1 # modalità di raccordo; 1=Taglia-estendi # raggio = 0 res = qad_utils.getFilletLinearObjectList(self.linearObjectList, self.partAt, self.pointAt, \ tmpLinearObjectList, tmpPartAt, tmpPointAt,\ 1, 0, epsg) else: res = qad_utils.getFilletLinearObjectList(self.linearObjectList, self.partAt, self.pointAt, \ tmpLinearObjectList, tmpPartAt, tmpPointAt,\ self.filletMode, self.radius, epsg) if res is None: # raccordo non possibile return tmpLinearObjectList = res[0] # si richiede la selezione della polilinea elif self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_POLYLINE: if self.tmpEntity.isInitialized(): # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy geom = self.layerToMapCoordinates(self.tmpEntity.layer, self.tmpEntity.getGeometry()) # ritorna una tupla (<The squared cartesian distance>, # <minDistPoint> # <afterVertex> # <leftOf>) dummy = qad_utils.closestSegmentWithContext( self.tmpPoint, geom) if dummy[2] is not None: # ritorna la sotto-geometria al vertice <atVertex> e la sua posizione nella geometria (0-based) subGeom, atSubGeom = qad_utils.getSubGeomAtVertex( geom, dummy[2]) tmpLinearObjectList = qad_utils.QadLinearObjectList() tmpLinearObjectList.fromPolyline(subGeom.asPolyline()) tmpLinearObjectList.fillet(self.radius) if tmpLinearObjectList is not None: pts = tmpLinearObjectList.asPolyline(self.tolerance2ApproxCurve) if self.layer.geometryType() == QGis.Polygon: geom = QgsGeometry.fromPolygon([pts]) else: geom = QgsGeometry.fromPolyline(pts) # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy geom = self.layerToMapCoordinates(self.layer, geom) self.__rubberBand.addGeometry(geom, self.layer) def activate(self): QadGetPoint.activate(self) self.__rubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) self.__rubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # si richiede la selezione del primo oggetto # si richiede la selezione del secondo oggetto if self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_FIRST_LINESTRING or \ self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_SECOND_LINESTRING: if self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_FIRST_LINESTRING: self.setSelectionMode( QadGetPointSelectionModeEnum.ENTITY_SELECTION) else: self.setSelectionMode( QadGetPointSelectionModeEnum.ENTITY_SELECTION_DYNAMIC) # solo layer lineari editabili che non appartengano a quote layerList = [] for layer in qad_utils.getVisibleVectorLayers( self.plugIn.canvas): # Tutti i layer vettoriali visibili if layer.geometryType() == QGis.Line and layer.isEditable(): if len(QadDimStyles.getDimListByLayer(layer)) == 0: layerList.append(layer) self.layersToCheck = layerList self.setSnapType(QadSnapTypeEnum.DISABLE) # non si richiede niente elif self.mode == Qad_fillet_maptool_ModeEnum.NONE: self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION) self.setDrawMode(QadGetPointDrawModeEnum.NONE) # si richiede la selezione della polilinea elif self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_POLYLINE: self.setSelectionMode( QadGetPointSelectionModeEnum.ENTITY_SELECTION_DYNAMIC) # solo layer lineari o poligono editabili che non appartengano a quote layerList = [] for layer in qad_utils.getVisibleVectorLayers( self.plugIn.canvas): # Tutti i layer vettoriali visibili if (layer.geometryType() == QGis.Line or layer.geometryType() == QGis.Polygon) and \ layer.isEditable(): if len(QadDimStyles.getDimListByLayer(layer)) == 0: layerList.append(layer) self.layersToCheck = layerList self.setSnapType(QadSnapTypeEnum.DISABLE)
class Qad_fillet_maptool(QadGetPoint): def __init__(self, plugIn): QadGetPoint.__init__(self, plugIn) self.filletMode = 1 # modalità di raccordo; 1=Taglia-estendi, 2=Non taglia-estendi self.radius = 0.0 self.layer = None self.linearObjectList = qad_utils.QadLinearObjectList() self.partAt1 = 0 self.vertexAt1 = 0 self.tolerance2ApproxCurve = None self.__rubberBand = QadRubberBand(self.canvas) def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) self.__rubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) self.__rubberBand.show() def clear(self): QadGetPoint.clear(self) self.__rubberBand.reset() self.mode = None def setEntityInfo(self, layer, featureId, linearObjectList, partAt, pointAt): """ Setta self.entity, self.atSubGeom, self.linearObjectList, self.partAt, self.pointAt di primo o del secondo oggetto da raccordare (vedi <firstObj>) """ self.layer = layer self.featureId = featureId self.linearObjectList.set(linearObjectList) self.partAt = partAt self.pointAt = pointAt self.tolerance2ApproxCurve = QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE")) def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) self.__rubberBand.reset() tmpLinearObjectList = None # si richiede la selezione del secondo oggetto if self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_SECOND_LINESTRING: if self.tmpEntity.isInitialized(): # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy geom = self.layerToMapCoordinates(self.tmpEntity.layer, self.tmpEntity.getGeometry()) # ritorna una tupla (<The squared cartesian distance>, # <minDistPoint> # <afterVertex> # <leftOf>) dummy = qad_utils.closestSegmentWithContext(self.tmpPoint, geom) if dummy[2] is not None: # ritorna la sotto-geometria al vertice <atVertex> e la sua posizione nella geometria (0-based) subGeom, atSubGeom = qad_utils.getSubGeomAtVertex(geom, dummy[2]) tmpLinearObjectList = qad_utils.QadLinearObjectList() tmpLinearObjectList.fromPolyline(subGeom.asPolyline()) # la funzione ritorna una lista con (<minima distanza al quadrato>, # <punto più vicino> # <indice della parte più vicina> # <"a sinistra di">) dummy = tmpLinearObjectList.closestPartWithContext(self.tmpPoint) tmpPartAt = dummy[2] tmpPointAt = dummy[1] # stessa entità e stessa parte if self.layer.id() == self.tmpEntity.layer.id() and \ self.featureId == self.tmpEntity.featureId and \ self.partAt == tmpPartAt: return # uso il crs del canvas per lavorare con coordinate piane xy epsg = self.canvas.mapRenderer().destinationCrs().authid() if self.tmpShiftKey == True: # tasto shift premuto durante il movimento del mouse # filletMode = 1 # modalità di raccordo; 1=Taglia-estendi # raggio = 0 res = qad_utils.getFilletLinearObjectList(self.linearObjectList, self.partAt, self.pointAt, \ tmpLinearObjectList, tmpPartAt, tmpPointAt,\ 1, 0, epsg) else: res = qad_utils.getFilletLinearObjectList(self.linearObjectList, self.partAt, self.pointAt, \ tmpLinearObjectList, tmpPartAt, tmpPointAt,\ self.filletMode, self.radius, epsg) if res is None: # raccordo non possibile return tmpLinearObjectList = res[0] # si richiede la selezione della polilinea elif self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_POLYLINE: if self.tmpEntity.isInitialized(): # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy geom = self.layerToMapCoordinates(self.tmpEntity.layer, self.tmpEntity.getGeometry()) # ritorna una tupla (<The squared cartesian distance>, # <minDistPoint> # <afterVertex> # <leftOf>) dummy = qad_utils.closestSegmentWithContext(self.tmpPoint, geom) if dummy[2] is not None: # ritorna la sotto-geometria al vertice <atVertex> e la sua posizione nella geometria (0-based) subGeom, atSubGeom = qad_utils.getSubGeomAtVertex(geom, dummy[2]) tmpLinearObjectList = qad_utils.QadLinearObjectList() tmpLinearObjectList.fromPolyline(subGeom.asPolyline()) tmpLinearObjectList.fillet(self.radius) if tmpLinearObjectList is not None: pts = tmpLinearObjectList.asPolyline(self.tolerance2ApproxCurve) if self.layer.geometryType() == QGis.Polygon: geom = QgsGeometry.fromPolygon([pts]) else: geom = QgsGeometry.fromPolyline(pts) # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy geom = self.layerToMapCoordinates(self.layer, geom) self.__rubberBand.addGeometry(geom, self.layer) def activate(self): QadGetPoint.activate(self) self.__rubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) self.__rubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # si richiede la selezione del primo oggetto # si richiede la selezione del secondo oggetto if self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_FIRST_LINESTRING or \ self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_SECOND_LINESTRING: if self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_FIRST_LINESTRING: self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION) else: self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION_DYNAMIC) # solo layer lineari editabili che non appartengano a quote layerList = [] for layer in self.plugIn.canvas.layers(): if layer.type() == QgsMapLayer.VectorLayer and layer.geometryType() == QGis.Line and layer.isEditable(): if len(QadDimStyles.getDimListByLayer(layer)) == 0: layerList.append(layer) self.layersToCheck = layerList self.setSnapType(QadSnapTypeEnum.DISABLE) # non si richiede niente elif self.mode == Qad_fillet_maptool_ModeEnum.NONE: self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION) self.setDrawMode(QadGetPointDrawModeEnum.NONE) # si richiede la selezione della polilinea elif self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_POLYLINE: self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION_DYNAMIC) # solo layer lineari o poligono editabili che non appartengano a quote layerList = [] for layer in self.plugIn.canvas.layers(): if layer.type() == QgsMapLayer.VectorLayer and \ (layer.geometryType() == QGis.Line or layer.geometryType() == QGis.Polygon) and \ layer.isEditable(): if len(QadDimStyles.getDimListByLayer(layer)) == 0: layerList.append(layer) self.layersToCheck = layerList self.setSnapType(QadSnapTypeEnum.DISABLE)
class Qad_mirror_maptool(QadGetPoint): def __init__(self, plugIn): QadGetPoint.__init__(self, plugIn) self.firstMirrorPt = None self.entitySet = QadEntitySet() self.__rubberBand = QadRubberBand(self.canvas) def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) self.__rubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) self.__rubberBand.show() def clear(self): QadGetPoint.clear(self) self.__rubberBand.reset() self.mode = None #============================================================================ # mirror #============================================================================ def mirror(self, f, pt1, pt2, layerEntitySet, entitySet): # verifico se la feature appartiene ad una quotatura dimEntity = self.plugIn.dimStyles.getDimEntity(layerEntitySet.layer, f.id()) if dimEntity is None: # specchio la feature e la rimuovo da entitySet (é la prima) f.setGeometry(qad_utils.mirrorQgsGeometry(f.geometry(), pt1, pt2)) self.__rubberBand.addGeometry(f.geometry(), layerEntitySet.layer) del layerEntitySet.featureIds[0] else: # specchio la quota e la rimuovo da entitySet dimEntitySet = dimEntity.getEntitySet() dimEntity.mirror(self.plugIn, pt1, qad_utils.getAngleBy2Pts(pt1, pt2)) self.__rubberBand.addGeometry(dimEntity.textualFeature.geometry(), dimEntity.getTextualLayer()) self.__rubberBand.addGeometries(dimEntity.getLinearGeometryCollection(), dimEntity.getLinearLayer()) self.__rubberBand.addGeometries(dimEntity.getSymbolGeometryCollection(), dimEntity.getSymbolLayer()) entitySet.subtract(dimEntitySet) def setMirroredGeometries(self, newPt): self.__rubberBand.reset() # copio entitySet entitySet = QadEntitySet(self.entitySet) for layerEntitySet in entitySet.layerEntitySetList: layer = layerEntitySet.layer transformedFirstMirrorPt = self.canvas.mapRenderer().mapToLayerCoordinates(layer, self.firstMirrorPt) transformedNewPtMirrorPt = self.canvas.mapRenderer().mapToLayerCoordinates(layer, newPt) while len(layerEntitySet.featureIds) > 0: featureId = layerEntitySet.featureIds[0] f = layerEntitySet.getFeature(featureId) self.mirror(f, transformedFirstMirrorPt, transformedNewPtMirrorPt, layerEntitySet, entitySet) def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) # noto il primo punto si richiede il secondo punto della linea speculare if self.mode == Qad_mirror_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT: self.setMirroredGeometries(self.tmpPoint) def activate(self): QadGetPoint.activate(self) self.__rubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) self.__rubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # noto niente si richiede il primo punto della linea speculare if self.mode == Qad_mirror_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il primo punto si richiede il secondo punto della linea speculare elif self.mode == Qad_mirror_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.firstMirrorPt)
class Qad_rectangle_maptool(QadGetPoint): def __init__(self, plugIn): QadGetPoint.__init__(self, plugIn) self.firstCorner = None self.secondCorner = None self.basePt = None self.gapType = 0 # 0 = Angoli retti; 1 = Raccorda i segmenti; 2 = Cima i segmenti self.gapValue1 = 0 # se gapType = 1 -> raggio di curvatura; se gapType = 2 -> prima distanza di cimatura self.gapValue2 = 0 # se gapType = 2 -> seconda distanza di cimatura self.rot = 0 self.vertices = [] self.__rubberBand = QadRubberBand(self.canvas, True) self.geomType = QGis.Polygon def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) self.__rubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) self.__rubberBand.show() def clear(self): QadGetPoint.clear(self) self.__rubberBand.reset() self.mode = None def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) self.__rubberBand.reset() result = False del self.vertices[:] # svuoto la lista # noto il primo angolo si richiede l'angolo opposto if self.mode == Qad_rectangle_maptool_ModeEnum.FIRST_CORNER_KNOWN_ASK_FOR_SECOND_CORNER: self.vertices.extend(qad_utils.getRectByCorners(self.firstCorner, self.tmpPoint, self.rot, \ self.gapType, self.gapValue1, self.gapValue2)) result = True if result == True: if self.vertices is not None: if self.geomType == QGis.Polygon: self.__rubberBand.setPolygon(self.vertices) else: self.__rubberBand.setLine(self.vertices) def activate(self): QadGetPoint.activate(self) self.__rubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) self.__rubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # noto niente si richiede il primo angolo if self.mode == Qad_rectangle_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_CORNER: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il primo angolo si richiede l'angolo opposto elif self.mode == Qad_rectangle_maptool_ModeEnum.FIRST_CORNER_KNOWN_ASK_FOR_SECOND_CORNER: self.setDrawMode(QadGetPointDrawModeEnum.NONE)
class Qad_lengthen_maptool(QadGetPoint): def __init__(self, plugIn): QadGetPoint.__init__(self, plugIn) self.OpMode = None # "DElta" o "Percent" o "Total" o "DYnamic" self.OpType = None # "length" o "Angle" self.value = None self.tmpLinearObjectList = None self.__rubberBand = QadRubberBand(self.canvas) def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) self.__rubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) self.__rubberBand.show() def clear(self): QadGetPoint.clear(self) self.__rubberBand.reset() self.mode = None def setInfo(self, entity, point): # setta: self.layer, self.tmpLinearObjectList e self.move_startPt if self.tmpLinearObjectList is not None: del self.tmpLinearObjectList self.tmpLinearObjectList = None if entity.isInitialized() == False: return False self.layer = entity.layer transformedPt = self.canvas.mapSettings().mapToLayerCoordinates(self.layer, point) geom = entity.getGeometry() # ritorna una tupla (<The squared cartesian distance>, # <minDistPoint> # <afterVertex> # <leftOf>) dummy = qad_utils.closestSegmentWithContext(transformedPt, geom) if dummy[2] is None: return False # ritorna la sotto-geometria al vertice <atVertex> e la sua posizione nella geometria (0-based) subGeom, atSubGeom = qad_utils.getSubGeomAtVertex(geom, dummy[2]) self.tmpLinearObjectList = qad_utils.QadLinearObjectList() self.tmpLinearObjectList.fromPolyline(subGeom.asPolyline()) if qad_utils.getDistance(self.tmpLinearObjectList.getStartPt(), transformedPt) <= \ qad_utils.getDistance(self.tmpLinearObjectList.getEndPt(), transformedPt): # si allunga/accorcia dal punto iniziale self.move_startPt = True else: # si allunga dal punto finale self.move_startPt = False return True def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) self.__rubberBand.reset() res = False # si richiede la selezione dell'oggetto da allungare if self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_OBJ_TO_LENGTHEN: if self.tmpEntity.isInitialized(): if self.setInfo(self.tmpEntity, self.tmpPoint) == False: return if self.OpMode == "DElta": newTmpLinearObjectList = qad_utils.QadLinearObjectList(self.tmpLinearObjectList) if self.OpType == "length": res = newTmpLinearObjectList.lengthen_delta(self.move_startPt, self.value) elif self.OpType == "Angle": res = newTmpLinearObjectList.lengthen_deltaAngle(self.move_startPt, self.value) elif self.OpMode == "Percent": newTmpLinearObjectList = qad_utils.QadLinearObjectList(self.tmpLinearObjectList) value = newTmpLinearObjectList.length() * self.value / 100 value = value - newTmpLinearObjectList.length() res = newTmpLinearObjectList.lengthen_delta(self.move_startPt, value) elif self.OpMode == "Total": newTmpLinearObjectList = qad_utils.QadLinearObjectList(self.tmpLinearObjectList) if self.OpType == "length": value = self.value - self.tmpLinearObjectList.length() res = newTmpLinearObjectList.lengthen_delta(self.move_startPt, value) elif self.OpType == "Angle": if newTmpLinearObjectList.qty() == 1: linearObject = newTmpLinearObjectList.getLinearObjectAt(0) if linearObject.isArc() == True: # se è un arco value = self.value - linearObject.getArc().totalAngle() res = newTmpLinearObjectList.lengthen_deltaAngle(self.move_startPt, value) # si richiede un punto per la nuova estremità elif self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_DYNAMIC_POINT: newTmpLinearObjectList = qad_utils.QadLinearObjectList(self.tmpLinearObjectList) transformedPt = self.canvas.mapSettings().mapToLayerCoordinates(self.layer, self.tmpPoint) if self.move_startPt: linearObject = newTmpLinearObjectList.getLinearObjectAt(0) else: linearObject = newTmpLinearObjectList.getLinearObjectAt(-1) if linearObject.isSegment(): newPt = qad_utils.getPerpendicularPointOnInfinityLine(linearObject.getStartPt(), linearObject.getEndPt(), transformedPt) else: # arco newPt = qad_utils.getPolarPointByPtAngle(linearObject.getArc().center, \ qad_utils.getAngleBy2Pts(linearObject.getArc().center, transformedPt), \ linearObject.getArc().radius) if newTmpLinearObjectList.qty() > 1 and linearObject.isSegment(): ang = linearObject.getTanDirectionOnStartPt() if self.move_startPt: linearObject.setStartPt(newPt) else: linearObject.setEndPt(newPt) if newTmpLinearObjectList.qty() > 1 and linearObject.isSegment() and \ qad_utils.TanDirectionNear(ang, linearObject.getTanDirectionOnStartPt()) == False: res = False else: res = True if res == False: # allungamento impossibile return pts = newTmpLinearObjectList.asPolyline() geom = QgsGeometry.fromPolyline(pts) self.__rubberBand.addGeometry(geom, self.layer) def activate(self): QadGetPoint.activate(self) self.__rubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) self.__rubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # si richiede la selezione dell'oggetto da misurare if self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_OBJ_TO_MISURE: self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION) # solo layer di tipo lineari che non appartengano a quote o di tipo poligono layerList = [] for layer in qad_utils.getVisibleVectorLayers(self.plugIn.canvas): # Tutti i layer vettoriali visibili if layer.geometryType() == QGis.Line or layer.geometryType() == QGis.Polygon: if len(QadDimStyles.getDimListByLayer(layer)) == 0: layerList.append(layer) self.layersToCheck = layerList self.onlyEditableLayers = False self.setSnapType(QadSnapTypeEnum.DISABLE) # si richiede il delta elif self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_DELTA: self.OpMode = "DElta" self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION) # non si richiede niente elif self.mode == Qad_lengthen_maptool_ModeEnum.NONE: self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION) # si richiede la selezione dell'oggetto da allungare elif self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_OBJ_TO_LENGTHEN: self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION_DYNAMIC) # solo layer lineari editabili che non appartengano a quote layerList = [] for layer in qad_utils.getVisibleVectorLayers(self.plugIn.canvas): # Tutti i layer vettoriali visibili if layer.geometryType() == QGis.Line and layer.isEditable(): if len(QadDimStyles.getDimListByLayer(layer)) == 0: layerList.append(layer) self.layersToCheck = layerList self.onlyEditableLayers = True self.setSnapType(QadSnapTypeEnum.DISABLE) # si richiede la percentuale elif self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_PERCENT: self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION) self.OpMode = "Percent" # si richiede il totale elif self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_TOTAL: self.OpMode = "Total" self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION) # si richiede il nuovo punto dell'estremità in modalità dinamica elif self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_DYNAMIC_POINT: self.OpMode = "DYnamic" self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
class Qad_scale_maptool(QadGetPoint): def __init__(self, plugIn): QadGetPoint.__init__(self, plugIn) self.basePt = None self.Pt1ReferenceLen = None self.ReferenceLen = 0 self.Pt1NewLen = None self.entitySet = QadEntitySet() self.__rubberBand = QadRubberBand(self.canvas) def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) self.__rubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) self.__rubberBand.show() def clear(self): QadGetPoint.clear(self) self.__rubberBand.reset() self.mode = None #============================================================================ # scale #============================================================================ def scale(self, f, basePt, scale, layerEntitySet, entitySet): # verifico se l'entità appartiene ad uno stile di quotatura dimEntity = self.plugIn.dimStyles.getDimEntity(layerEntitySet.layer, f.id()) if dimEntity is None: # scalo la feature e la rimuovo da entitySet (é la prima) f.setGeometry(qad_utils.scaleQgsGeometry(f.geometry(), basePt, scale)) self.__rubberBand.addGeometry(f.geometry(), layerEntitySet.layer) del layerEntitySet.featureIds[0] else: # scalo la quota e la rimuovo da entitySet dimEntitySet = dimEntity.getEntitySet() dimEntity.scale(self.plugIn, basePt, scale) self.__rubberBand.addGeometry(dimEntity.textualFeature.geometry(), dimEntity.getTextualLayer()) self.__rubberBand.addGeometries(dimEntity.getLinearGeometryCollection(), dimEntity.getLinearLayer()) self.__rubberBand.addGeometries(dimEntity.getSymbolGeometryCollection(), dimEntity.getSymbolLayer()) entitySet.subtract(dimEntitySet) #============================================================================ # addScaledGeometries #============================================================================ def addScaledGeometries(self, scale): self.__rubberBand.reset() # copio entitySet entitySet = QadEntitySet(self.entitySet) if scale <= 0: return for layerEntitySet in entitySet.layerEntitySetList: layer = layerEntitySet.layer transformedBasePt = self.canvas.mapRenderer().mapToLayerCoordinates(layer, self.basePt) while len(layerEntitySet.featureIds) > 0: featureId = layerEntitySet.featureIds[0] f = layerEntitySet.getFeature(featureId) self.scale(f, transformedBasePt, scale, layerEntitySet, entitySet) def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) # noto il punto base si richiede il secondo punto per la scala if self.mode == Qad_scale_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_SCALE_PT: scale = qad_utils.getDistance(self.basePt, self.tmpPoint) self.addScaledGeometries(scale) # noto il primo punto si richiede il secondo punto per la lunghezza di riferimento elif self.mode == Qad_scale_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_NEW_LEN_PT: len = qad_utils.getDistance(self.basePt, self.tmpPoint) scale = len / self.ReferenceLen self.addScaledGeometries(scale) # noto il primo punto si richiede il secondo punto per la nuova lunghezza elif self.mode == Qad_scale_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_NEW_LEN_PT: len = qad_utils.getDistance(self.Pt1NewLen, self.tmpPoint) scale = len / self.ReferenceLen self.addScaledGeometries(scale) def activate(self): QadGetPoint.activate(self) self.__rubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) self.__rubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # noto niente si richiede il punto base if self.mode == Qad_scale_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_BASE_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il punto base si richiede il secondo punto per la scala elif self.mode == Qad_scale_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_SCALE_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.basePt) # si richiede il primo punto per la lunghezza di riferimento elif self.mode == Qad_scale_maptool_ModeEnum.ASK_FOR_FIRST_PT_REFERENCE_LEN: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il primo punto si richiede il secondo punto per la lunghezza di riferimento elif self.mode == Qad_scale_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT_REFERENCE_LEN: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.Pt1ReferenceLen) # noto il punto base si richiede il secondo punto per la nuova lunghezza elif self.mode == Qad_scale_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_NEW_LEN_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.basePt) # si richiede il primo punto per la nuova lunghezza elif self.mode == Qad_scale_maptool_ModeEnum.ASK_FOR_FIRST_NEW_LEN_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il primo punto si richiede il secondo punto per la nuova lunghezza elif self.mode == Qad_scale_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_NEW_LEN_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.Pt1NewLen)
class Qad_dim_maptool(QadGetPoint): def __init__(self, plugIn): QadGetPoint.__init__(self, plugIn) dimStyle = None self.dimPt1 = None self.dimPt2 = None self.dimCircle = None self.dimArc = None # per quotatura arco self.forcedTextRot = None # rotazione del testo di quota self.measure = None # misura della quota (se None viene calcolato) self.preferredAlignment = QadDimStyleAlignmentEnum.HORIZONTAL # allineamento della linea di quota self.forcedDimLineAlignment = None # allineamento della linea di quota forzato self.forcedDimLineRot = 0.0 # rotazione della linea di quota forzato self.leader = None # per disegnare la linea direttrice nella quotatura arco self.__rubberBand = QadRubberBand(self.canvas) def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) self.__rubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) self.__rubberBand.show() def clear(self): QadGetPoint.clear(self) self.__rubberBand.reset() self.mode = None def setDimLineAlignment(self, LinePosPt, horizLine1, horizLine2, verticalLine1, verticalLine2): # < 0 se a sinistra della linea sxOfHorizLine1 = True if qad_utils.leftOfLine(LinePosPt, horizLine1[0], horizLine1[1]) < 0 else False sxOfHorizLine2 = True if qad_utils.leftOfLine(LinePosPt, horizLine2[0], horizLine2[1]) < 0 else False sxOfVerticalLine1 = True if qad_utils.leftOfLine(LinePosPt, verticalLine1[0], verticalLine1[1]) < 0 else False sxOfVerticalLine2 = True if qad_utils.leftOfLine(LinePosPt, verticalLine2[0], verticalLine2[1]) < 0 else False # se LinePosPt é tra le linee di limite orizzontale e non é tra le linee di limite verticale if sxOfHorizLine1 != sxOfHorizLine2 and sxOfVerticalLine1 == sxOfVerticalLine2: self.preferredAlignment = QadDimStyleAlignmentEnum.HORIZONTAL # se LinePosPt non é tra le linee di limite orizzontale ed é tra le linee di limite verticale elif sxOfHorizLine1 == sxOfHorizLine2 and sxOfVerticalLine1 != sxOfVerticalLine2: self.preferredAlignment = QadDimStyleAlignmentEnum.VERTICAL return # ============================================================================ # setLinearDimPtsAndDimLineAlignmentOnCircle # ============================================================================ def setLinearDimPtsAndDimLineAlignmentOnCircle(self, LinePosPt, circle): pt1 = qad_utils.getPolarPointByPtAngle(circle.center, self.forcedDimLineRot, circle.radius) pt2 = qad_utils.getPolarPointByPtAngle(pt1, self.forcedDimLineRot + math.pi / 2, circle.radius) horizLine1 = [pt1, pt2] pt1 = qad_utils.getPolarPointByPtAngle(circle.center, self.forcedDimLineRot, -1 * circle.radius) pt2 = qad_utils.getPolarPointByPtAngle(pt1, self.forcedDimLineRot + math.pi / 2, circle.radius) horizLine2 = [pt1, pt2] pt1 = qad_utils.getPolarPointByPtAngle(circle.center, self.forcedDimLineRot + math.pi / 2, circle.radius) pt2 = qad_utils.getPolarPointByPtAngle(pt1, self.forcedDimLineRot, circle.radius) verticalLine1 = [pt1, pt2] pt1 = qad_utils.getPolarPointByPtAngle(circle.center, self.forcedDimLineRot + math.pi / 2, -1 * circle.radius) pt2 = qad_utils.getPolarPointByPtAngle(pt1, self.forcedDimLineRot, circle.radius) verticalLine2 = [pt1, pt2] # se non é stato impostato un allineamento forzato, lo calcolo in automatico if self.forcedDimLineAlignment is None: self.setDimLineAlignment(LinePosPt, horizLine1, horizLine2, verticalLine1, verticalLine2) else: self.preferredAlignment = self.forcedDimLineAlignment if self.preferredAlignment == QadDimStyleAlignmentEnum.HORIZONTAL: self.dimPt1 = horizLine1[0] self.dimPt2 = horizLine2[0] else: self.dimPt1 = verticalLine1[0] self.dimPt2 = verticalLine2[0] # ============================================================================ # setLinearDimLineAlignmentOnDimPts # ============================================================================ def setLinearDimLineAlignmentOnDimPts(self, LinePosPt): # se non é stato impostato un allineamento forzato, lo calcolo in automatico if self.forcedDimLineAlignment is None: pt2 = qad_utils.getPolarPointByPtAngle(self.dimPt1, self.forcedDimLineRot + math.pi / 2, 1) horizLine1 = [self.dimPt1, pt2] pt2 = qad_utils.getPolarPointByPtAngle(self.dimPt2, self.forcedDimLineRot + math.pi / 2, 1) horizLine2 = [self.dimPt2, pt2] pt2 = qad_utils.getPolarPointByPtAngle(self.dimPt1, self.forcedDimLineRot, 1) verticalLine1 = [self.dimPt1, pt2] pt2 = qad_utils.getPolarPointByPtAngle(self.dimPt2, self.forcedDimLineRot, 1) verticalLine2 = [self.dimPt2, pt2] self.setDimLineAlignment(LinePosPt, horizLine1, horizLine2, verticalLine1, verticalLine2) else: self.preferredAlignment = self.forcedDimLineAlignment # ============================================================================ # canvasMoveEvent # ============================================================================ def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) self.__rubberBand.reset() dimEntity = None # noti i punti di quotatura si richiede la posizione della linea di quota lineare if self.mode == Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_LINEAR_DIM_LINE_POS: if self.dimCircle is not None: self.setLinearDimPtsAndDimLineAlignmentOnCircle(self.tmpPoint, self.dimCircle) else: self.setLinearDimLineAlignmentOnDimPts(self.tmpPoint) dimEntity, textOffsetRect = self.dimStyle.getLinearDimFeatures( self.canvas, self.dimPt1, self.dimPt2, self.tmpPoint, self.measure, self.preferredAlignment, self.forcedDimLineRot, ) # noti i punti di quotatura si richiede la posizione della linea di quota allineata elif self.mode == Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_ALIGNED_DIM_LINE_POS: dimEntity, textOffsetRect = self.dimStyle.getAlignedDimFeatures( self.canvas, self.dimPt1, self.dimPt2, self.tmpPoint, self.measure ) # noti i punti di quotatura si richiede la posizione della linea di quota arco elif self.mode == Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_ARC_DIM_LINE_POS: dimEntity, textOffsetRect = self.dimStyle.getArcDimFeatures( self.canvas, self.dimArc, self.tmpPoint, self.measure ) if dimEntity is not None: # testo di quota self.__rubberBand.addGeometry( dimEntity.textualFeature.geometry(), self.dimStyle.getTextualLayer() ) # geom e layer self.__rubberBand.addGeometry(textOffsetRect, self.dimStyle.getTextualLayer()) # geom e layer for g in dimEntity.getLinearGeometryCollection(): self.__rubberBand.addGeometry(g, self.dimStyle.getLinearLayer()) # geom e layer for g in dimEntity.getSymbolGeometryCollection(): self.__rubberBand.addGeometry(g, self.dimStyle.getSymbolLayer()) # geom e layer def activate(self): QadGetPoint.activate(self) if self.__rubberBand is not None: self.__rubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) if self.__rubberBand is not None: self.__rubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # noto niente si richiede il primo punto di quotatura if self.mode == Qad_dim_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il primo punto si richiede il secondo punto di quotatura elif self.mode == Qad_dim_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.dimPt1) # noto i punti di quotatura si richiede la posizione della linea di quota elif self.mode == Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_LINEAR_DIM_LINE_POS: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # si richiede il testo di quota elif self.mode == Qad_dim_maptool_ModeEnum.ASK_FOR_TEXT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noti i punti di quotatura si richiede la posizione della linea di quota allineata elif self.mode == Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_ALIGNED_DIM_LINE_POS: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # si richiede un punto sull'arco per la quota arco elif self.mode == Qad_dim_maptool_ModeEnum.ASK_FOR_PARTIAL_ARC_PT_FOR_DIM_ARC: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto i punti di quotatura si richiede la posizione della linea di quota elif self.mode == Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_ARC_DIM_LINE_POS: self.setDrawMode(QadGetPointDrawModeEnum.NONE)
class Qad_pline_maptool(QadGetPoint): def __init__(self, plugIn, asToolForMPolygon=False): QadGetPoint.__init__(self, plugIn) self.firstPt = None self.mode = None self.asToolForMPolygon = asToolForMPolygon # se True significa che è usato per disegnare un poligono if self.asToolForMPolygon: self.__polygonRubberBand = QadRubberBand(self.plugIn.canvas, True) self.endVertex = None # punta al vertice iniziale e finale del poligono di QadPLINECommandClass else: self.__polylineTraceRubberBand = QadRubberBand( self.plugIn.canvas, True) # da usare in trace di un oggetto esistente def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) if self.asToolForMPolygon: self.__polygonRubberBand.hide() else: self.__polylineTraceRubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) if self.asToolForMPolygon: self.__polygonRubberBand.show() else: self.__polylineTraceRubberBand.show() def clear(self): QadGetPoint.clear(self) if self.asToolForMPolygon: self.__polygonRubberBand.reset() else: self.__polylineTraceRubberBand.reset() self.mode = None def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) if self.asToolForMPolygon == True: # se True significa che è usato per disegnare un poligono self.__polygonRubberBand.reset() else: self.__polylineTraceRubberBand.reset() startPoint = self.getStartPoint() if startPoint is None: return points = None # si richiede il punto finale per ricalcare un oggetto esistente if self.mode == Qad_pline_maptool_ModeEnum.ASK_FOR_TRACE_PT: if self.tmpEntity.isInitialized(): # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy geom = self.layerToMapCoordinates(self.tmpEntity.layer, self.tmpEntity.getGeometry()) ptEnd = qad_utils.closestVertexPtWithContext( self.tmpPoint, geom) # leggo la parte di linea tra self.firstPt e ptEnd points = qad_utils.getLinePart(geom, startPoint, ptEnd) else: points = [startPoint, self.tmpPoint] # caso di poligono if self.asToolForMPolygon: if (points is not None) and (self.endVertex is not None) and ( startPoint != self.endVertex): points.insert(0, self.endVertex) self.__polygonRubberBand.setPolygon(points) elif self.mode == Qad_pline_maptool_ModeEnum.ASK_FOR_TRACE_PT: if (points is not None): self.__polylineTraceRubberBand.setLine(points) del startPoint def activate(self): QadGetPoint.activate(self) if self.asToolForMPolygon: self.__polygonRubberBand.show() else: self.__polylineTraceRubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) if self.asToolForMPolygon: self.__polygonRubberBand.hide() else: self.__polylineTraceRubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # si richiede il punto finale per ricalcare un oggetto esistente if self.mode == Qad_pline_maptool_ModeEnum.ASK_FOR_TRACE_PT: self.checkPointLayer = False # scarto la selezione di punti self.checkLineLayer = True self.checkPolygonLayer = True self.onlyEditableLayers = False self.forceSnapTypeOnce(QadSnapTypeEnum.END) self.setSelectionMode( QadGetPointSelectionModeEnum.ENTITY_SELECTION_DYNAMIC) self.setDrawMode(QadGetPointDrawModeEnum.NONE) # non si richiede niente elif self.mode == Qad_pline_maptool_ModeEnum.NONE: self.setSelectionMode(QadGetPointSelectionModeEnum.NONE) self.setDrawMode(QadGetPointDrawModeEnum.NONE) # si deve tracciare una linea elif self.mode == Qad_pline_maptool_ModeEnum.DRAW_LINE: self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION) self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE ) # imposto la linea elastica
class Qad_dim_maptool(QadGetPoint): def __init__(self, plugIn): QadGetPoint.__init__(self, plugIn) dimStyle = None self.dimPt1 = None self.dimPt2 = None self.dimCircle = None self.forcedTextRot = None # rotazione del testo di quota self.measure = None # misura della quota (se None viene calcolato) self.preferredAlignment = QadDimStyleAlignmentEnum.HORIZONTAL # allineamento della linea di quota self.forcedDimLineAlignment = None # allineamento della linea di quota forzato self.forcedDimLineRot = 0.0 # rotazione della linea di quota forzato self.__rubberBand = QadRubberBand(self.canvas) self.centerPt = None self.radius = None self.dimPt1 = None self.dimPt2 = None self.firstDiamPt = None self.tan1 = None self.tan2 = None self.startPtForRadius = None self.geomType = QGis.Polygon def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) self.__rubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) self.__rubberBand.show() def clear(self): QadGetPoint.clear(self) self.__rubberBand.reset() self.mode = None def seDimLineAlignment(self, LinePosPt, horizLine1, horizLine2, verticalLine1, verticalLine2): # < 0 se a sinistra della linea sxOfHorizLine1 = True if qad_utils.leftOfLine(LinePosPt, horizLine1[0], horizLine1[1]) < 0 else False sxOfHorizLine2 = True if qad_utils.leftOfLine(LinePosPt, horizLine2[0], horizLine2[1]) < 0 else False sxOfVerticalLine1 = True if qad_utils.leftOfLine(LinePosPt, verticalLine1[0], verticalLine1[1]) < 0 else False sxOfVerticalLine2 = True if qad_utils.leftOfLine(LinePosPt, verticalLine2[0], verticalLine2[1]) < 0 else False # se LinePosPt é tra le linee di limite orizzontale e non é tra le linee di limite verticale if sxOfHorizLine1 != sxOfHorizLine2 and sxOfVerticalLine1 == sxOfVerticalLine2: self.preferredAlignment = QadDimStyleAlignmentEnum.HORIZONTAL # se LinePosPt non é tra le linee di limite orizzontale ed é tra le linee di limite verticale elif sxOfHorizLine1 == sxOfHorizLine2 and sxOfVerticalLine1 != sxOfVerticalLine2: self.preferredAlignment = QadDimStyleAlignmentEnum.VERTICAL return #============================================================================ # setLinearDimPtsAndDimLineAlignmentOnCircle #============================================================================ def setLinearDimPtsAndDimLineAlignmentOnCircle(self, LinePosPt, circle): pt1 = qad_utils.getPolarPointByPtAngle(circle.center, self.forcedDimLineRot, circle.radius) pt2 = qad_utils.getPolarPointByPtAngle(pt1, self.forcedDimLineRot + math.pi / 2, circle.radius) horizLine1 = [pt1, pt2] pt1 = qad_utils.getPolarPointByPtAngle(circle.center, self.forcedDimLineRot, -1 * circle.radius) pt2 = qad_utils.getPolarPointByPtAngle(pt1, self.forcedDimLineRot + math.pi / 2, circle.radius) horizLine2 = [pt1, pt2] pt1 = qad_utils.getPolarPointByPtAngle(circle.center, self.forcedDimLineRot + math.pi / 2, circle.radius) pt2 = qad_utils.getPolarPointByPtAngle(pt1, self.forcedDimLineRot, circle.radius) verticalLine1 = [pt1, pt2] pt1 = qad_utils.getPolarPointByPtAngle(circle.center, self.forcedDimLineRot + math.pi / 2, -1 * circle.radius) pt2 = qad_utils.getPolarPointByPtAngle(pt1, self.forcedDimLineRot, circle.radius) verticalLine2 = [pt1, pt2] # se non é stato impostato un allineamento forzato, lo calcolo in automatico if self.forcedDimLineAlignment is None: self.seDimLineAlignment(LinePosPt, horizLine1, horizLine2, verticalLine1, verticalLine2) else: self.preferredAlignment = self.forcedDimLineAlignment if self.preferredAlignment == QadDimStyleAlignmentEnum.HORIZONTAL: self.dimPt1 = horizLine1[0] self.dimPt2 = horizLine2[0] else: self.dimPt1 = verticalLine1[0] self.dimPt2 = verticalLine2[0] #============================================================================ # setLinearDimLineAlignmentOnDimPts #============================================================================ def setLinearDimLineAlignmentOnDimPts(self, LinePosPt): # se non é stato impostato un allineamento forzato, lo calcolo in automatico if self.forcedDimLineAlignment is None: pt2 = qad_utils.getPolarPointByPtAngle(self.dimPt1, self.forcedDimLineRot + math.pi / 2, 1) horizLine1 = [self.dimPt1, pt2] pt2 = qad_utils.getPolarPointByPtAngle(self.dimPt2, self.forcedDimLineRot + math.pi / 2, 1) horizLine2 = [self.dimPt2, pt2] pt2 = qad_utils.getPolarPointByPtAngle(self.dimPt1, self.forcedDimLineRot, 1) verticalLine1 = [self.dimPt1, pt2] pt2 = qad_utils.getPolarPointByPtAngle(self.dimPt2, self.forcedDimLineRot, 1) verticalLine2 = [self.dimPt2, pt2] self.seDimLineAlignment(LinePosPt, horizLine1, horizLine2, verticalLine1, verticalLine2) else: self.preferredAlignment = self.forcedDimLineAlignment #============================================================================ # canvasMoveEvent #============================================================================ def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) self.__rubberBand.reset() dimEntity = None # noti i punti di quotatura si richiede la posizione della linea di quota lineare if self.mode == Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_LINEAR_DIM_LINE_POS: if self.dimCircle is not None: self.setLinearDimPtsAndDimLineAlignmentOnCircle(self.tmpPoint, self.dimCircle) else: self.setLinearDimLineAlignmentOnDimPts(self.tmpPoint) dimEntity, textOffsetRect = self.dimStyle.getLinearDimFeatures(self.canvas, \ self.dimPt1, \ self.dimPt2, \ self.tmpPoint, \ self.measure, \ self.preferredAlignment, \ self.forcedDimLineRot) # noti i punti di quotatura si richiede la posizione della linea di quota allineata elif self.mode == Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_ALIGNED_DIM_LINE_POS: dimEntity, textOffsetRect = self.dimStyle.getAlignedDimFeatures(self.canvas, \ self.dimPt1, \ self.dimPt2, \ self.tmpPoint, \ self.measure) if dimEntity is not None: # testo di quota self.__rubberBand.addGeometry(dimEntity.textualFeature.geometry(), self.dimStyle.getTextualLayer()) # geom e layer self.__rubberBand.addGeometry(textOffsetRect, self.dimStyle.getTextualLayer()) # geom e layer for g in dimEntity.getLinearGeometryCollection(): self.__rubberBand.addGeometry(g, self.dimStyle.getLinearLayer()) # geom e layer for g in dimEntity.getSymbolGeometryCollection(): self.__rubberBand.addGeometry(g, self.dimStyle.getSymbolLayer()) # geom e layer def activate(self): QadGetPoint.activate(self) if self.__rubberBand is not None: self.__rubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) if self.__rubberBand is not None: self.__rubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # noto niente si richiede il primo punto di quotatura if self.mode == Qad_dim_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il primo punto si richiede il secondo punto di quotatura elif self.mode == Qad_dim_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.dimPt1) # noto i punti di quotatura si richiede la posizione della linea di quota elif self.mode == Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_LINEAR_DIM_LINE_POS: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # si richiede il testo di quota elif self.mode == Qad_dim_maptool_ModeEnum.ASK_FOR_TEXT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noti i punti di quotatura si richiede la posizione della linea di quota allineata elif self.mode == Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_ALIGNED_DIM_LINE_POS: self.setDrawMode(QadGetPointDrawModeEnum.NONE)
class Qad_move_maptool(QadGetPoint): def __init__(self, plugIn): QadGetPoint.__init__(self, plugIn) self.basePt = None self.entitySet = QadEntitySet() self.__rubberBand = QadRubberBand(self.canvas) def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) self.__rubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) self.__rubberBand.show() def clear(self): QadGetPoint.clear(self) self.__rubberBand.reset() self.mode = None #============================================================================ # move #============================================================================ def move(self, f, offSetX, offSetY, layerEntitySet, entitySet): # verifico se l'entità appartiene ad uno stile di quotatura dimEntity = self.plugIn.dimStyles.getDimEntity(layerEntitySet.layer, f.id()) if dimEntity is None: # sposto la feature e la rimuovo da entitySet (é la prima) f.setGeometry(qad_utils.moveQgsGeometry(f.geometry(), offSetX, offSetY)) self.__rubberBand.addGeometry(f.geometry(), layerEntitySet.layer) del layerEntitySet.featureIds[0] else: # sposto la quota e la rimuovo da entitySet dimEntitySet = dimEntity.getEntitySet() dimEntity.move(offSetX, offSetY) self.__rubberBand.addGeometry(dimEntity.textualFeature.geometry(), dimEntity.getTextualLayer()) self.__rubberBand.addGeometries(dimEntity.getLinearGeometryCollection(), dimEntity.getLinearLayer()) self.__rubberBand.addGeometries(dimEntity.getSymbolGeometryCollection(), dimEntity.getSymbolLayer()) entitySet.subtract(dimEntitySet) def addMovedGeometries(self, newPt): self.__rubberBand.reset() # copio entitySet entitySet = QadEntitySet(self.entitySet) for layerEntitySet in entitySet.layerEntitySetList: layer = layerEntitySet.layer transformedBasePt = self.canvas.mapRenderer().mapToLayerCoordinates(layer, self.basePt) transformedNewPt = self.canvas.mapRenderer().mapToLayerCoordinates(layer, newPt) offSetX = transformedNewPt.x() - transformedBasePt.x() offSetY = transformedNewPt.y() - transformedBasePt.y() while len(layerEntitySet.featureIds) > 0: featureId = layerEntitySet.featureIds[0] f = layerEntitySet.getFeature(featureId) self.move(f, offSetX, offSetY, layerEntitySet, entitySet) def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) # noto il punto base si richiede il secondo punto if self.mode == Qad_move_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_MOVE_PT: self.addMovedGeometries(self.tmpPoint) def activate(self): QadGetPoint.activate(self) self.__rubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) self.__rubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # noto niente si richiede il punto base if self.mode == Qad_move_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_BASE_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il punto base si richiede il secondo punto elif self.mode == Qad_move_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_MOVE_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.basePt)
class Qad_pline_maptool(QadGetPoint): def __init__(self, plugIn, asToolForMPolygon = False): QadGetPoint.__init__(self, plugIn) self.firstPt = None self.mode = None self.asToolForMPolygon = asToolForMPolygon # se True significa che è usato per disegnare un poligono if self.asToolForMPolygon: self.__polygonRubberBand = QadRubberBand(self.plugIn.canvas, True) self.endVertex = None # punta al vertice iniziale e finale del poligono di QadPLINECommandClass else: self.__polylineTraceRubberBand = QadRubberBand(self.plugIn.canvas, True) # da usare in trace di un oggetto esistente def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) if self.asToolForMPolygon: self.__polygonRubberBand.hide() else: self.__polylineTraceRubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) if self.asToolForMPolygon: self.__polygonRubberBand.show() else: self.__polylineTraceRubberBand.show() def clear(self): QadGetPoint.clear(self) if self.asToolForMPolygon: self.__polygonRubberBand.reset() else: self.__polylineTraceRubberBand.reset() self.mode = None def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) if self.asToolForMPolygon == True: # se True significa che è usato per disegnare un poligono self.__polygonRubberBand.reset() else: self.__polylineTraceRubberBand.reset() startPoint = self.getStartPoint() if startPoint is None: return points = None # si richiede il punto finale per ricalcare un oggetto esistente if self.mode == Qad_pline_maptool_ModeEnum.ASK_FOR_TRACE_PT: if self.tmpEntity.isInitialized(): # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy geom = self.layerToMapCoordinates(self.tmpEntity.layer, self.tmpEntity.getGeometry()) ptEnd = qad_utils.closestVertexPtWithContext(self.tmpPoint, geom) # leggo la parte di linea tra self.firstPt e ptEnd points = qad_utils.getLinePart(geom, startPoint, ptEnd) else: points = [startPoint, self.tmpPoint] # caso di poligono if self.asToolForMPolygon: if (points is not None) and (self.endVertex is not None) and (startPoint != self.endVertex): points.insert(0, self.endVertex) self.__polygonRubberBand.setPolygon(points) elif self.mode == Qad_pline_maptool_ModeEnum.ASK_FOR_TRACE_PT: if (points is not None): self.__polylineTraceRubberBand.setLine(points) del startPoint def activate(self): QadGetPoint.activate(self) if self.asToolForMPolygon: self.__polygonRubberBand.show() else: self.__polylineTraceRubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) if self.asToolForMPolygon: self.__polygonRubberBand.hide() else: self.__polylineTraceRubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # si richiede il punto finale per ricalcare un oggetto esistente if self.mode == Qad_pline_maptool_ModeEnum.ASK_FOR_TRACE_PT: self.checkPointLayer = False # scarto la selezione di punti self.checkLineLayer = True self.checkPolygonLayer = True self.onlyEditableLayers = False self.forceSnapTypeOnce(QadSnapTypeEnum.END) self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION_DYNAMIC) self.setDrawMode(QadGetPointDrawModeEnum.NONE) # non si richiede niente elif self.mode == Qad_pline_maptool_ModeEnum.NONE: self.setSelectionMode(QadGetPointSelectionModeEnum.NONE) self.setDrawMode(QadGetPointDrawModeEnum.NONE) # si deve tracciare una linea elif self.mode == Qad_pline_maptool_ModeEnum.DRAW_LINE: self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION) self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) # imposto la linea elastica
class Qad_polygon_maptool(QadGetPoint): def __init__(self, plugIn): QadGetPoint.__init__(self, plugIn) self.mode = None self.sideNumber = None self.centerPt = None self.constructionModeByCenter = None self.firstEdgePt = None self.vertices = [] self.__rubberBand = QadRubberBand(self.canvas, True) self.geomType = QGis.Polygon def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) self.__rubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) self.__rubberBand.show() def clear(self): QadGetPoint.clear(self) self.__rubberBand.reset() self.mode = None def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) self.__rubberBand.reset() result = False del self.vertices[:] # svuoto la lista if self.mode is not None: # noto il centro si richiede il raggio if self.mode == Qad_polygon_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_RADIUS: radius = qad_utils.getDistance(self.centerPt, self.tmpPoint) InscribedOption = True if self.constructionModeByCenter == QadMsg.translate( "Command_POLYGON", "Inscribed in circle") else False self.vertices.extend(qad_utils.getPolygonByNsidesCenterRadius(self.sideNumber, self.centerPt, radius, \ InscribedOption, self.tmpPoint)) result = True # si richiede il secondo punto dello spigolo elif self.mode == Qad_polygon_maptool_ModeEnum.FIRST_EDGE_PT_KNOWN_ASK_FOR_SECOND_EDGE_PT: self.vertices.extend(qad_utils.getPolygonByNsidesEdgePts(self.sideNumber, self.firstEdgePt, \ self.tmpPoint)) result = True if result == True: if self.vertices is not None: if self.geomType == QGis.Polygon: self.__rubberBand.setPolygon(self.vertices) else: self.__rubberBand.setLine(self.vertices) def activate(self): QadGetPoint.activate(self) self.__rubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) self.__rubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # si richiede il centro if self.mode == Qad_polygon_maptool_ModeEnum.ASK_FOR_CENTER_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il centro si richiede il raggio if self.mode == Qad_polygon_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_RADIUS: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.centerPt) # si richiede il primo punto dello spigolo if self.mode == Qad_polygon_maptool_ModeEnum.ASK_FOR_FIRST_EDGE_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # si richiede il secondo punto dello spigolo if self.mode == Qad_polygon_maptool_ModeEnum.FIRST_EDGE_PT_KNOWN_ASK_FOR_SECOND_EDGE_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.firstEdgePt)
class Qad_pedit_maptool(QadGetPoint): def __init__(self, plugIn): QadGetPoint.__init__(self, plugIn) self.firstPt = None self.layer = None self.linearObjectList = qad_utils.QadLinearObjectList() self.tolerance2ApproxCurve = None self.vertexAt = 0 self.after = True self.__rubberBand = QadRubberBand(self.canvas) def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) self.__rubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) self.__rubberBand.show() def clear(self): QadGetPoint.clear(self) self.__rubberBand.reset() self.mode = None def setLinearObjectList(self, linearObjectList, layer): self.linearObjectList.set(linearObjectList) self.layer = layer self.tolerance2ApproxCurve = qad_utils.distMapToLayerCoordinates(QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE")), \ self.canvas,\ self.layer) def setVertexAt(self, vertexAt, after = None): if vertexAt == self.linearObjectList.qty(): pt = self.linearObjectList.getLinearObjectAt(-1).getEndPt() else: pt = self.linearObjectList.getLinearObjectAt(vertexAt).getStartPt() self.firstPt = self.canvas.mapRenderer().layerToMapCoordinates(self.layer, pt) self.vertexAt = vertexAt self.after = after def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) self.__rubberBand.reset() tmpLinearObjectList = None # noti il primo punto e il centro dell'arco si richiede il punto finale if self.mode == Qad_pedit_maptool_ModeEnum.ASK_FOR_NEW_VERTEX: newPt = self.canvas.mapRenderer().mapToLayerCoordinates(self.layer, self.tmpPoint) tmpLinearObjectList = qad_utils.QadLinearObjectList() tmpLinearObjectList.set(self.linearObjectList) if self.after: # dopo if self.vertexAt == tmpLinearObjectList.qty() and tmpLinearObjectList.isClosed(): tmpLinearObjectList.insertPoint(0, newPt) else: tmpLinearObjectList.insertPoint(self.vertexAt, newPt) else: # prima if self.vertexAt == 0 and tmpLinearObjectList.isClosed(): tmpLinearObjectList.insertPoint(tmpLinearObjectList.qty() - 1, newPt) else: tmpLinearObjectList.insertPoint(self.vertexAt - 1, newPt) elif self.mode == Qad_pedit_maptool_ModeEnum.ASK_FOR_MOVE_VERTEX: newPt = self.canvas.mapRenderer().mapToLayerCoordinates(self.layer, self.tmpPoint) tmpLinearObjectList = qad_utils.QadLinearObjectList() tmpLinearObjectList.set(self.linearObjectList) tmpLinearObjectList.movePoint(self.vertexAt, newPt) if tmpLinearObjectList is not None: pts = tmpLinearObjectList.asPolyline(self.tolerance2ApproxCurve) if self.layer.geometryType() == QGis.Polygon: geom = QgsGeometry.fromPolygon([pts]) else: geom = QgsGeometry.fromPolyline(pts) self.__rubberBand.addGeometry(geom, self.layer) def activate(self): QadGetPoint.activate(self) self.__rubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) self.__rubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # si richiede la selezione di un'entità if self.mode == Qad_pedit_maptool_ModeEnum.ASK_FOR_ENTITY_SEL: self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION) # solo layer lineari o poligono editabili che non appartengano a quote layerList = [] for layer in self.plugIn.canvas.layers(): if layer.type() == QgsMapLayer.VectorLayer and \ (layer.geometryType() == QGis.Line or layer.geometryType() == QGis.Polygon) and \ layer.isEditable(): if len(self.plugIn.dimStyles.getDimListByLayer(layer)) == 0: layerList.append(layer) self.layersToCheck = layerList self.setSnapType(QadSnapTypeEnum.DISABLE) # non si richiede niente elif self.mode == Qad_pedit_maptool_ModeEnum.NONE: self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION) self.setDrawMode(QadGetPointDrawModeEnum.NONE) # si richiede il primo punto per calcolo distanza di approssimazione # si richiede la posizione più vicina ad un vertice elif self.mode == Qad_pedit_maptool_ModeEnum.ASK_FOR_FIRST_TOLERANCE_PT: self.onlyEditableLayers = False self.checkPointLayer = True self.checkLineLayer = True self.checkPolygonLayer = True self.setSnapType() self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION) self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il primo punto per calcolo distanza di approssimazione si richiede il secondo punto # noto il primo punto per calcolo distanza di approssimazione si richiede il secondo punto elif self.mode == Qad_pedit_maptool_ModeEnum.FIRST_TOLERANCE_PT_KNOWN_ASK_FOR_SECOND_PT or \ self.mode == Qad_pedit_maptool_ModeEnum.ASK_FOR_NEW_VERTEX or \ self.mode == Qad_pedit_maptool_ModeEnum.ASK_FOR_MOVE_VERTEX: self.onlyEditableLayers = False self.checkPointLayer = True self.checkLineLayer = True self.checkPolygonLayer = True self.setSnapType() self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION) self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.firstPt) # si richiede la posizione più vicina ad un vertice elif self.mode == Qad_pedit_maptool_ModeEnum.ASK_FOR_VERTEX: self.setSnapType(QadSnapTypeEnum.DISABLE) self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION) self.setDrawMode(QadGetPointDrawModeEnum.NONE)
class Qad_mbuffer_maptool(QadGetPoint): def __init__(self, plugIn): QadGetPoint.__init__(self, plugIn) self.startPtForBufferWidth = None # vedi il numero minimo di punti affinché venga riconosciuto un arco o un cerchio # nei files qad_arc.py e qad_circle.py self.segments = 12 self.entitySet = QadEntitySet() self.geomType = QGis.Polygon self.__rubberBand = QadRubberBand(self.canvas, True) def setRubberBandColor(self, rubberBandBorderColor, rubberBandFillColor): if rubberBandBorderColor is not None: self.__rubberBand.setBorderColor(rubberBandBorderColor) if rubberBandFillColor is not None: self.__rubberBand.setFillColor(rubberBandFillColor) def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) self.__rubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) self.__rubberBand.show() def clear(self): QadGetPoint.clear(self) self.__rubberBand.reset() self.mode = None def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) self.__rubberBand.reset() # noto il primo punto si richiede la larghezza del buffer if self.mode == Qad_mbuffer_maptool_ModeEnum.FIRST_PT_ASK_FOR_BUFFER_WIDTH: width = qad_utils.getDistance(self.startPtForBufferWidth, self.tmpPoint) tolerance = QadVariables.get( QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE")) for layerEntitySet in self.entitySet.layerEntitySetList: layer = layerEntitySet.layer geoms = layerEntitySet.getGeometryCollection() for geom in geoms: # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy newGeom = self.layerToMapCoordinates(layer, geom) bufferGeom = qad_utils.ApproxCurvesOnGeom(newGeom.buffer(width, self.segments), \ self.segments, self.segments, \ tolerance) if bufferGeom: # trasformo la geometria nel crs del layer self.__rubberBand.addGeometry( self.mapToLayerCoordinates(layer, bufferGeom), layer) def activate(self): QadGetPoint.activate(self) self.__rubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) self.__rubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # noto niente si richiede il primo punto if self.mode == Qad_mbuffer_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il primo punto si richiede la larghezza del buffer elif self.mode == Qad_mbuffer_maptool_ModeEnum.FIRST_PT_ASK_FOR_BUFFER_WIDTH: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.startPtForBufferWidth)
class Qad_mbuffer_maptool(QadGetPoint): def __init__(self, plugIn): QadGetPoint.__init__(self, plugIn) self.startPtForBufferWidth = None # vedi il numero minimo di punti affinché venga riconosciuto un arco o un cerchio # nei files qad_arc.py e qad_circle.py self.segments = 12 self.entitySet = QadEntitySet() self.geomType = QGis.Polygon self.__rubberBand = QadRubberBand(self.canvas, True) def setRubberBandColor(self, rubberBandBorderColor, rubberBandFillColor): if rubberBandBorderColor is not None: self.__rubberBand.setBorderColor(rubberBandBorderColor) if rubberBandFillColor is not None: self.__rubberBand.setFillColor(rubberBandFillColor) def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) self.__rubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) self.__rubberBand.show() def clear(self): QadGetPoint.clear(self) self.__rubberBand.reset() self.mode = None def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) self.__rubberBand.reset() # noto il primo punto si richiede la larghezza del buffer if self.mode == Qad_mbuffer_maptool_ModeEnum.FIRST_PT_ASK_FOR_BUFFER_WIDTH: width = qad_utils.getDistance(self.startPtForBufferWidth, self.tmpPoint) tolerance = QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE")) for layerEntitySet in self.entitySet.layerEntitySetList: layer = layerEntitySet.layer geoms = layerEntitySet.getGeometryCollection() for geom in geoms: # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy newGeom = self.layerToMapCoordinates(layer, geom) bufferGeom = qad_utils.ApproxCurvesOnGeom(newGeom.buffer(width, self.segments), \ self.segments, self.segments, \ tolerance) if bufferGeom: # trasformo la geometria nel crs del layer self.__rubberBand.addGeometry(self.mapToLayerCoordinates(layer, bufferGeom), layer) def activate(self): QadGetPoint.activate(self) self.__rubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) self.__rubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # noto niente si richiede il primo punto if self.mode == Qad_mbuffer_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il primo punto si richiede la larghezza del buffer elif self.mode == Qad_mbuffer_maptool_ModeEnum.FIRST_PT_ASK_FOR_BUFFER_WIDTH: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.startPtForBufferWidth)
class Qad_line_maptool(QadGetPoint): def __init__(self, plugIn): QadGetPoint.__init__(self, plugIn) self.firstPt = None self.tan1 = None self.per1 = None self.geom1 = None self.__rubberBand = QadRubberBand(self.canvas) def __del__(self): QadGetPoint.__del__(self) def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) self.__rubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) self.__rubberBand.show() def clear(self): QadGetPoint.clear(self) self.__rubberBand.reset() self.mode = None def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) self.__rubberBand.reset() line = None # noto il primo punto si richiede il secondo punto if self.mode == Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT: if self.firstPt is not None: line = [self.firstPt, self.tmpPoint] # nota l'entita del primo punto di tangenza si richiede il secondo punto elif self.mode == Qad_line_maptool_ModeEnum.FIRST_TAN_KNOWN_ASK_FOR_SECOND_PT: snapper = QadSnapper() snapper.setSnapPointCRS(self.canvas.mapSettings().destinationCrs()) snapper.setSnapType(QadSnapTypeEnum.TAN) snapper.setStartPoint(self.tmpPoint) oSnapPoints = snapper.getSnapPoint(self.geom1, self.tan1, self.canvas.mapSettings().destinationCrs()) # memorizzo il punto di snap in point (prendo il primo valido) for item in oSnapPoints.items(): points = item[1] if points is not None: line = [points[0], self.tmpPoint] break # nota l'entita del primo punto di perpendicolarità si richiede il secondo punto elif self.mode == Qad_line_maptool_ModeEnum.FIRST_PER_KNOWN_ASK_FOR_SECOND_PT: snapper = QadSnapper() snapper.setSnapPointCRS(self.canvas.mapSettings().destinationCrs()) snapper.setSnapType(QadSnapTypeEnum.PER) snapper.setStartPoint(self.tmpPoint) oSnapPoints = snapper.getSnapPoint(self.geom1, self.per1, self.canvas.mapSettings().destinationCrs()) # memorizzo il punto di snap in point (prendo il primo valido) for item in oSnapPoints.items(): points = item[1] if points is not None: line = [points[0], self.tmpPoint] break if line is not None: self.__rubberBand.setLine(line) def activate(self): QadGetPoint.activate(self) self.__rubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) self.__rubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # noto niente si richiede il primo punto if self.mode == Qad_line_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) self.setStartPoint(None) # noto il primo punto si richiede il secondo punto elif self.mode == Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.firstPt) # nota l'entita del primo punto di tangenza si richiede il secondo punto elif self.mode == Qad_line_maptool_ModeEnum.FIRST_TAN_KNOWN_ASK_FOR_SECOND_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # nota l'entita del primo punto di perpendicolarità si richiede il secondo punto elif self.mode == Qad_line_maptool_ModeEnum.FIRST_PER_KNOWN_ASK_FOR_SECOND_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE)
class Qad_arc_maptool(QadGetPoint): def __init__(self, plugIn, asToolForMPolygon=False): QadGetPoint.__init__(self, plugIn) self.arcStartPt = None self.arcSecondPt = None self.arcEndPt = None self.arcCenterPt = None self.arcTanOnStartPt = None self.arcAngle = None self.arcStartPtForRadius = None self.arcRadius = None self.__rubberBand = QadRubberBand(self.canvas) self.asToolForMPolygon = asToolForMPolygon # se True significa che è usato per disegnare un poligono if self.asToolForMPolygon: self.__polygonRubberBand = QadRubberBand(self.plugIn.canvas, True) self.endVertex = None # punta al vertice iniziale e finale del poligono di QadPLINECommandClass def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) self.__rubberBand.hide() if self.asToolForMPolygon: self.__polygonRubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) self.__rubberBand.show() if self.asToolForMPolygon: self.__polygonRubberBand.show() def clear(self): QadGetPoint.clear(self) self.__rubberBand.reset() if self.asToolForMPolygon: self.__polygonRubberBand.reset() self.mode = None def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) self.__rubberBand.reset() if self.asToolForMPolygon: self.__polygonRubberBand.reset() result = False arc = QadArc() # noti il primo e il secondo punto dell'arco si richiede il terzo punto if self.mode == Qad_arc_maptool_ModeEnum.START_SECOND_PT_KNOWN_ASK_FOR_END_PT: result = arc.fromStartSecondEndPts(self.arcStartPt, self.arcSecondPt, self.tmpPoint) # noti il primo punto e il centro dell'arco si richiede il punto finale elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_END_PT: result = arc.fromStartCenterEndPts(self.arcStartPt, self.arcCenterPt, self.tmpPoint) if result == True and self.tmpCtrlKey: # cambio direzione arc.inverse() # noti il primo punto e il centro dell'arco si richiede l'angolo inscritto elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_ANGLE: angle = qad_utils.getAngleBy2Pts(self.arcCenterPt, self.tmpPoint) result = arc.fromStartCenterPtsAngle(self.arcStartPt, self.arcCenterPt, angle) if result == True and self.tmpCtrlKey: # cambio direzione arc.inverse() # noti il primo punto e il centro dell'arco si richiede la lunghezza della corda elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_CHORD: chord = qad_utils.getDistance(self.arcStartPt, self.tmpPoint) result = arc.fromStartCenterPtsChord(self.arcStartPt, self.arcCenterPt, chord) if result == True and self.tmpCtrlKey: # cambio direzione arc.inverse() # noti il punto iniziale e finale dell'arco si richiede il centro elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_CENTER: result = arc.fromStartCenterEndPts(self.arcStartPt, self.tmpPoint, self.arcEndPt) if result == True and self.tmpCtrlKey: # cambio direzione arc.inverse() # noti il punto iniziale e finale dell'arco si richiede l'angolo inscritto elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_ANGLE: angle = qad_utils.getAngleBy2Pts(self.arcStartPt, self.tmpPoint) result = arc.fromStartEndPtsAngle(self.arcStartPt, self.arcEndPt, angle) if result == True and self.tmpCtrlKey: # cambio direzione arc.inverse() # noti il punto iniziale e finale dell'arco si richiede la direzione della tangente elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_TAN: tan = qad_utils.getAngleBy2Pts(self.arcStartPt, self.tmpPoint) result = arc.fromStartEndPtsTan(self.arcStartPt, self.arcEndPt, tan) if result == True and self.tmpCtrlKey: # cambio direzione arc.inverse() # noti il punto iniziale e finale dell'arco si richiede il raggio elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_RADIUS: radius = qad_utils.getDistance(self.arcEndPt, self.tmpPoint) result = arc.fromStartEndPtsRadius(self.arcStartPt, self.arcEndPt, radius) if result == True and self.tmpCtrlKey: # cambio direzione arc.inverse() # noti il punto iniziale e la tangente al punto iniziale si richiede il punto finale elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_TAN_KNOWN_ASK_FOR_END_PT: result = arc.fromStartEndPtsTan(self.arcStartPt, self.tmpPoint, self.arcTanOnStartPt) if result == True and self.tmpCtrlKey: # cambio direzione arc.inverse() # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il punto finale elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_END_PT: result = arc.fromStartEndPtsAngle(self.arcStartPt, self.tmpPoint, self.arcAngle) if result == True and self.tmpCtrlKey: # cambio direzione arc.inverse() # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il centro elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_CENTER_PT: result = arc.fromStartCenterPtsAngle(self.arcStartPt, self.tmpPoint, self.arcAngle) if result == True and self.tmpCtrlKey: # cambio direzione arc.inverse() # noti il punto iniziale, l'angolo inscritto e il raggio dell'arco si richiede la direzione della corda elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_RADIUS_KNOWN_ASK_FOR_CHORDDIRECTION: chordDirection = qad_utils.getAngleBy2Pts(self.arcStartPt, self.tmpPoint) result = arc.fromStartPtAngleRadiusChordDirection(self.arcStartPt, self.arcAngle, \ self.arcRadius, chordDirection) if result == True and self.tmpCtrlKey: # cambio direzione arc.inverse() # noti il punto iniziale e il raggio dell'arco si richiede il punto finale elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_RADIUS_KNOWN_ASK_FOR_END_PT: result = arc.fromStartEndPtsRadius(self.arcStartPt, self.tmpPoint, self.arcRadius) if result == True and self.tmpCtrlKey: # cambio direzione arc.inverse() if result == True: points = arc.asPolyline() if points is not None: self.__rubberBand.setLine(points) if self.asToolForMPolygon == True: # se True significa che è usato per disegnare un poligono if self.endVertex is not None: points.insert(0, self.endVertex) self.__polygonRubberBand.setPolygon(points) def activate(self): QadGetPoint.activate(self) self.__rubberBand.show() if self.asToolForMPolygon: self.__polygonRubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) self.__rubberBand.hide() if self.asToolForMPolygon: self.__polygonRubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # noto niente si richiede il primo punto if self.mode == Qad_arc_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_START_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il primo punto dell'arco si richiede il secondo punto elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_KNOWN_ASK_FOR_SECOND_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt) # noti il primo e il secondo punto dell'arco si richiede il terzo punto elif self.mode == Qad_arc_maptool_ModeEnum.START_SECOND_PT_KNOWN_ASK_FOR_END_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il primo punto dell'arco si richiede il centro elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_KNOWN_ASK_FOR_CENTER_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt) # noti il primo punto e il centro dell'arco si richiede il punto finale elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_END_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcCenterPt) # noti il primo punto e il centro dell'arco si richiede l'angolo inscritto elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_ANGLE: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcCenterPt) # noti il primo punto e il centro dell'arco si richiede la lunghezza della corda elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_CHORD: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt) # noto il punto iniziale dell'arco si richiede il punto finale elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_KNOWN_ASK_FOR_END_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt) # noti il punto iniziale e finale dell'arco si richiede il centro elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_CENTER: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noti il punto iniziale e finale dell'arco si richiede l'angolo inscritto elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_ANGLE: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt) # noti il punto iniziale e finale dell'arco si richiede la direzione della tangente elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_TAN: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt) # noti il punto iniziale e finale dell'arco si richiede il raggio elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_RADIUS: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcEndPt) # noto niente si richiede il centro elif self.mode == Qad_arc_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_CENTER_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il centro dell'arco si richiede il punto iniziale elif self.mode == Qad_arc_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_START_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcCenterPt) # noti il punto iniziale e la tangente al punto iniziale si richiede il punto finale elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_TAN_KNOWN_ASK_FOR_END_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt) # noto il punto iniziale dell'arco si richiede l'angolo inscritto elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_KNOWN_ASK_FOR_ANGLE: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt) # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il punto finale elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_END_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt) # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il centro elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_CENTER_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il raggio elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_RADIUS: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il secondo punto per misurare il raggio elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_SECONDPTRADIUS: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPtForRadius) # noti il punto iniziale, l'angolo inscritto e il raggio dell'arco si richiede la direzione della corda elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_RADIUS_KNOWN_ASK_FOR_CHORDDIRECTION: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt) # noti il punto iniziale e il raggio dell'arco si richiede il punto finale elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_RADIUS_KNOWN_ASK_FOR_END_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.arcStartPt)
class Qad_line_maptool(QadGetPoint): def __init__(self, plugIn): QadGetPoint.__init__(self, plugIn) self.firstPt = None self.tan1 = None self.per1 = None self.geom1 = None self.__rubberBand = QadRubberBand(self.canvas) def __del__(self): QadGetPoint.__del__(self) def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) self.__rubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) self.__rubberBand.show() def clear(self): QadGetPoint.clear(self) self.__rubberBand.reset() self.mode = None def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) self.__rubberBand.reset() line = None # noto il primo punto si richiede il secondo punto if self.mode == Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT: if (self.firstPt is not None): line = [self.firstPt, self.tmpPoint] # nota l'entita del primo punto di tangenza si richiede il secondo punto elif self.mode == Qad_line_maptool_ModeEnum.FIRST_TAN_KNOWN_ASK_FOR_SECOND_PT: snapper = QadSnapper() snapper.setSnapPointCRS(self.canvas.mapRenderer().destinationCrs()) snapper.setSnapType(QadSnapTypeEnum.TAN) snapper.setStartPoint(self.tmpPoint) oSnapPoints = snapper.getSnapPoint( self.geom1, self.tan1, self.canvas.mapRenderer().destinationCrs()) # memorizzo il punto di snap in point (prendo il primo valido) for item in oSnapPoints.items(): points = item[1] if points is not None: line = [points[0], self.tmpPoint] break # nota l'entita del primo punto di perpendicolarità si richiede il secondo punto elif self.mode == Qad_line_maptool_ModeEnum.FIRST_PER_KNOWN_ASK_FOR_SECOND_PT: snapper = QadSnapper() snapper.setSnapPointCRS(self.canvas.mapRenderer().destinationCrs()) snapper.setSnapType(QadSnapTypeEnum.PER) snapper.setStartPoint(self.tmpPoint) oSnapPoints = snapper.getSnapPoint( self.geom1, self.per1, self.canvas.mapRenderer().destinationCrs()) # memorizzo il punto di snap in point (prendo il primo valido) for item in oSnapPoints.items(): points = item[1] if points is not None: line = [points[0], self.tmpPoint] break if line is not None: self.__rubberBand.setLine(line) def activate(self): QadGetPoint.activate(self) self.__rubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) self.__rubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # noto niente si richiede il primo punto if self.mode == Qad_line_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) self.setStartPoint(None) # noto il primo punto si richiede il secondo punto elif self.mode == Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.firstPt) # nota l'entita del primo punto di tangenza si richiede il secondo punto elif self.mode == Qad_line_maptool_ModeEnum.FIRST_TAN_KNOWN_ASK_FOR_SECOND_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # nota l'entita del primo punto di perpendicolarità si richiede il secondo punto elif self.mode == Qad_line_maptool_ModeEnum.FIRST_PER_KNOWN_ASK_FOR_SECOND_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE)
class Qad_polygon_maptool(QadGetPoint): def __init__(self, plugIn): QadGetPoint.__init__(self, plugIn) self.mode = None self.sideNumber = None self.centerPt = None self.constructionModeByCenter = None self.firstEdgePt = None self.vertices = [] self.__rubberBand = QadRubberBand(self.canvas, True) self.geomType = QGis.Polygon def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) self.__rubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) self.__rubberBand.show() def clear(self): QadGetPoint.clear(self) self.__rubberBand.reset() self.mode = None def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) self.__rubberBand.reset() result = False del self.vertices[:] # svuoto la lista if self.mode is not None: # noto il centro si richiede il raggio if self.mode == Qad_polygon_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_RADIUS: radius = qad_utils.getDistance(self.centerPt, self.tmpPoint) InscribedOption = True if self.constructionModeByCenter == QadMsg.translate("Command_POLYGON", "Inscribed in circle") else False self.vertices.extend(qad_utils.getPolygonByNsidesCenterRadius(self.sideNumber, self.centerPt, radius, \ InscribedOption, self.tmpPoint)) result = True # si richiede il secondo punto dello spigolo elif self.mode == Qad_polygon_maptool_ModeEnum.FIRST_EDGE_PT_KNOWN_ASK_FOR_SECOND_EDGE_PT: self.vertices.extend(qad_utils.getPolygonByNsidesEdgePts(self.sideNumber, self.firstEdgePt, \ self.tmpPoint)) result = True if result == True: if self.vertices is not None: if self.geomType == QGis.Polygon: self.__rubberBand.setPolygon(self.vertices) else: self.__rubberBand.setLine(self.vertices) def activate(self): QadGetPoint.activate(self) self.__rubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) self.__rubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # si richiede il centro if self.mode == Qad_polygon_maptool_ModeEnum.ASK_FOR_CENTER_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il centro si richiede il raggio if self.mode == Qad_polygon_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_RADIUS: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.centerPt) # si richiede il primo punto dello spigolo if self.mode == Qad_polygon_maptool_ModeEnum.ASK_FOR_FIRST_EDGE_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # si richiede il secondo punto dello spigolo if self.mode == Qad_polygon_maptool_ModeEnum.FIRST_EDGE_PT_KNOWN_ASK_FOR_SECOND_EDGE_PT: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.firstEdgePt)
class Qad_circle_maptool(QadGetPoint): def __init__(self, plugIn): QadGetPoint.__init__(self, plugIn) self.centerPt = None self.radius = None self.firstPt = None self.secondPt = None self.firstDiamPt = None self.tan1 = None self.tan2 = None self.startPtForRadius = None self.__rubberBand = QadRubberBand(self.canvas, False) self.geomType = QGis.Polygon def setRubberBandColor(self, rubberBandBorderColor, rubberBandFillColor): if rubberBandBorderColor is not None: self.__rubberBand.setBorderColor(rubberBandBorderColor) if rubberBandFillColor is not None: self.__rubberBand.setFillColor(rubberBandFillColor) def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) self.__rubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) self.__rubberBand.show() def clear(self): QadGetPoint.clear(self) self.__rubberBand.reset() self.mode = None def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) self.__rubberBand.reset() result = False circle = QadCircle() # noto il centro del cerchio si richiede il raggio if self.mode == Qad_circle_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_RADIUS: radius = qad_utils.getDistance(self.centerPt, self.tmpPoint) circle.set(self.centerPt, radius) result = True # noto il centro del cerchio si richiede il diametro elif self.mode == Qad_circle_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_DIAM: diam = qad_utils.getDistance(self.centerPt, self.tmpPoint) result = circle.set(self.centerPt, diam / 2) result = True # noto il primo e il secondo punto si richiede il terzo punto elif self.mode == Qad_circle_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_THIRD_PT: if (self.firstPt is not None) and (self.secondPt is not None): result = circle.from3Pts(self.firstPt, self.secondPt, self.tmpPoint) # noto il primo punto di estremità diam si richiede il secondo punto di estremità diam elif self.mode == Qad_circle_maptool_ModeEnum.FIRST_DIAM_PT_KNOWN_ASK_FOR_SECOND_DIAM_PT: if self.firstDiamPt is not None: result = circle.fromDiamEnds(self.firstDiamPt, self.tmpPoint) # noto note la prima, la seconda entita dei punti di tangenza e il primo punto per misurare il raggio # si richiede il secondo punto per misurare il raggio elif self.mode == Qad_circle_maptool_ModeEnum.FIRST_SECOND_TAN_FIRSTPTRADIUS_KNOWN_ASK_FOR_SECONDPTRADIUS: radius = qad_utils.getDistance(self.startPtForRadius, self.tmpPoint) result = circle.from2TanPtsRadius(self.tanGeom1, self.tanPt1, \ self.tanGeom2, self.tanPt2, radius) if result == True: points = circle.asPolyline() if points is not None: if self.geomType == QGis.Polygon: self.__rubberBand.setPolygon(points) else: self.__rubberBand.setLine(points) def activate(self): QadGetPoint.activate(self) self.__rubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) self.__rubberBand.hide() except: pass def setMode(self, mode): self.mode = mode # noto niente si richiede il centro if self.mode == Qad_circle_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_CENTER_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il centro del cerchio si richiede il raggio elif self.mode == Qad_circle_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_RADIUS: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.centerPt) # noto il centro del cerchio si richiede il diametro elif self.mode == Qad_circle_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_DIAM: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.centerPt) # noto niente si richiede il primo punto elif self.mode == Qad_circle_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il primo punto si richiede il secondo punto elif self.mode == Qad_circle_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il primo e il secondo punto si richiede il terzo punto elif self.mode == Qad_circle_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_THIRD_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto niente si richiede il primo punto di estremità diam elif self.mode == Qad_circle_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_DIAM_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto il primo punto di estremità diam si richiede il secondo punto di estremità diam elif self.mode == Qad_circle_maptool_ModeEnum.FIRST_DIAM_PT_KNOWN_ASK_FOR_SECOND_DIAM_PT: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # noto niente si richiede l'entita del primo punto di tangenza elif self.mode == Qad_circle_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_TAN: self.setDrawMode(QadGetPointDrawModeEnum.NONE) self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION) self.forceSnapTypeOnce(QadSnapTypeEnum.TAN_DEF) # nota l'entita del primo punto di tangenza si richiede quella del secondo punto di tangenza elif self.mode == Qad_circle_maptool_ModeEnum.FIRST_TAN_KNOWN_ASK_FOR_SECOND_TAN: self.setDrawMode(QadGetPointDrawModeEnum.NONE) self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION) self.forceSnapTypeOnce(QadSnapTypeEnum.TAN_DEF) # note la prima e la seconda entita dei punti di tangenza si richiede il raggio elif self.mode == Qad_circle_maptool_ModeEnum.FIRST_SECOND_TAN_KNOWN_ASK_FOR_RADIUS: self.setDrawMode(QadGetPointDrawModeEnum.NONE) # siccome il puntatore era stato variato in ENTITY_SELECTION dalla selez precedente self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION) # noto note la prima, la seconda entita dei punti di tangenza e il primo punto per misurare il raggio # si richiede il secondo punto per misurare il raggio elif self.mode == Qad_circle_maptool_ModeEnum.FIRST_SECOND_TAN_FIRSTPTRADIUS_KNOWN_ASK_FOR_SECONDPTRADIUS: self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.startPtForRadius)
class Qad_offset_maptool(QadGetPoint): def __init__(self, plugIn): QadGetPoint.__init__(self, plugIn) self.firstPt = None self.layer = None self.subGeom = None self.offSet = 0 self.lastOffSetOnLeftSide = 0 self.lastOffSetOnRightSide = 0 self.gapType = 0 self.__rubberBand = QadRubberBand(self.canvas) def hidePointMapToolMarkers(self): QadGetPoint.hidePointMapToolMarkers(self) self.__rubberBand.hide() def showPointMapToolMarkers(self): QadGetPoint.showPointMapToolMarkers(self) self.__rubberBand.show() def clear(self): QadGetPoint.clear(self) self.__rubberBand.reset() self.mode = None def addOffSetGeometries(self, newPt): self.__rubberBand.reset() transformedPt = self.plugIn.canvas.mapRenderer().mapToLayerCoordinates(self.layer, newPt) # ritorna una tupla (<The squared cartesian distance>, # <minDistPoint> # <afterVertex> # <leftOf>) dummy = qad_utils.closestSegmentWithContext(transformedPt, self.subGeom) if self.offSet < 0: afterVertex = dummy[2] pt = qad_utils.getPerpendicularPointOnInfinityLine(self.subGeom.vertexAt(afterVertex - 1), \ self.subGeom.vertexAt(afterVertex), \ transformedPt) offSetDistance = qad_utils.getDistance(transformedPt, pt) else: offSetDistance = qad_utils.distMapToLayerCoordinates(self.offSet, \ self.plugIn.canvas,\ self.layer) if dummy[3] < 0: # alla sinistra offSetDistance = offSetDistance + self.lastOffSetOnLeftSide else: # alla destra offSetDistance = offSetDistance + self.lastOffSetOnRightSide tolerance2ApproxCurve = qad_utils.distMapToLayerCoordinates(QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE")), \ self.plugIn.canvas,\ self.layer) epsg = self.layer.crs().authid() lines = qad_utils.offSetPolyline(self.subGeom.asPolyline(), epsg, \ offSetDistance, \ "left" if dummy[3] < 0 else "right", \ self.gapType, \ tolerance2ApproxCurve) for line in lines: if self.layer.geometryType() == QGis.Polygon: if line[0] == line[-1]: # se é una linea chiusa offsetGeom = QgsGeometry.fromPolygon([line]) else: offsetGeom = QgsGeometry.fromPolyline(line) else: offsetGeom = QgsGeometry.fromPolyline(line) self.__rubberBand.addGeometry(offsetGeom, self.layer) def canvasMoveEvent(self, event): QadGetPoint.canvasMoveEvent(self, event) # nota la distanza di offset si richiede il punto per stabilire da che parte if self.mode == Qad_offset_maptool_ModeEnum.OFFSET_KNOWN_ASK_FOR_SIDE_PT: self.addOffSetGeometries(self.tmpPoint) # si richiede il punto di passaggio per stabilire da che parte e a quale offset elif self.mode == Qad_offset_maptool_ModeEnum.ASK_FOR_PASSAGE_PT: self.addOffSetGeometries(self.tmpPoint) def activate(self): QadGetPoint.activate(self) self.__rubberBand.show() def deactivate(self): try: # necessario perché se si chiude QGIS parte questo evento nonostante non ci sia più l'oggetto maptool ! QadGetPoint.deactivate(self) self.__rubberBand.hide() except: pass def setMode(self, mode): self.clear() self.mode = mode # si richiede il primo punto per calcolo offset if self.mode == Qad_offset_maptool_ModeEnum.ASK_FOR_FIRST_OFFSET_PT: self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION) self.setDrawMode(QadGetPointDrawModeEnum.NONE) self.onlyEditableLayers = False # noto il primo punto per calcolo offset si richiede il secondo punto if self.mode == Qad_offset_maptool_ModeEnum.FIRST_OFFSET_PT_KNOWN_ASK_FOR_SECOND_PT: self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION) self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE) self.setStartPoint(self.firstPt) self.onlyEditableLayers = False # nota la distanza di offset si richiede il punto per stabilire da che parte elif self.mode == Qad_offset_maptool_ModeEnum.OFFSET_KNOWN_ASK_FOR_SIDE_PT: self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION) self.setDrawMode(QadGetPointDrawModeEnum.NONE) self.onlyEditableLayers = False # si richiede il punto di passaggio per stabilire da che parte e a quale offset elif self.mode == Qad_offset_maptool_ModeEnum.ASK_FOR_PASSAGE_PT: self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION) self.setDrawMode(QadGetPointDrawModeEnum.NONE) self.onlyEditableLayers = False # si richiede la selezione di un oggetto elif self.mode == Qad_offset_maptool_ModeEnum.ASK_FOR_ENTITY_SELECTION: self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION) # solo layer lineari o poligono editabili che non appartengano a quote layerList = [] for layer in self.plugIn.canvas.layers(): if layer.type() == QgsMapLayer.VectorLayer and \ (layer.geometryType() == QGis.Line or layer.geometryType() == QGis.Polygon) and \ layer.isEditable(): if len(self.plugIn.dimStyles.getDimListByLayer(layer)) == 0: layerList.append(layer) self.layersToCheck = layerList self.setDrawMode(QadGetPointDrawModeEnum.NONE) self.onlyEditableLayers = True