def testCtor(self):
box = QgsBox3d(5.0, 6.0, 7.0, 10.0, 11.0, 12.0)
self.assertEqual(box.xMinimum(), 5.0)
self.assertEqual(box.yMinimum(), 6.0)
self.assertEqual(box.zMinimum(), 7.0)
self.assertEqual(box.xMaximum(), 10.0)
self.assertEqual(box.yMaximum(), 11.0)
self.assertEqual(box.zMaximum(), 12.0)
box = QgsBox3d(QgsPointV2(QgsWkbTypes.PointZ, 5, 6, 7),
QgsPointV2(QgsWkbTypes.PointZ, 10, 11, 12))
self.assertEqual(box.xMinimum(), 5.0)
self.assertEqual(box.yMinimum(), 6.0)
self.assertEqual(box.zMinimum(), 7.0)
self.assertEqual(box.xMaximum(), 10.0)
self.assertEqual(box.yMaximum(), 11.0)
self.assertEqual(box.zMaximum(), 12.0)
# point constructor should normalize
box = QgsBox3d(QgsPointV2(QgsWkbTypes.PointZ, 10, 11, 12),
QgsPointV2(QgsWkbTypes.PointZ, 5, 6, 7))
self.assertEqual(box.xMinimum(), 5.0)
self.assertEqual(box.yMinimum(), 6.0)
self.assertEqual(box.zMinimum(), 7.0)
self.assertEqual(box.xMaximum(), 10.0)
self.assertEqual(box.yMaximum(), 11.0)
self.assertEqual(box.zMaximum(), 12.0)
def exportToQgsCircularStringV2(self):
"""Export CADCircle to a QgsCircularStringV2"""
quadrant = self.quadrant()
quad = [QgsPointV2(p.x, p.y) for p in quadrant] + \
[QgsPointV2(quadrant[0].x, quadrant[0].y)]
QgsCircString = QgsCircularStringV2()
QgsCircString.setPoints(quad)
return QgsCircString
def _snapCursorPoint(self, cursorPoint):
res, snapResults = self._snapper.snapToBackgroundLayers(cursorPoint)
if (res != 0 or len(snapResults) < 1):
clicked = self.toMapCoordinates(cursorPoint)
clickedV2 = QgsPointV2(clicked)
return clicked, clickedV2, False
else:
# Take a copy as QGIS will delete the result!
snapped = QgsPoint(snapResults[0].snappedVertex)
snappedV2 = QgsPointV2(snapped)
return snapped, snappedV2, True
def map(self, p):
# move to origin (translation part 1)
p = QgsPointV2(p.x() - self.dx1, p.y() - self.dy1)
# scale
p = QgsPointV2(self.ds * p.x(), self.ds * p.y())
# rotation
p = QgsPointV2(
math.cos(self.da) * p.x() - math.sin(self.da) * p.y(),
math.sin(self.da) * p.x() + math.cos(self.da) * p.y())
# remove to right spot (translation part 2)
p = QgsPointV2(p.x() + self.dx2, p.y() + self.dy2)
return p
def _addGridLinesToLayer(self,
layer,
transformer,
originX,
intervalX,
repeatX,
originY,
intervalY,
repeatY,
attributes,
localFieldX='local_x',
localFieldY='local_x',
mapFieldX='map_x',
mapFieldY='map_y'):
if (layer is None or not layer.isValid()
or layer.geometryType() != QGis.Line):
return
features = []
terminusX = originX + (intervalX * repeatX)
terminusY = originY + (intervalY * repeatY)
for localX in range(originX, originX + (intervalX * repeatX) + 1,
intervalX):
localStartPoint = QgsPointV2(localX, originY)
localEndPoint = QgsPointV2(localX, terminusY)
mapStartPoint = transformer.map(localStartPoint)
mapEndPoint = transformer.map(localEndPoint)
feature = QgsFeature(layer.dataProvider().fields())
lineGeometry = QgsLineStringV2()
lineGeometry.setPoints([mapStartPoint, mapEndPoint])
feature.setGeometry(QgsGeometry(lineGeometry))
self._setAttributes(feature, attributes)
feature.setAttribute(localFieldX, localX)
feature.setAttribute(mapFieldX, mapStartPoint.x())
features.append(feature)
for localY in range(originY, originY + (intervalY * repeatY) + 1,
intervalY):
localStartPoint = QgsPointV2(originX, localY)
localEndPoint = QgsPointV2(terminusX, localY)
mapStartPoint = transformer.map(localStartPoint)
mapEndPoint = transformer.map(localEndPoint)
feature = QgsFeature(layer.dataProvider().fields())
lineGeometry = QgsLineStringV2()
lineGeometry.setPoints([mapStartPoint, mapEndPoint])
feature.setGeometry(QgsGeometry(lineGeometry))
self._setAttributes(feature, attributes)
feature.setAttribute(localFieldY, localY)
feature.setAttribute(mapFieldY, mapStartPoint.y())
features.append(feature)
layers.addFeatures(features, layer)
def _addGridPointsToLayer(self,
layer,
transformer,
originX,
intervalX,
repeatX,
originY,
intervalY,
repeatY,
attributes,
localFieldX='local_x',
localFieldY='local_x',
mapFieldX='map_x',
mapFieldY='map_y'):
if (layer is None or not layer.isValid()
or layer.geometryType() != QGis.Point):
return
features = []
for localX in range(originX, originX + (intervalX * repeatX) + 1,
intervalX):
for localY in range(originY, originY + (intervalY * repeatY) + 1,
intervalY):
localPoint = QgsPointV2(localX, localY)
mapPoint = transformer.map(localPoint)
feature = QgsFeature(layer.dataProvider().fields())
feature.setGeometry(QgsGeometry(mapPoint))
self._setAttributes(feature, attributes)
feature.setAttribute(localFieldX, localX)
feature.setAttribute(localFieldY, localY)
feature.setAttribute(mapFieldX, mapPoint.x())
feature.setAttribute(mapFieldY, mapPoint.y())
features.append(feature)
layers.addFeatures(features, layer)
def __mid_12(self):
"""
To get the middle between point 1 and point 2
:return: the middle point 1-2
"""
return QgsPointV2(old_div((self.__p1.x() + self.__p2.x()), 2),
old_div((self.__p1.y() + self.__p2.y()), 2))
def __mid_23(self):
"""
To get the middle between point 2 and point 3
:return: the middle poinr 2-3
"""
return QgsPointV2(old_div((self.__p2.x() + self.__p3.x()), 2),
old_div((self.__p2.y() + self.__p3.y()), 2))
def __linePreview(self, point):
"""
To create a line geometry preview (rubberBand)
:param point: new position as mapPoint
"""
line_v2, curved = GeometryV2.asLineV2(
self.__selectedFeature.geometry(), self.__iface)
vertex = QgsPointV2()
line_v2.pointAt(self.__selectedVertex, vertex)
self.__rubberBand = QgsRubberBand(self.canvas(), QGis.Line)
dx = vertex.x() - point.x()
dy = vertex.y() - point.y()
if isinstance(curved, (list, tuple)):
self.__newFeature = QgsCompoundCurveV2()
for pos in range(line_v2.nCurves()):
curve_v2 = self.__newCurve(curved[pos], line_v2.curveAt(pos),
dx, dy)
self.__newFeature.addCurve(curve_v2)
if pos == 0:
self.__rubberBand.setToGeometry(
QgsGeometry(curve_v2.curveToLine()), None)
else:
self.__rubberBand.addGeometry(
QgsGeometry(curve_v2.curveToLine()), None)
else:
self.__newFeature = self.__newCurve(curved, line_v2, dx, dy)
self.__rubberBand.setToGeometry(
QgsGeometry(self.__newFeature.curveToLine()), None)
def processAlgorithm(self, progress):
source = self.getParameterValue(self.INPUT)
vlayer = dataobjects.getObjectFromUri(source)
output = self.getOutputFromName(self.OUTPUT)
fields = vlayer.fields()
x_field_index = fields.lookupField(self.getParameterValue(self.XFIELD))
y_field_index = fields.lookupField(self.getParameterValue(self.YFIELD))
z_field_index = None
if self.getParameterValue(self.ZFIELD):
z_field_index = fields.lookupField(self.getParameterValue(self.ZFIELD))
m_field_index = None
if self.getParameterValue(self.MFIELD):
m_field_index = fields.lookupField(self.getParameterValue(self.MFIELD))
wkb_type = QgsWkbTypes.Point
if z_field_index is not None:
wkb_type = QgsWkbTypes.addZ(wkb_type)
if m_field_index is not None:
wkb_type = QgsWkbTypes.addM(wkb_type)
crsId = self.getParameterValue(self.TARGET_CRS)
target_crs = QgsCoordinateReferenceSystem()
target_crs.createFromUserInput(crsId)
writer = output.getVectorWriter(fields, wkb_type, target_crs)
features = vector.features(vlayer)
total = 100.0 / len(features)
for current, feature in enumerate(features):
progress.setPercentage(int(current * total))
attrs = feature.attributes()
try:
x = float(attrs[x_field_index])
y = float(attrs[y_field_index])
point = QgsPointV2(x, y)
if z_field_index is not None:
try:
point.addZValue(float(attrs[z_field_index]))
except:
point.addZValue(0.0)
if m_field_index is not None:
try:
point.addMValue(float(attrs[m_field_index]))
except:
point.addMValue(0.0)
feature.setGeometry(QgsGeometry(point))
except:
pass # no geometry
writer.addFeature(feature)
del writer
def _addGridPolygonsToLayer(self,
layer,
transformer,
originX,
intervalX,
repeatX,
originY,
intervalY,
repeatY,
attributes,
localFieldX='local_x',
localFieldY='local_x',
mapFieldX='map_x',
mapFieldY='map_y'):
if (layer is None or not layer.isValid()
or layer.geometryType() != QGis.Polygon):
return
features = []
for localX in range(originX, originX + intervalX * repeatX, intervalX):
for localY in range(originY, originY + intervalY * repeatY,
intervalY):
localPoint = QgsPointV2(localX, localY)
mapPoint = transformer.map(localPoint)
points = []
points.append(transformer.map(localPoint))
points.append(
transformer.map(QgsPointV2(localX, localY + intervalY)))
points.append(
transformer.map(
QgsPointV2(localX + intervalX, localY + intervalY)))
points.append(
transformer.map(QgsPointV2(localX + intervalX, localY)))
feature = QgsFeature(layer.dataProvider().fields())
lineGeometry = QgsLineStringV2()
lineGeometry.setPoints(points)
polygonGeometry = QgsPolygonV2()
polygonGeometry.setExteriorRing(lineGeometry)
feature.setGeometry(QgsGeometry(polygonGeometry))
self._setAttributes(feature, attributes)
feature.setAttribute(localFieldX, localX)
feature.setAttribute(localFieldY, localY)
feature.setAttribute(mapFieldX, mapPoint.x())
feature.setAttribute(mapFieldY, mapPoint.y())
features.append(feature)
layers.addFeatures(features, layer)
def translateFeatures(self, layer, xInterval, yInterval, allFeatures):
localOriginPoint = QgsPointV2(0, 0)
localTranslatedPoint = QgsPointV2(xInterval, yInterval)
mapOriginPoint = self.localTransformer.map(localOriginPoint)
mapTranslatedPoint = self.localTransformer.map(localTranslatedPoint)
dx = mapTranslatedPoint.x() - mapOriginPoint.x()
dy = mapTranslatedPoint.y() - mapOriginPoint.y()
if layer.startEditing():
featureIds = None
if allFeatures:
featureIds = layer.allFeatureIds()
else:
featureIds = layer.selectedFeaturesIds()
for featureId in featureIds:
layer.translateFeature(featureId, dx, dy)
if layer.commitChanges():
return self.updateLayerCoordinates(layer, False, False)
return False
def exportToQgsCircularStringV2(self):
"""Export CADCircle to a QgsCircularStringV2"""
QgsCircString = QgsCircularStringV2()
QgsCircString.setPoints([
QgsPointV2(p)
for p in [self._ptStart, self._ptArc, self._ptEnd]
])
return QgsCircString
def center(self):
mid_12 = self.__mid_12()
mid_23 = self.__mid_23()
slop_12 = self.__slop_p_12()
slop_23 = self.__slop_p_23()
x = (mid_23.y() - mid_12.y() + slop_12 * mid_12.x() -
slop_23 * mid_23.x()) / (slop_12 - slop_23)
y = (x - mid_12.x()) * slop_12 + mid_12.y()
return QgsPointV2(x, y)
def canvasMoveEvent(self, event):
"""
When the mouse is moved
:param event: mouse event
"""
if self.__selecting:
self.__rubber.reset()
firstV2 = QgsPointV2(self.first)
second = QgsPointV2(self.first.x(), event.mapPoint().y())
third = QgsPointV2(event.mapPoint())
fourth = QgsPointV2(event.mapPoint().x(), self.first.y())
lineV2 = QgsLineStringV2()
lineV2.setPoints([firstV2, second, third, fourth, firstV2])
polygonV2 = QgsPolygonV2()
polygonV2.setExteriorRing(lineV2)
self.geom = QgsGeometry(polygonV2)
self.__rubber.setToGeometry(self.geom, None)
def getProjection(self, p):
"""
Get the p projection on segment
:param p: QgsPointV2
:param pProj: QgsPointV2 reference
:return: bool
"""
s1 = QgsPointV2(self.idxFrom.point())
s2 = QgsPointV2(self.idxTo.point())
nx = s2.y() - s1.y()
ny = -(s2.x() - s1.x())
if s1 == s2:
return s1
t = (p.x() * ny - p.y() * nx - s1.x() * ny + s1.y() * nx) / ((s2.x() - s1.x()) * ny - (s2.y() - s1.y()) * nx)
if t < 0. or t > 1.:
return False
pProj = QgsPointV2(s1.x() + (s2.x() - s1.x()) * t, s1.y() + (s2.y() - s1.y()) * t)
return pProj
def canvasMoveEvent(self, event):
"""
When the mouse is moved
:param event: mouse event
"""
if self.__isSelected:
dots = QgsLineStringV2()
dots.addVertex(self.__startVertex)
dots.addVertex(QgsPointV2(event.mapPoint()))
self.__rubberDots.reset()
self.__rubberDots.setToGeometry(QgsGeometry(dots.clone()), None)
def __pointPreview(self, point):
"""
To create a point geometry preview (rubberBand)
:param point: new position as mapPoint
"""
point_v2 = GeometryV2.asPointV2(self.__selectedFeature.geometry())
self.__newFeature = QgsPointV2(point.x(), point.y())
self.__newFeature.addZValue(point_v2.z())
self.__rubberBand = QgsRubberBand(self.__canvas, QGis.Point)
self.__rubberBand.setToGeometry(QgsGeometry(self.__newFeature.clone()),
None)
def __createPoint(tab):
"""
To create a new QGSPointV2 from coordinates
:param tab: coordinates
:return: QGSPointV2
"""
pointV2 = QgsPointV2(float(tab[0]), float(tab[1]))
if len(tab) > 2:
pointV2.addZValue(float(tab[2]))
if len(tab) > 3:
pointV2.addMValue(float(tab[3]))
return pointV2
def pasteMapPointFromClipboard(self):
# TODO Use QgsClipboard when it becomes public
text = QApplication.clipboard().text().strip().upper()
idx = text.find('POINT(')
if idx >= 0:
idx_l = idx + 5
idx_r = text.find(')', idx_l) + 1
text = text[idx_l:idx_r]
if (text[0] == '(' and text[len(text) - 1] == ')'):
coords = text[1:len(text) - 2].split()
point = QgsPointV2(float(coords[0]), float(coords[1]))
self.setMapPoint(point)
def testContainsPoint(self):
box = QgsBox3d(5.0, 6.0, 7.0, 11.0, 13.0, 15.0)
self.assertTrue(box.contains(QgsPointV2(QgsWkbTypes.PointZ, 6, 7, 8)))
self.assertFalse(box.contains(QgsPointV2(QgsWkbTypes.PointZ, 16, 7, 8)))
self.assertFalse(box.contains(QgsPointV2(QgsWkbTypes.PointZ, 6, 17, 8)))
self.assertFalse(box.contains(QgsPointV2(QgsWkbTypes.PointZ, 6, 7, 18)))
# 2d containment
self.assertTrue(box.contains(QgsPointV2(QgsWkbTypes.Point, 6, 7)))
self.assertFalse(box.contains(QgsPointV2(QgsWkbTypes.Point, 16, 7)))
self.assertFalse(box.contains(QgsPointV2(QgsWkbTypes.Point, 6, 17)))
def __newPoint(angle, point, distance):
"""
To create a new point at a certain distance and certain azimut from another point
:param angle: the azimut
:param point: the reference point
:param distance: the distance
:return: the new QgsPoint (with same elevation than parameter point)
"""
x = point.x() + cos(angle) * distance
y = point.y() + sin(angle) * distance
pt = QgsPointV2(x, y)
pt.addZValue(point.z())
return pt
def center(self):
"""
To get the center of the arc
:return: the arc center
"""
mid_12 = self.__mid_12()
mid_23 = self.__mid_23()
slop_12 = self.__slop_p_12()
slop_23 = self.__slop_p_23()
x = old_div((mid_23.y() - mid_12.y() + slop_12 * mid_12.x() -
slop_23 * mid_23.x()), (slop_12 - slop_23))
y = (x - mid_12.x()) * slop_12 + mid_12.y()
return QgsPointV2(x, y)
def __newCurve(self, curved, line_v2, dx, dy):
if curved:
newCurve = QgsCircularStringV2()
else:
newCurve = QgsLineStringV2()
points = []
for pos in xrange(line_v2.numPoints()):
x = line_v2.pointN(pos).x() - dx
y = line_v2.pointN(pos).y() - dy
pt = QgsPointV2(x, y)
pt.addZValue(line_v2.pointN(pos).z())
points.append(pt)
newCurve.setPoints(points)
return newCurve
def __ok(self, withVertex, withPoint):
line_v2, curved = GeometryV2.asLineV2(
self.__selectedFeature.geometry())
vertex_v2 = QgsPointV2()
vertex_id = QgsVertexId()
line_v2.closestSegment(QgsPointV2(self.__mapPoint), vertex_v2,
vertex_id, 0)
x0 = line_v2.xAt(vertex_id.vertex - 1)
y0 = line_v2.yAt(vertex_id.vertex - 1)
d0 = Finder.sqrDistForCoords(x0, vertex_v2.x(), y0, vertex_v2.y())
x1 = line_v2.xAt(vertex_id.vertex)
y1 = line_v2.yAt(vertex_id.vertex)
d1 = Finder.sqrDistForCoords(x1, vertex_v2.x(), y1, vertex_v2.y())
z0 = line_v2.zAt(vertex_id.vertex - 1)
z1 = line_v2.zAt(vertex_id.vertex)
vertex_v2.addZValue((d0 * z1 + d1 * z0) / (d0 + d1))
if withPoint:
pt_feat = QgsFeature(self.__layer.pendingFields())
pt_feat.setGeometry(QgsGeometry(vertex_v2))
if self.__layer.editFormConfig().suppress(
) == QgsEditFormConfig.SuppressOn:
self.__layer.addFeature(pt_feat)
else:
self.__iface.openFeatureForm(self.__layer, pt_feat)
if withVertex:
line_v2.insertVertex(vertex_id, vertex_v2)
self.__lastLayer.changeGeometry(self.__selectedFeature.id(),
QgsGeometry(line_v2))
self.__lastLayer.removeSelection()
self.__rubber.reset()
self.__lastFeatureId = None
self.__selectedFeature = None
self.__isEditing = False
def createGridDialogAccepted(self):
mp1 = self.gridWizard.mapPoint1()
lp1 = self.gridWizard.localPoint1()
mp2 = self.gridWizard.mapPoint2()
lp2 = self.gridWizard.localPoint2()
xInterval = self.gridWizard.localEastingInterval()
yInterval = self.gridWizard.localNorthingInterval()
if self.gridWizard.methodType() != GridWizard.TwoKnownPoints:
axisGeometry = QgsGeometry.fromPolyline([mp1, mp2])
if self.gridWizard.methodType() == GridWizard.PointOnYAxis:
if axisGeometry.length() < yInterval:
self._plugin.showCriticalMessage(
'Cannot create grid: Input axis must be longer than local interval'
)
return False
mp2 = axisGeometry.interpolate(yInterval).geometry()
lp2 = QgsPointV2(lp1.x(), lp1.y() + yInterval)
else:
if axisGeometry.length() < xInterval:
self._plugin.showCriticalMessage(
'Cannot create grid: Input axis must be longer than local interval'
)
return False
mp2 = axisGeometry.interpolate(xInterval).geometry()
lp2 = QgsPointV2(lp1.x() + xInterval, lp1.y())
if self.createGrid(self.gridWizard.siteCode(),
self.gridWizard.gridName(), mp1, lp1, mp2, lp2,
self.gridWizard.localOriginPoint(),
self.gridWizard.localTerminusPoint(), xInterval,
yInterval):
self._plugin.mapCanvas().refresh()
self.loadGridNames()
self.setGrid(self.gridWizard.siteCode(),
self.gridWizard.gridName())
self._setReadOnly(False)
self._plugin.showInfoMessage('Grid successfully created', 10)
def __snapToIntersection(self, mapPoint, selectedFeature):
"""
To check is we can snap a close intersection
:param mapPoint: the point to check
:param selectedFeature: the feature that can intersect another one
:return: an intersection QgsPointV2 or none
"""
f = Finder.findClosestFeatureAt(mapPoint, self.__linesConfig, self)
if f is None:
return None
intersect = Finder.intersect(selectedFeature.geometry(), f.geometry(),
mapPoint)
if intersect is not None:
return QgsPointV2(intersect)
else:
return None
def projPointOnSegment(self, p, s1, s2):
"""
p: QgsPointV2
s1: QgsPointV2 of segment
s2: QgsPointV2 of segment
"""
nx = s2.y() - s1.y()
ny = -( s2.x() - s1.x() )
if s1 == s2:
return s1
t = ( p.x() * ny - p.y() * nx - s1.x() * ny + s1.y() * nx ) / ( ( s2.x() - s1.x() ) * ny - ( s2.y() - s1.y() ) * nx )
if t < 0.:
return s1
elif t > 1.:
return s2
else:
return QgsPointV2( s1.x() + ( s2.x() - s1.x() ) * t, s1.y() + ( s2.y() - s1.y() ) * t )
def updateLayerCoordinates(self, layer, updateGeometry, createMapFields):
if (not self._initialised or layer is None or not layer.isValid()
or layer.geometryType() != QGis.Point):
return False
local_x = 'local_x'
local_y = 'local_y'
map_x = 'map_x'
map_y = 'map_y'
if layer.startEditing():
if layer.fieldNameIndex(local_x) < 0:
layer.dataProvider().addAttributes(
[self._plugin.field('local_x')])
if layer.fieldNameIndex(local_y) < 0:
layer.dataProvider().addAttributes(
[self._plugin.field('local_y')])
if (createMapFields and layer.fieldNameIndex(map_x) < 0):
layer.dataProvider().addAttributes(
[self._plugin.field('map_x')])
if (createMapFields and layer.fieldNameIndex(map_y) < 0):
layer.dataProvider().addAttributes(
[self._plugin.field('map_y')])
local_x_idx = layer.fieldNameIndex(local_x)
local_y_idx = layer.fieldNameIndex(local_y)
map_x_idx = layer.fieldNameIndex(map_x)
map_y_idx = layer.fieldNameIndex(map_y)
if updateGeometry:
for feature in layer.getFeatures():
localPoint = QgsPointV2(feature.attribute(local_x),
feature.attribute(local_y))
mapPoint = self.localTransformer.map(localPoint)
layer.changeGeometry(feature.id(), QgsGeometry(mapPoint))
for feature in layer.getFeatures():
mapPoint = feature.geometry().geometry()
localPoint = self.mapTransformer.map(mapPoint)
layer.changeAttributeValue(feature.id(), local_x_idx,
localPoint.x())
layer.changeAttributeValue(feature.id(), local_y_idx,
localPoint.y())
layer.changeAttributeValue(feature.id(), map_x_idx,
mapPoint.x())
layer.changeAttributeValue(feature.id(), map_y_idx,
mapPoint.y())
return layer.commitChanges()
return False
def __onDstOk(self):
"""
When the Ok button in Intersect Distance Dialog is pushed
"""
self.__distance = float(self.__dstDlg.observation().text())
circle = QgsCircularStringV2()
x = self.__dstDlg.mapPoint().x()
y = self.__dstDlg.mapPoint().y()
circle.setPoints([
QgsPointV2(x + self.__distance * cos(pi / 180 * a),
y + self.__distance * sin(pi / 180 * a))
for a in range(0, 361, 90)
])
lineLayer = self.__lineLayer()
lineLayer.startEditing()
feature = QgsFeature()
feature.setGeometry(QgsGeometry(circle))
fields = lineLayer.pendingFields()
feature.setFields(fields)
fieldsNames = [fields.at(pos).name() for pos in range(fields.count())]
if "distance" in fieldsNames:
feature.setAttribute("distance", self.__distance)
if "x" in fieldsNames:
feature.setAttribute("x", self.__dstDlg.mapPoint().x())
if "y" in fieldsNames:
feature.setAttribute("y", self.__dstDlg.mapPoint().y())
lineLayer.addFeature(feature)
# lineLayer.updateExtents()
lineLayer.commitChanges()
# center
pointLayer = self.__pointLayer()
pointLayer.startEditing()
feature = QgsFeature()
feature.setGeometry(QgsGeometry().fromPoint(self.__dstDlg.mapPoint()))
fields = pointLayer.pendingFields()
feature.setFields(fields)
pointLayer.addFeature(feature)
pointLayer.commitChanges()
self.__dstDlg.accept()
self.__cancel()
