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_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_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