def RotateGeoms(self, angle):
# copio entitySet
entitySet = QadEntitySet(self.entitySet)
self.plugIn.beginEditCommand("Feature rotated", entitySet.getLayerList())
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
transformedBasePt = self.mapToLayerCoordinates(layer, self.basePt)
rotFldName = ""
if qad_layer.isTextLayer(layer):
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif qad_layer.isSymbolLayer(layer):
rotFldName = qad_layer.get_symbolRotationFieldName(layer)
while len(layerEntitySet.featureIds) > 0:
featureId = layerEntitySet.featureIds[0]
f = layerEntitySet.getFeature(featureId)
if self.rotate(f, transformedBasePt, angle, rotFldName, layerEntitySet, entitySet) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
def arrayPolarEntity(plugIn, ent, basePt, centerPt, itemsNumber, angleBetween, rows, distanceBetweenRows, itemsRotation, \
addToLayer, highlightObj):
"""
serie polare
ent = entità QAD di cui fare la serie (QadEntity o QadDimEntity)
basePt = punto base in map coordinate (QgsPoint)
centerPt = punto centrale in map coordinate (QgsPoint)
itemsNumber = numero di copie da fare
angleBetween = angolo tra un elemento e l'altro (radianti)
rows = numero di righe
distanceBetweenRows = distanza tra le righe in map coordinate
itemsRotation = True se si vuole ruotare gli elementi intorno al cerchio
addToLayer = se è True aggiunge le nuove entità al layer
highlightObj = se è diverso da None vengono aggiunge le geometrie all'oggetto QadHighlight
"""
g = None
coordTransform = None
f = None
if ent.whatIs() == "ENTITY":
f = ent.getFeature()
# trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
CRS = qgis.utils.iface.mapCanvas().mapSettings().destinationCrs() # CRS corrente
coordTransform = QgsCoordinateTransform(ent.crs(), CRS)
g = f.geometry()
g.transform(coordTransform)
coordTransform = QgsCoordinateTransform(CRS, ent.crs())
rotFldName = ""
if ent.getEntityType() == QadEntityGeomTypeEnum.TEXT:
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(ent.layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif ent.getEntityType() == QadEntityGeomTypeEnum.SYMBOL:
rotFldName = qad_layer.get_symbolRotationFieldName(ent.layer)
firstAngle = qad_utils.getAngleBy2Pts(centerPt, basePt)
dist = qad_utils.getDistance(centerPt, basePt)
for row in range(0, rows):
angle = firstAngle
for i in range(0, itemsNumber):
newBasePt = qad_utils.getPolarPointByPtAngle(centerPt, angle, dist)
offSetX = newBasePt.x() - basePt.x()
offSetY = newBasePt.y() - basePt.y()
if g is not None: # se l'entità non è una quotatura
if doMoveAndRotateGeom(plugIn, f, g, ent.layer, offSetX, offSetY, \
i * angleBetween if itemsRotation else None, rotFldName, \
newBasePt, coordTransform, addToLayer, highlightObj) == False:
return False
else: # se l'entità è una quotatura
if doMoveAndRotateDimEntity(plugIn, ent, offSetX, offSetY, \
i * angleBetween if itemsRotation else None, \
newBasePt, addToLayer, highlightObj) == False:
return False
angle = angle + angleBetween
dist = dist + distanceBetweenRows
return True
def rotate(self, basePt, angle):
# basePt = punto base espresso in map coordinate
# restituisce una feature ruotata
canvas = qad.mainWindow().mapCanvas()
destinationCrs = canvas.mapSettings().destinationCrs()
f = self.getFeature()
g = g.geometry()
g.transform(QgsCoordinateTransform(self.crs(), destinationCrs))
# ruoto la feature
g = qad_utils.rotateQgsGeometry(g, basePt, angle)
g.transform(QgsCoordinateTransform(destinationCrs, self.crs()))
f.setGeometry(g)
rotFldName = ""
if self.getEntityType() == QadEntityGeomTypeEnum.TEXT:
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(self.layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif self.getEntityType() == QadEntityGeomTypeEnum.SYMBOL:
rotFldName = qad_layer.get_symbolRotationFieldName(self.layer)
if len(rotFldName) > 0:
rotValue = f.attribute(rotFldName)
# a volte vale None e a volte null (vai a capire...)
rotValue = 0 if rotValue is None or isinstance(rotValue, QPyNullVariant) else qad_utils.toRadians(rotValue) # la rotazione é in gradi nel campo della feature
rotValue = rotValue + angle
f.setAttribute(rotFldName, qad_utils.toDegrees(qad_utils.normalizeAngle(rotValue)))
return f
def addFeature(self, layer):
transformedPoint = self.mapToLayerCoordinates(layer, self.insPt)
g = QgsGeometry.fromPoint(transformedPoint)
f = QgsFeature()
f.setGeometry(g)
# Add attribute fields to feature.
fields = layer.pendingFields()
f.setFields(fields)
# assegno i valori di default
provider = layer.dataProvider()
for field in fields.toList():
i = fields.indexFromName(field.name())
f[field.name()] = provider.defaultValue(i)
# se la scala dipende da un campo
scaleFldName = qad_layer.get_symbolScaleFieldName(layer)
if len(scaleFldName) > 0:
f.setAttribute(scaleFldName, self.scale)
# se la rotazione dipende da un campo
rotFldName = qad_layer.get_symbolRotationFieldName(layer)
if len(rotFldName) > 0:
f.setAttribute(rotFldName, qad_utils.toDegrees(self.rot))
return qad_layer.addFeatureToLayer(self.plugIn, layer, f)
def addFeature(self, layer, insPt, rot):
transformedPoint = self.mapToLayerCoordinates(layer, insPt)
g = QgsGeometry.fromPoint(transformedPoint)
f = QgsFeature()
f.setGeometry(g)
# Add attribute fields to feature.
fields = layer.pendingFields()
f.setFields(fields)
# assegno i valori di default
provider = layer.dataProvider()
for field in fields.toList():
i = fields.indexFromName(field.name())
f[field.name()] = provider.defaultValue(i)
# se la scala dipende da un campo
scaleFldName = qad_layer.get_symbolScaleFieldName(layer)
if len(scaleFldName) > 0:
f.setAttribute(scaleFldName, 1.0)
# se la rotazione dipende da un campo
rotFldName = qad_layer.get_symbolRotationFieldName(layer)
if len(rotFldName) > 0:
f.setAttribute(rotFldName, qad_utils.toDegrees(rot))
return qad_layer.addFeatureToLayer(self.plugIn, layer, f)
def rotate(self, basePt, angle):
# basePt = punto base espresso in map coordinate
# restituisce una feature ruotata
canvas = qgis.utils.iface.mapCanvas()
destinationCrs = canvas.mapSettings().destinationCrs()
f = self.getFeature()
g = g.geometry()
g.transform(QgsCoordinateTransform(self.crs(), destinationCrs))
# ruoto la feature
g = qad_utils.rotateQgsGeometry(g, basePt, angle)
g.transform(QgsCoordinateTransform(destinationCrs, self.crs()))
f.setGeometry(g)
rotFldName = ""
if self.getEntityType() == QadEntityGeomTypeEnum.TEXT:
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(self.layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif self.getEntityType() == QadEntityGeomTypeEnum.SYMBOL:
rotFldName = qad_layer.get_symbolRotationFieldName(self.layer)
if len(rotFldName) > 0:
rotValue = f.attribute(rotFldName)
# a volte vale None e a volte null (vai a capire...)
rotValue = 0 if rotValue is None or isinstance(rotValue, QPyNullVariant) else qad_utils.toRadians(rotValue) # la rotazione é in gradi nel campo della feature
rotValue = rotValue + angle
f.setAttribute(rotFldName, qad_utils.toDegrees(qad_utils.normalizeAngle(rotValue)))
return f
def RotateGeoms(self, angle):
# copio entitySet
entitySet = QadEntitySet(self.entitySet)
self.plugIn.beginEditCommand("Feature rotated",
entitySet.getLayerList())
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
transformedBasePt = self.mapToLayerCoordinates(layer, self.basePt)
rotFldName = ""
if qad_layer.isTextLayer(layer):
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif qad_layer.isSymbolLayer(layer):
rotFldName = qad_layer.get_symbolRotationFieldName(layer)
while len(layerEntitySet.featureIds) > 0:
featureId = layerEntitySet.featureIds[0]
f = layerEntitySet.getFeature(featureId)
if self.rotate(f, transformedBasePt, angle, rotFldName,
layerEntitySet, entitySet) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
def mirrorGeoms(self):
entity = QadEntity()
self.plugIn.beginEditCommand("Feature mirrored",
self.entitySet.getLayerList())
dimElaboratedList = [] # lista delle quotature già elaborate
for layerEntitySet in self.entitySet.layerEntitySetList:
layer = layerEntitySet.layer
transformedBasePt = self.mapToLayerCoordinates(layer, self.basePt)
transformedNewPt = self.mapToLayerCoordinates(
layer, self.secondMirrorPt)
rotFldName = ""
if qad_layer.isTextLayer(layer):
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif qad_layer.isSymbolLayer(layer):
rotFldName = qad_layer.get_symbolRotationFieldName(layer)
for featureId in layerEntitySet.featureIds:
entity.set(layer, featureId)
# verifico se l'entità appartiene ad uno stile di quotatura
dimEntity = QadDimStyles.getDimEntity(entity)
if dimEntity is None:
if self.mirror(entity, transformedBasePt, transformedNewPt,
rotFldName) == False:
self.plugIn.destroyEditCommand()
return
else:
found = False
for dimElaborated in dimElaboratedList:
if dimElaborated == dimEntity:
found = True
if found == False: # quota non ancora elaborata
dimElaboratedList.append(dimEntity)
if self.mirror(dimEntity, transformedBasePt,
transformedNewPt, rotFldName) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
self.nOperationsToUndo = self.nOperationsToUndo + 1
def mirrorGeoms(self):
# copio entitySet
entitySet = QadEntitySet(self.entitySet)
self.plugIn.beginEditCommand("Feature mirrored",
self.entitySet.getLayerList())
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
transformedBasePt = self.mapToLayerCoordinates(
layer, self.firstMirrorPt)
transformedNewPt = self.mapToLayerCoordinates(
layer, self.secondMirrorPt)
rotFldName = ""
if qad_layer.isTextLayer(layer):
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif qad_layer.isSymbolLayer(layer):
rotFldName = qad_layer.get_symbolRotationFieldName(layer)
while len(layerEntitySet.featureIds) > 0:
featureId = layerEntitySet.featureIds[0]
f = layerEntitySet.getFeature(featureId)
entity = QadEntity()
entity.set(layer, featureId)
# verifico se l'entità appartiene ad uno stile di quotatura
dimStyle, dimId = QadDimStyles.getDimIdByEntity(entity)
if dimStyle is not None:
dimEntity = QadDimEntity()
if dimEntity.initByDimId(dimStyle, dimId) == False:
dimEntity = None
else:
dimEntity = None
if self.mirror(f, transformedBasePt, transformedNewPt,
rotFldName, layerEntitySet, entitySet,
dimEntity) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
def mirrorGeoms(self):
entity = QadEntity()
self.plugIn.beginEditCommand("Feature mirrored", self.entitySet.getLayerList())
dimElaboratedList = [] # lista delle quotature già elaborate
for layerEntitySet in self.entitySet.layerEntitySetList:
layer = layerEntitySet.layer
transformedBasePt = self.mapToLayerCoordinates(layer, self.basePt)
transformedNewPt = self.mapToLayerCoordinates(layer, self.secondMirrorPt)
rotFldName = ""
if qad_layer.isTextLayer(layer):
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif qad_layer.isSymbolLayer(layer):
rotFldName = qad_layer.get_symbolRotationFieldName(layer)
for featureId in layerEntitySet.featureIds:
entity.set(layer, featureId)
# verifico se l'entità appartiene ad uno stile di quotatura
dimEntity = QadDimStyles.getDimEntity(entity)
if dimEntity is None:
if self.mirror(entity, transformedBasePt, transformedNewPt, rotFldName) == False:
self.plugIn.destroyEditCommand()
return
else:
found = False
for dimElaborated in dimElaboratedList:
if dimElaborated == dimEntity:
found = True
if found == False: # quota non ancora elaborata
dimElaboratedList.append(dimEntity)
if self.mirror(dimEntity, transformedBasePt, transformedNewPt, rotFldName) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
self.nOperationsToUndo = self.nOperationsToUndo + 1
def mirrorGeoms(self):
# copio entitySet
entitySet = QadEntitySet(self.entitySet)
self.plugIn.beginEditCommand("Feature mirrored", self.entitySet.getLayerList())
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
transformedBasePt = self.mapToLayerCoordinates(layer, self.firstMirrorPt)
transformedNewPt = self.mapToLayerCoordinates(layer, self.secondMirrorPt)
rotFldName = ""
if qad_layer.isTextLayer(layer):
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif qad_layer.isSymbolLayer(layer):
rotFldName = qad_layer.get_symbolRotationFieldName(layer)
while len(layerEntitySet.featureIds) > 0:
featureId = layerEntitySet.featureIds[0]
f = layerEntitySet.getFeature(featureId)
entity = QadEntity()
entity.set(layer, featureId)
# verifico se l'entità appartiene ad uno stile di quotatura
dimStyle, dimId = QadDimStyles.getDimIdByEntity(entity)
if dimStyle is not None:
dimEntity = QadDimEntity()
if dimEntity.initByDimId(dimStyle, dimId) == False:
dimEntity = None
else:
dimEntity = None
if self.mirror(f, transformedBasePt, transformedNewPt, rotFldName, layerEntitySet, entitySet, dimEntity) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
def run(self, msgMapTool=False, msg=None):
if self.plugIn.canvas.mapSettings().destinationCrs().geographicFlag():
self.showMsg(
QadMsg.translate(
"QAD", "\nThe coordinate reference system of the project must be a projected coordinate system.\n"
)
)
return True # fine comando
currLayer, errMsg = qad_layer.getCurrLayerEditable(self.plugIn.canvas, QGis.Point)
if currLayer is None:
self.showErr(errMsg)
return True # fine comando
if qad_layer.isSymbolLayer(currLayer) == False:
errMsg = QadMsg.translate("QAD", "\nCurrent layer is not a symbol layer.")
errMsg = errMsg + QadMsg.translate("QAD", "\nA symbol layer is a vector punctual layer without label.\n")
self.showErr(errMsg)
return True # fine comando
if len(QadDimStyles.getDimListByLayer(currLayer)) > 0:
errMsg = QadMsg.translate("QAD", "\nThe current layer belongs to a dimension style.\n")
self.showErr(errMsg)
return True # fine comando
if self.step == 0:
self.waitForEntsel(msgMapTool, msg)
return False # continua
# =========================================================================
# RISPOSTA ALLA SELEZIONE DI UN'ENTITA' (da step = 0)
elif self.step == QadDIVIDECommandClassStepEnum.ASK_FOR_ENT:
if self.entSelClass.run(msgMapTool, msg) == True:
if self.entSelClass.entity.isInitialized():
# se il layer di destinazione è di tipo simbolo
if qad_layer.isSymbolLayer(currLayer) == True:
# se il simbolo può essere ruotato
if len(qad_layer.get_symbolRotationFieldName(currLayer)) > 0:
self.waitForAlignmentObjs()
else:
self.waitForSegmentNumber()
return False
else:
if self.entSelClass.canceledByUsr == True: # fine comando
return True
self.showMsg(QadMsg.translate("QAD", "No geometries in this position."))
self.waitForEntsel(msgMapTool, msg)
return False # continua
# =========================================================================
# RISPOSTA ALLA RICHIESTA DI ALLINEARE GLI OGGETTI (da step = ASK_FOR_ENT)
elif (
self.step == QadDIVIDECommandClassStepEnum.ASK_FOR_ALIGNMENT
): # dopo aver atteso una parola chiave si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
value = self.defaultValue
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
else:
# la parola chiave arriva come parametro della funzione
value = msg
if type(value) == unicode:
if value == QadMsg.translate("QAD", "Yes") or value == "Yes":
self.objectAlignment = True
else:
self.objectAlignment = False
self.waitForSegmentNumber()
return False
# =========================================================================
# RISPOSTA ALLA RICHIESTA DEL NUMERO DI SEGMENTI (da step = ASK_FOR_ALIGNMENT)
# =========================================================================
elif (
self.step == QadDIVIDECommandClassStepEnum.ASK_SEGMENT_NUMBER
): # dopo aver atteso un numero intero si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return False
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
else:
# il numero di segmenti arriva come parametro della funzione
self.nSegments = msg
self.doDivide(currLayer)
return True # fine comando
return False
def arrayPathEntity(plugIn, ent, basePt, rows, cols, distanceBetweenRows, distanceBetweenCols, tangentDirection, itemsRotation, \
pathLinearObjectList, distanceFromStartPt, addToLayer, highlightObj):
"""
serie traiettoria
ent = entità QAD di cui fare la serie (QadEntity o QadDimEntity)
basePt = punto base in map coordinate (QgsPoint)
rows = numero di righe
cols = numero di colonne
distanceBetweenRows = distanza tra le righe in map coordinate
distanceBetweenCols = distanza tra le colonne in map coordinate
tangentDirection = specifica il modo in cui gli elementi disposti in serie sono allineati rispetto alla direzione iniziale della traiettoria
itemsRotation = True se si vuole ruotare gli elementi come l'angolo della serie
pathLinearObjectList = traiettoria da seguire (QadLinearObjectList) in map coordinate
distanceFromStartPt = distanza dal punto iniziale della traccia
addToLayer = se è True aggiunge le nuove entità al layer
highlightObj = se è diverso da None vengono aggiunge le geometrie all'oggetto QadHighlight
la funzione restituisce True in caso di successo e Falso in caso di errore
"""
g = None
coordTransform = None
f = None
if ent.whatIs() == "ENTITY":
f = ent.getFeature()
# trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
CRS = qgis.utils.iface.mapCanvas().mapSettings().destinationCrs() # CRS corrente
coordTransform = QgsCoordinateTransform(ent.crs(), CRS)
g = f.geometry()
g.transform(coordTransform)
coordTransform = QgsCoordinateTransform(CRS, ent.crs())
rotFldName = ""
if ent.getEntityType() == QadEntityGeomTypeEnum.TEXT:
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(ent.layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif ent.getEntityType() == QadEntityGeomTypeEnum.SYMBOL:
rotFldName = qad_layer.get_symbolRotationFieldName(ent.layer)
firstBasePt = basePt
firstTanDirection = pathLinearObjectList.getTanDirectionOnStartPt()
for col in range(0, cols):
distX = (distanceBetweenCols * col) + distanceFromStartPt
firstBasePt, angle = pathLinearObjectList.getPointFromStart(distX) # ritorna il punto e la direzione della tang in quel punto
if firstBasePt is not None:
for row in range(0, rows):
newBasePt = qad_utils.getPolarPointByPtAngle(firstBasePt, angle + math.pi/2, distanceBetweenRows * row)
offSetX = newBasePt.x() - basePt.x()
offSetY = newBasePt.y() - basePt.y()
if g is not None: # se l'entità non è una quotatura
if doMoveAndRotateGeom(plugIn, f, g, ent.layer, offSetX, offSetY, \
angle - tangentDirection if itemsRotation else -tangentDirection, rotFldName, \
newBasePt, coordTransform, addToLayer, highlightObj) == False:
return False
else: # se l'entità è una quotatura
if doMoveAndRotateDimEntity(plugIn, ent, offSetX, offSetY, \
angle - tangentDirection if itemsRotation else -tangentDirection, \
newBasePt, addToLayer, highlightObj) == False:
return False
distX = distX + distanceBetweenCols
return True
def arrayRectangleEntity(plugIn, ent, basePt, rows, cols, distanceBetweenRows, distanceBetweenCols, angle, itemsRotation,
addToLayer, highlightObj):
"""
serie rettangolare
ent = entità QAD di cui fare la serie (QadEntity o QadDimEntity)
basePt = punto base in map coordinate (QgsPoint)
rows = numero di righe
cols = numero di colonne
distanceBetweenRows = distanza tra le righe in map coordinate
distanceBetweenCols = distanza tra le colonne in map coordinate
angle = angolo della serie (radianti)
itemsRotation = True se si vuole ruotare gli elementi come l'angolo della serie
addToLayer = se è True aggiunge le nuove entità al layer
highlightObj = se è diverso da None vengono aggiunge le geometrie all'oggetto QadHighlight
la funzione restituisce True in caso di successo e Falso in caso di errore
"""
g = None
coordTransform = None
f = None
if ent.whatIs() == "ENTITY":
f = ent.getFeature()
# trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
CRS = qgis.utils.iface.mapCanvas().mapSettings().destinationCrs() # CRS corrente
coordTransform = QgsCoordinateTransform(ent.crs(), CRS)
g = f.geometry()
g.transform(coordTransform)
coordTransform = QgsCoordinateTransform(CRS, ent.crs())
rotFldName = ""
if ent.getEntityType() == QadEntityGeomTypeEnum.TEXT:
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(ent.layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif ent.getEntityType() == QadEntityGeomTypeEnum.SYMBOL:
rotFldName = qad_layer.get_symbolRotationFieldName(ent.layer)
for row in range(0, rows):
firstBasePt = qad_utils.getPolarPointByPtAngle(basePt, angle + math.pi / 2, distanceBetweenRows * row)
distX = 0
for col in range(0, cols):
newBasePt = qad_utils.getPolarPointByPtAngle(firstBasePt, angle, distanceBetweenCols * col)
offSetX = newBasePt.x() - basePt.x()
offSetY = newBasePt.y() - basePt.y()
if g is not None: # se l'entità non è una quotatura
if doMoveAndRotateGeom(plugIn, f, g, ent.layer, offSetX, offSetY, \
angle if itemsRotation else None, rotFldName, \
newBasePt, coordTransform, addToLayer, highlightObj) == False:
return False
else: # se l'entità è una quotatura
if doMoveAndRotateDimEntity(plugIn, ent, offSetX, offSetY, \
angle if itemsRotation else None, \
newBasePt, addToLayer, highlightObj) == False:
return False
distX = distX + distanceBetweenCols
return True
def run(self, msgMapTool=False, msg=None):
if self.plugIn.canvas.mapSettings().destinationCrs().geographicFlag():
self.showMsg(
QadMsg.translate(
"QAD",
"\nThe coordinate reference system of the project must be a projected coordinate system.\n"
))
return True # fine comando
currLayer, errMsg = qad_layer.getCurrLayerEditable(
self.plugIn.canvas, QGis.Point)
if currLayer is None:
self.showErr(errMsg)
return True # fine comando
if qad_layer.isSymbolLayer(currLayer) == False:
errMsg = QadMsg.translate(
"QAD", "\nCurrent layer is not a symbol layer.")
errMsg = errMsg + QadMsg.translate(
"QAD",
"\nA symbol layer is a vector punctual layer without label.\n")
self.showErr(errMsg)
return True # fine comando
if len(QadDimStyles.getDimListByLayer(currLayer)) > 0:
errMsg = QadMsg.translate(
"QAD", "\nThe current layer belongs to a dimension style.\n")
self.showErr(errMsg)
return True # fine comando
if self.step == 0:
self.waitForEntsel(msgMapTool, msg)
return False # continua
#=========================================================================
# RISPOSTA ALLA SELEZIONE DI UN'ENTITA' (da step = 0)
elif self.step == QadDIVIDECommandClassStepEnum.ASK_FOR_ENT:
if self.entSelClass.run(msgMapTool, msg) == True:
if self.entSelClass.entity.isInitialized():
# se il layer di destinazione è di tipo simbolo
if qad_layer.isSymbolLayer(currLayer) == True:
# se il simbolo può essere ruotato
if len(qad_layer.get_symbolRotationFieldName(
currLayer)) > 0:
self.waitForAlignmentObjs()
else:
self.waitForSegmentNumber()
return False
else:
if self.entSelClass.canceledByUsr == True: # fine comando
return True
self.showMsg(
QadMsg.translate("QAD",
"No geometries in this position."))
self.waitForEntsel(msgMapTool, msg)
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DI ALLINEARE GLI OGGETTI (da step = ASK_FOR_ENT)
elif self.step == QadDIVIDECommandClassStepEnum.ASK_FOR_ALIGNMENT: # dopo aver atteso una parola chiave si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
if self.getPointMapTool(
).rightButton == True: # se usato il tasto destro del mouse
value = self.defaultValue
else:
self.setMapTool(
self.getPointMapTool()) # riattivo il maptool
return False
else:
# la parola chiave arriva come parametro della funzione
value = msg
if type(value) == unicode:
if value == QadMsg.translate("QAD", "Yes") or value == "Yes":
self.objectAlignment = True
else:
self.objectAlignment = False
self.waitForSegmentNumber()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL NUMERO DI SEGMENTI (da step = ASK_FOR_ALIGNMENT)
#=========================================================================
elif self.step == QadDIVIDECommandClassStepEnum.ASK_SEGMENT_NUMBER: # dopo aver atteso un numero intero si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
if self.getPointMapTool(
).rightButton == True: # se usato il tasto destro del mouse
return False
else:
self.setMapTool(
self.getPointMapTool()) # riattivo il maptool
return False
else:
# il numero di segmenti arriva come parametro della funzione
self.nSegments = msg
self.doDivide(currLayer)
return True # fine comando
return False
def run(self, msgMapTool = False, msg = None):
if self.plugIn.canvas.mapRenderer().destinationCrs().geographicFlag():
self.showMsg(QadMsg.translate("QAD", "\nIl sistema di riferimento del progetto deve essere un sistema di coordinate proiettate.\n"))
return True # fine comando
currLayer, errMsg = qad_layer.getCurrLayerEditable(self.plugIn.canvas, QGis.Point)
if currLayer is None:
self.showErr(errMsg)
return True # fine comando
if qad_layer.isSymbolLayer(currLayer) == False:
errMsg = QadMsg.translate("QAD", "\nIl layer corrente non é di tipo simbolo.")
errMsg = errMsg + QadMsg.translate("QAD", "\nUn layer simbolo é un layer vettoriale di tipo punto senza etichetta.\n")
self.showErr(errMsg)
return True # fine comando
#=========================================================================
# RICHIESTA PUNTO DI INSERIMENTO
if self.step == 0: # inizio del comando
self.waitForPoint() # si appresta ad attendere un punto
self.step = self.step + 1
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO DI INSERIMENTO
elif self.step == 1: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
pt = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
pt = msg
self.insPt = QgsPoint(pt)
self.plugIn.setLastPoint(self.insPt)
# se la scala dipende da un campo
scaleFldName = qad_layer.get_symbolScaleFieldName(currLayer)
if len(scaleFldName) > 0:
# si appresta ad attendere la scala
self.GetDistClass = QadGetDistClass(self.plugIn)
prompt = QadMsg.translate("Command_INSERT", "Specificare la scala del simbolo <{0}>: ")
self.GetDistClass.msg = prompt.format(str(self.scale))
self.GetDistClass.dist = self.scale
self.GetDistClass.inputMode = QadInputModeEnum.NOT_NEGATIVE | QadInputModeEnum.NOT_ZERO
self.GetDistClass.startPt = self.insPt
self.step = 2
self.GetDistClass.run(msgMapTool, msg)
return False
else:
# se la rotazione dipende da un campo
rotFldName = qad_layer.get_symbolRotationFieldName(currLayer)
if len(rotFldName) > 0:
if self.GetAngleClass is not None:
del self.GetAngleClass
# si appresta ad attendere l'angolo di rotazione
self.GetAngleClass = QadGetAngleClass(self.plugIn)
prompt = QadMsg.translate("Command_INSERT", "Specificare la rotazione del simbolo <{0}>: ")
self.GetAngleClass.msg = prompt.format(str(qad_utils.toDegrees(self.rot)))
self.GetAngleClass.angle = self.rot
self.GetAngleClass.startPt = self.insPt
self.step = 3
self.GetAngleClass.run(msgMapTool, msg)
return False
else:
self.addFeature(currLayer)
return True
#=========================================================================
# RISPOSTA ALLA RICHIESTA SCALA (da step = 1)
elif self.step == 2:
if self.GetDistClass.run(msgMapTool, msg) == True:
if self.GetDistClass.dist is not None:
self.scale = self.GetDistClass.dist
self.plugIn.setLastScale(self.scale)
del self.GetDistClass
self.GetDistClass = None
# se la rotazione dipende da un campo
rotFldName = qad_layer.get_symbolRotationFieldName(currLayer)
if len(rotFldName) > 0:
if self.GetAngleClass is not None:
del self.GetAngleClass
# si appresta ad attendere l'angolo di rotazione
self.GetAngleClass = QadGetAngleClass(self.plugIn)
prompt = QadMsg.translate("Command_INSERT", "Specificare la rotazione del simbolo <{0}>: ")
self.GetAngleClass.msg = prompt.format(str(qad_utils.toDegrees(self.rot)))
self.GetAngleClass.angle = self.rot
self.GetAngleClass.startPt = self.insPt
self.step = 3
self.GetAngleClass.run(msgMapTool, msg)
return False
else:
self.addFeature(currLayer)
return True
else:
return True
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA ROTAZIONE (da step = 1 o 2)
elif self.step == 3:
if self.GetAngleClass.run(msgMapTool, msg) == True:
if self.GetAngleClass.angle is not None:
self.rot = self.GetAngleClass.angle
self.plugIn.setLastRot(self.rot)
self.addFeature(currLayer)
return True # fine comando
else:
return True
return False
def arrayPolarEntity(plugIn, ent, basePt, centerPt, itemsNumber, angleBetween, rows, distanceBetweenRows, itemsRotation, \
addToLayer, highlightObj):
"""
serie polare
ent = entità QAD di cui fare la serie (QadEntity o QadDimEntity)
basePt = punto base in map coordinate (QgsPoint)
centerPt = punto centrale in map coordinate (QgsPoint)
itemsNumber = numero di copie da fare
angleBetween = angolo tra un elemento e l'altro (radianti)
rows = numero di righe
distanceBetweenRows = distanza tra le righe in map coordinate
itemsRotation = True se si vuole ruotare gli elementi intorno al cerchio
addToLayer = se è True aggiunge le nuove entità al layer
highlightObj = se è diverso da None vengono aggiunge le geometrie all'oggetto QadHighlight
"""
g = None
coordTransform = None
f = None
if ent.whatIs() == "ENTITY":
f = ent.getFeature()
# trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
CRS = qgis.utils.iface.mapCanvas().mapSettings().destinationCrs(
) # CRS corrente
coordTransform = QgsCoordinateTransform(ent.crs(), CRS)
g = f.geometry()
g.transform(coordTransform)
coordTransform = QgsCoordinateTransform(CRS, ent.crs())
rotFldName = ""
if ent.getEntityType() == QadEntityGeomTypeEnum.TEXT:
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(ent.layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif ent.getEntityType() == QadEntityGeomTypeEnum.SYMBOL:
rotFldName = qad_layer.get_symbolRotationFieldName(ent.layer)
firstAngle = qad_utils.getAngleBy2Pts(centerPt, basePt)
dist = qad_utils.getDistance(centerPt, basePt)
for row in range(0, rows):
angle = firstAngle
for i in range(0, itemsNumber):
newBasePt = qad_utils.getPolarPointByPtAngle(centerPt, angle, dist)
offSetX = newBasePt.x() - basePt.x()
offSetY = newBasePt.y() - basePt.y()
if g is not None: # se l'entità non è una quotatura
if doMoveAndRotateGeom(plugIn, f, g, ent.layer, offSetX, offSetY, \
i * angleBetween if itemsRotation else None, rotFldName, \
newBasePt, coordTransform, addToLayer, highlightObj) == False:
return False
else: # se l'entità è una quotatura
if doMoveAndRotateDimEntity(plugIn, ent, offSetX, offSetY, \
i * angleBetween if itemsRotation else None, \
newBasePt, addToLayer, highlightObj) == False:
return False
angle = angle + angleBetween
dist = dist + distanceBetweenRows
return True
def arrayPathEntity(plugIn, ent, basePt, rows, cols, distanceBetweenRows, distanceBetweenCols, tangentDirection, itemsRotation, \
pathLinearObjectList, distanceFromStartPt, addToLayer, highlightObj):
"""
serie traiettoria
ent = entità QAD di cui fare la serie (QadEntity o QadDimEntity)
basePt = punto base in map coordinate (QgsPoint)
rows = numero di righe
cols = numero di colonne
distanceBetweenRows = distanza tra le righe in map coordinate
distanceBetweenCols = distanza tra le colonne in map coordinate
tangentDirection = specifica il modo in cui gli elementi disposti in serie sono allineati rispetto alla direzione iniziale della traiettoria
itemsRotation = True se si vuole ruotare gli elementi come l'angolo della serie
pathLinearObjectList = traiettoria da seguire (QadLinearObjectList) in map coordinate
distanceFromStartPt = distanza dal punto iniziale della traccia
addToLayer = se è True aggiunge le nuove entità al layer
highlightObj = se è diverso da None vengono aggiunge le geometrie all'oggetto QadHighlight
la funzione restituisce True in caso di successo e Falso in caso di errore
"""
g = None
coordTransform = None
f = None
if ent.whatIs() == "ENTITY":
f = ent.getFeature()
# trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
CRS = qgis.utils.iface.mapCanvas().mapSettings().destinationCrs(
) # CRS corrente
coordTransform = QgsCoordinateTransform(ent.crs(), CRS)
g = f.geometry()
g.transform(coordTransform)
coordTransform = QgsCoordinateTransform(CRS, ent.crs())
rotFldName = ""
if ent.getEntityType() == QadEntityGeomTypeEnum.TEXT:
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(ent.layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif ent.getEntityType() == QadEntityGeomTypeEnum.SYMBOL:
rotFldName = qad_layer.get_symbolRotationFieldName(ent.layer)
firstBasePt = basePt
firstTanDirection = pathLinearObjectList.getTanDirectionOnStartPt()
for col in range(0, cols):
distX = (distanceBetweenCols * col) + distanceFromStartPt
firstBasePt, angle = pathLinearObjectList.getPointFromStart(
distX) # ritorna il punto e la direzione della tang in quel punto
if firstBasePt is not None:
for row in range(0, rows):
newBasePt = qad_utils.getPolarPointByPtAngle(
firstBasePt, angle + math.pi / 2,
distanceBetweenRows * row)
offSetX = newBasePt.x() - basePt.x()
offSetY = newBasePt.y() - basePt.y()
if g is not None: # se l'entità non è una quotatura
if doMoveAndRotateGeom(plugIn, f, g, ent.layer, offSetX, offSetY, \
angle - tangentDirection if itemsRotation else -tangentDirection, rotFldName, \
newBasePt, coordTransform, addToLayer, highlightObj) == False:
return False
else: # se l'entità è una quotatura
if doMoveAndRotateDimEntity(plugIn, ent, offSetX, offSetY, \
angle - tangentDirection if itemsRotation else -tangentDirection, \
newBasePt, addToLayer, highlightObj) == False:
return False
distX = distX + distanceBetweenCols
return True
def arrayRectangleEntity(plugIn, ent, basePt, rows, cols, distanceBetweenRows,
distanceBetweenCols, angle, itemsRotation, addToLayer,
highlightObj):
"""
serie rettangolare
ent = entità QAD di cui fare la serie (QadEntity o QadDimEntity)
basePt = punto base in map coordinate (QgsPoint)
rows = numero di righe
cols = numero di colonne
distanceBetweenRows = distanza tra le righe in map coordinate
distanceBetweenCols = distanza tra le colonne in map coordinate
angle = angolo della serie (radianti)
itemsRotation = True se si vuole ruotare gli elementi come l'angolo della serie
addToLayer = se è True aggiunge le nuove entità al layer
highlightObj = se è diverso da None vengono aggiunge le geometrie all'oggetto QadHighlight
la funzione restituisce True in caso di successo e Falso in caso di errore
"""
g = None
coordTransform = None
f = None
if ent.whatIs() == "ENTITY":
f = ent.getFeature()
# trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
CRS = qgis.utils.iface.mapCanvas().mapSettings().destinationCrs(
) # CRS corrente
coordTransform = QgsCoordinateTransform(ent.crs(), CRS)
g = f.geometry()
g.transform(coordTransform)
coordTransform = QgsCoordinateTransform(CRS, ent.crs())
rotFldName = ""
if ent.getEntityType() == QadEntityGeomTypeEnum.TEXT:
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(ent.layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif ent.getEntityType() == QadEntityGeomTypeEnum.SYMBOL:
rotFldName = qad_layer.get_symbolRotationFieldName(ent.layer)
for row in range(0, rows):
firstBasePt = qad_utils.getPolarPointByPtAngle(
basePt, angle + math.pi / 2, distanceBetweenRows * row)
distX = 0
for col in range(0, cols):
newBasePt = qad_utils.getPolarPointByPtAngle(
firstBasePt, angle, distanceBetweenCols * col)
offSetX = newBasePt.x() - basePt.x()
offSetY = newBasePt.y() - basePt.y()
if g is not None: # se l'entità non è una quotatura
if doMoveAndRotateGeom(plugIn, f, g, ent.layer, offSetX, offSetY, \
angle if itemsRotation else None, rotFldName, \
newBasePt, coordTransform, addToLayer, highlightObj) == False:
return False
else: # se l'entità è una quotatura
if doMoveAndRotateDimEntity(plugIn, ent, offSetX, offSetY, \
angle if itemsRotation else None, \
newBasePt, addToLayer, highlightObj) == False:
return False
distX = distX + distanceBetweenCols
return True
def run(self, msgMapTool=False, msg=None):
if self.plugIn.canvas.mapSettings().destinationCrs().geographicFlag():
self.showMsg(
QadMsg.translate(
"QAD",
"\nThe coordinate reference system of the project must be a projected coordinate system.\n"
))
return True # fine comando
currLayer, errMsg = qad_layer.getCurrLayerEditable(
self.plugIn.canvas, QGis.Point)
if currLayer is None:
self.showErr(errMsg)
return True # fine comando
if qad_layer.isSymbolLayer(currLayer) == False:
errMsg = QadMsg.translate(
"QAD", "\nCurrent layer is not a symbol layer.")
errMsg = errMsg + QadMsg.translate(
"QAD",
"\nA symbol layer is a vector punctual layer without label.\n")
self.showErr(errMsg)
return True # fine comando
#=========================================================================
# RICHIESTA PUNTO DI INSERIMENTO
if self.step == 0: # inizio del comando
self.waitForPoint() # si appresta ad attendere un punto
self.step = self.step + 1
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO DI INSERIMENTO
elif self.step == 1: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool(
).point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool(
).rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(
self.getPointMapTool()) # riattivo il maptool
return False
pt = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
pt = msg
self.insPt = QgsPoint(pt)
self.plugIn.setLastPoint(self.insPt)
# se la scala dipende da un campo
scaleFldName = qad_layer.get_symbolScaleFieldName(currLayer)
if len(scaleFldName) > 0:
# si appresta ad attendere la scala
self.GetDistClass = QadGetDistClass(self.plugIn)
prompt = QadMsg.translate("Command_INSERT",
"Specify the symbol scale <{0}>: ")
self.GetDistClass.msg = prompt.format(str(self.scale))
self.GetDistClass.dist = self.scale
self.GetDistClass.inputMode = QadInputModeEnum.NOT_NEGATIVE | QadInputModeEnum.NOT_ZERO
self.GetDistClass.startPt = self.insPt
self.step = 2
self.GetDistClass.run(msgMapTool, msg)
return False
else:
# se la rotazione dipende da un campo
rotFldName = qad_layer.get_symbolRotationFieldName(currLayer)
if len(rotFldName) > 0:
if self.GetAngleClass is not None:
del self.GetAngleClass
# si appresta ad attendere l'angolo di rotazione
self.GetAngleClass = QadGetAngleClass(self.plugIn)
prompt = QadMsg.translate(
"Command_INSERT",
"Specify the symbol rotation <{0}>: ")
self.GetAngleClass.msg = prompt.format(
str(qad_utils.toDegrees(self.rot)))
self.GetAngleClass.angle = self.rot
self.GetAngleClass.startPt = self.insPt
self.step = 3
self.GetAngleClass.run(msgMapTool, msg)
return False
else:
self.addFeature(currLayer)
return True
#=========================================================================
# RISPOSTA ALLA RICHIESTA SCALA (da step = 1)
elif self.step == 2:
if self.GetDistClass.run(msgMapTool, msg) == True:
if self.GetDistClass.dist is not None:
self.scale = self.GetDistClass.dist
self.plugIn.setLastScale(self.scale)
del self.GetDistClass
self.GetDistClass = None
# se la rotazione dipende da un campo
rotFldName = qad_layer.get_symbolRotationFieldName(
currLayer)
if len(rotFldName) > 0:
if self.GetAngleClass is not None:
del self.GetAngleClass
# si appresta ad attendere l'angolo di rotazione
self.GetAngleClass = QadGetAngleClass(self.plugIn)
prompt = QadMsg.translate(
"Command_INSERT",
"Specify the symbol rotation <{0}>: ")
self.GetAngleClass.msg = prompt.format(
str(qad_utils.toDegrees(self.rot)))
self.GetAngleClass.angle = self.rot
self.GetAngleClass.startPt = self.insPt
self.step = 3
self.GetAngleClass.run(msgMapTool, msg)
return False
else:
self.addFeature(currLayer)
return True
else:
return True
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA ROTAZIONE (da step = 1 o 2)
elif self.step == 3:
if self.GetAngleClass.run(msgMapTool, msg) == True:
if self.GetAngleClass.angle is not None:
self.rot = self.GetAngleClass.angle
self.plugIn.setLastRot(self.rot)
self.addFeature(currLayer)
return True # fine comando
else:
return True
return False
