本文整理汇总了Python中qad_rubberband.QadRubberBand.hide方法的典型用法代码示例。如果您正苦于以下问题:Python QadRubberBand.hide方法的具体用法?Python QadRubberBand.hide怎么用?Python QadRubberBand.hide使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类qad_rubberband.QadRubberBand
的用法示例。
在下文中一共展示了QadRubberBand.hide方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: Qad_circle_maptool
# 需要导入模块: from qad_rubberband import QadRubberBand [as 别名]
# 或者: from qad_rubberband.QadRubberBand import hide [as 别名]
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)
#.........这里部分代码省略.........
示例2: Qad_lengthen_maptool
# 需要导入模块: from qad_rubberband import QadRubberBand [as 别名]
# 或者: from qad_rubberband.QadRubberBand import hide [as 别名]
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)
#.........这里部分代码省略.........
示例3: Qad_fillet_maptool
# 需要导入模块: from qad_rubberband import QadRubberBand [as 别名]
# 或者: from qad_rubberband.QadRubberBand import hide [as 别名]
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:
#.........这里部分代码省略.........
示例4: Qad_mbuffer_maptool
# 需要导入模块: from qad_rubberband import QadRubberBand [as 别名]
# 或者: from qad_rubberband.QadRubberBand import hide [as 别名]
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)
示例5: Qad_rectangle_maptool
# 需要导入模块: from qad_rubberband import QadRubberBand [as 别名]
# 或者: from qad_rubberband.QadRubberBand import hide [as 别名]
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)
示例6: Qad_stretch_maptool
# 需要导入模块: from qad_rubberband import QadRubberBand [as 别名]
# 或者: from qad_rubberband.QadRubberBand import hide [as 别名]
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()
#.........这里部分代码省略.........
示例7: Qad_pedit_maptool
# 需要导入模块: from qad_rubberband import QadRubberBand [as 别名]
# 或者: from qad_rubberband.QadRubberBand import hide [as 别名]
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
#.........这里部分代码省略.........
示例8: Qad_polygon_maptool
# 需要导入模块: from qad_rubberband import QadRubberBand [as 别名]
# 或者: from qad_rubberband.QadRubberBand import hide [as 别名]
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)
示例9: Qad_arc_maptool
# 需要导入模块: from qad_rubberband import QadRubberBand [as 别名]
# 或者: from qad_rubberband.QadRubberBand import hide [as 别名]
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
#.........这里部分代码省略.........
示例10: Qad_dim_maptool
# 需要导入模块: from qad_rubberband import QadRubberBand [as 别名]
# 或者: from qad_rubberband.QadRubberBand import hide [as 别名]
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]
#.........这里部分代码省略.........
示例11: Qad_line_maptool
# 需要导入模块: from qad_rubberband import QadRubberBand [as 别名]
# 或者: from qad_rubberband.QadRubberBand import hide [as 别名]
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)
示例12: Qad_scale_maptool
# 需要导入模块: from qad_rubberband import QadRubberBand [as 别名]
# 或者: from qad_rubberband.QadRubberBand import hide [as 别名]
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
#.........这里部分代码省略.........
示例13: Qad_move_maptool
# 需要导入模块: from qad_rubberband import QadRubberBand [as 别名]
# 或者: from qad_rubberband.QadRubberBand import hide [as 别名]
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)
示例14: Qad_pline_maptool
# 需要导入模块: from qad_rubberband import QadRubberBand [as 别名]
# 或者: from qad_rubberband.QadRubberBand import hide [as 别名]
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)
#.........这里部分代码省略.........
示例15: Qad_mirror_maptool
# 需要导入模块: from qad_rubberband import QadRubberBand [as 别名]
# 或者: from qad_rubberband.QadRubberBand import hide [as 别名]
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)