Python QgsGeometry.fromPolyline方法代码示例

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolyline [as 别名]
    def _rectangleGridLine(self, writer, width, height, originX, originY,
                           hSpacing, vSpacing):
        ft = QgsFeature()

        columns = int(math.floor(float(width) / hSpacing))
        rows = int(math.floor(float(height) / vSpacing))

        # Longitude lines
        for col in xrange(0, columns + 1):
            polyline = []
            x = originX + (col * hSpacing)
            for row in xrange(0, rows + 1):
                y = originY + (row * vSpacing)
                polyline.append(QgsPoint(x, y))

            ft.setGeometry(QgsGeometry.fromPolyline(polyline))
            ft.setAttributes([x, originY, x, originY + (rows * vSpacing)])
            writer.addFeature(ft)

        # Latitude lines
        for row in xrange(0, rows + 1):
            polyline = []
            y = originY + (row * vSpacing)
            for col in xrange(0, columns + 1):
                x = originX + (col * hSpacing)
                polyline.append(QgsPoint(x, y))

            ft.setGeometry(QgsGeometry.fromPolyline(polyline))
            ft.setAttributes([originX, y, originX + (col * hSpacing), y])
            writer.addFeature(ft)

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolyline [as 别名]
    def drawLimits (self):
        self.dlg.listWidget.clear()
        #comprobate if the layer already exists and delete it
        for lyr in QgsMapLayerRegistry.instance().mapLayers().values():
            if lyr.name() == "Limites":
                QgsMapLayerRegistry.instance().removeMapLayer( lyr.id() )
                break

        #crete a vector layer with a expecific name and color
        v_layer = QgsVectorLayer("LineString", "Limites", "memory")
        symbols =v_layer.rendererV2().symbols()
        symbol=symbols[0]
        symbol.setColor(QColor('magenta'))
        #create the provider and add the layer
        pr = v_layer.dataProvider()
        QgsMapLayerRegistry.instance().addMapLayers([v_layer])
        seg = QgsFeature()
        iterations=len(self.tool.polygon)
        #draw the lines between the buttons in order
        for i in range (iterations):
            if i== iterations-1:
                seg.setGeometry(QgsGeometry.fromPolyline([self.tool.polygon[i], self.tool.polygon[0]]))
            else:
                seg.setGeometry(QgsGeometry.fromPolyline([self.tool.polygon[i], self.tool.polygon[i+1]]))
            #add the lines to the provider and update the layer
            pr.addFeatures( [ seg ] )
            v_layer.updateExtents()
            v_layer.triggerRepaint()

        #add the points to the QlistWidget
        for i in range (len(self.tool.polygon)):
            self.addItem(i)

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolyline [as 别名]
    def finishGeom (self, numPoints):
        if self.maxPoints == 1:
            geom = QgsGeometry.fromPoint(self.captureList[0])
        elif self.isPolygon and numPoints == 2:
            geom = QgsGeometry.fromPolyline(self.captureList)
            #geom = QgsGeometry.fromRect(geom.boundingBox())
        elif self.isPolygon:
            geom = QgsGeometry.fromPolygon([self.captureList])
        else:
            geom = QgsGeometry.fromPolyline(self.captureList)

        geom.simplify(0.00001)
        geom.transform(QgsCoordinateTransform(
                                              self.canvas.mapSettings().destinationCrs(),
                                              self.crs))
        
        if self.yx:
            i = 0
            vertex = geom.vertexAt(i)
            while (vertex != QgsPoint(0,0)):
                x = vertex.x()
                y = vertex.y()
                geom.moveVertex(y, x, i)
                i+=1
                vertex = geom.vertexAt(i) 
        
        self.selectionFinished.emit(geom.exportToWkt())
        self.clearMapCanvas()

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolyline [as 别名]
def densify(geometry, maxsegmentlength):
    """Densifies geometry vertices, so no segment is longer than maxsegmentlength
    Only implemented for linestring at the time being"""
    g = togeometry(geometry)
    type = QGis.flatType((g.wkbType()))
    if not type == QGis.WKBLineString:
        raise NotImplementedError("Densify is only implemented for LineStrings at the moment")
    input_coords = tocoordinates(g)
    output_coords = []
    maxsegmentlength = float(maxsegmentlength)
    for ix in xrange(len(input_coords) - 1):
        p0 = input_coords[ix]
        p1 = input_coords[ix + 1]
        output_coords.append(QgsPoint(p0))
        # Avoid calculating these values at the cost of performace.
        in_segment = QgsGeometry.fromPolyline([p0, p1])
        in_segment_length = in_segment.length()
        segcount = int(ceil(in_segment_length / maxsegmentlength))
        if segcount > 1:
            new_seg_length = float(in_segment_length) / segcount
            for i in xrange(1,segcount):
                new_p = in_segment.interpolate(new_seg_length * i).asPoint()
                output_coords.append(new_p)
    # Add last coord
    output_coords.append(input_coords[-1])
    return QgsGeometry.fromPolyline(output_coords)

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolyline [as 别名]
    def test_identify_segment_center(self):
        """Test for identify_segment_center."""
        points = [
            (QgsPoint(0, 0)),
            (QgsPoint(1, 0)),
            (QgsPoint(2, 0)),
        ]

        geom = QgsGeometry.fromPolyline(points)
        line = QgsFeature()
        line.setGeometry(geom)

        center = identify_segment_center(line)
        expected_center = QgsPoint(1, 0)
        message = 'Expected %s but I got %s' % (expected_center, center)
        self.assertEqual(expected_center, center, message)

        points.append(QgsPoint(5, 0))

        geom = QgsGeometry.fromPolyline(points)
        line = QgsFeature()
        line.setGeometry(geom)

        center = identify_segment_center(line)
        expected_center = QgsPoint(2.5, 0)
        message = 'Expected %s but I got %s' % (expected_center, center)
        self.assertEqual(expected_center, center, message)

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolyline [as 别名]
 def canvasReleaseEvent(self,event):
     if event.button() == Qt.RightButton:
       self.points.append(QgsPoint( self.toMapCoordinates( event.pos()) ) )
       if len(self.points) <= 1 :return
     
       self.rubberBand.setToGeometry( QgsGeometry.fromPolyline(self.points), None )
       self.callback( self.rubberBand )
       QgsMapTool.deactivate(self)
     else:
       self.points.append(QgsPoint( self.toMapCoordinates(event.pos()) ) )
       if len(self.points) <= 1 : return
       self.rubberBand.setToGeometry( QgsGeometry.fromPolyline(self.points), None )

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolyline [as 别名]
 def reprojectRubberBand(self, geom):
     """
     Reprojects the geometry
     geom: QgsGeometry
     """
     # Defining the crs from src and destiny
     epsg = self.canvas.mapSettings().destinationCrs().authid()
     crsSrc = QgsCoordinateReferenceSystem(epsg)
     #getting srid from something like 'EPSG:31983'
     layer = self.canvas.currentLayer()
     srid = layer.crs().authid()
     crsDest = QgsCoordinateReferenceSystem(srid) #here we have to put authid, not srid
     # Creating a transformer
     coordinateTransformer = QgsCoordinateTransform(crsSrc, crsDest)
     lyrType = self.iface.activeLayer().geometryType()
     # Transforming the points
     if lyrType == QGis.Line:
         geomList = geom.asPolyline()
     elif lyrType == QGis.Polygon:
         geomList = geom.asPolygon()
     newGeom = []
     for j in xrange(len(geomList)):
         if lyrType == QGis.Line:
             newGeom.append(coordinateTransformer.transform(geomList[j]))
         elif lyrType == QGis.Polygon:
             line = geomList[j]
             for i in xrange(len(line)):
                 point = line[i]
                 newGeom.append(coordinateTransformer.transform(point))
     if lyrType == QGis.Line:
         return QgsGeometry.fromPolyline(newGeom + [newGeom[0]])
     elif lyrType == QGis.Polygon:
         return QgsGeometry.fromPolygon([newGeom])                   

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolyline [as 别名]
    def _segmentAzimuth(self, line1Azimuth, line2Azimuth):
        nearLineGeom = self._nearLine.geometry()
        if nearLineGeom.isMultipart():
            dct = {}
            minDists = []

            for line in nearLineGeom.asMultiPolyline():
                l = QgsGeometry.fromPolyline(line)
                closestSegmContext = l.closestSegmentWithContext(
                    self._nearestVertex
                )
                minDists.append(closestSegmContext[0])
                dct[closestSegmContext[0]] = [line, closestSegmContext[-1]]

            minDistance = min(minDists)
            closestSegment = dct[minDistance][0]
            indexSegmEnd = dct[minDistance][1]
            segmEnd = closestSegment[indexSegmEnd]
            segmStart = closestSegment[indexSegmEnd - 1]
        else:
            closestSegmContext = nearLineGeom.closestSegmentWithContext(
                self._nearestVertex
            )
            indexSegmEnd = closestSegmContext[-1]
            segmEnd = nearLineGeom.asPolyline()[indexSegmEnd]
            segmStart = nearLineGeom.asPolyline()[indexSegmEnd - 1]

        segmentAzimuth = segmStart.azimuth(segmEnd)
        self._dltAz1 = self._getDeltaAzimuth(segmentAzimuth, line1Azimuth)
        self._dltAz2 = self._getDeltaAzimuth(segmentAzimuth, line2Azimuth)

        self._azimuth()

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolyline [as 别名]
def createlinemarker(f0, f1):
    g0 = togeometry(f0)
    g1 = togeometry(f1)
    p0 = linemarkerpoint(g0, g1)
    p1 = linemarkerpoint(g1, g0)
    geom = QgsGeometry.fromPolyline([p0.asPoint(), p1.asPoint()])
    return geom

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolyline [as 别名]
    def test_multi_intersect(self):
        def zipline(p1, p2, increment):
            middle = p1.x()
            start = p1.y() + increment
            end = p2.y() - increment
            while start < end:
                yield QgsPoint(middle - increment, start)
                start += increment
                yield QgsPoint(middle + increment, start)

        # Define the two captured points
        p1, p2 = QgsPoint(20.0, 10.0), QgsPoint(20.0, 10.2)

        # Define a "zig-zag" LineString geometry along the line between these
        # two points
        ls_points = list(zipline(p1, p2, 0.01))
        ls = QgsGeometry.fromPolyline(ls_points)

        # Get the points generated by ElevationReader
        points = self.extract_elevation_helper(p1, p2, [FeatureDescr(ls, 20)])

        # Evaluate the results
        self.assertEqual(len(points), len(ls_points) - 1)
        p_x = [p.x() for p in points]
        self.assertListEqual(p_x, sorted(p_x))
        for point in points:
            self.assertEqual(point.y(), 20)

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolyline [as 别名]
    def processAlgorithm(self, progress):
        layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT))

        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
            layer.pendingFields().toList(), QGis.WKBLineString, layer.crs())

        outFeat = QgsFeature()
        inGeom = QgsGeometry()
        outGeom = QgsGeometry()

        current = 0
        features = vector.features(layer)
        total = 100.0 / float(len(features))
        for f in features:
            inGeom = f.geometry()
            attrs = f.attributes()
            lineList = self.extractAsLine(inGeom)
            outFeat.setAttributes(attrs)
            for h in lineList:
                outFeat.setGeometry(outGeom.fromPolyline(h))
                writer.addFeature(outFeat)

            current += 1
            progress.setPercentage(int(current * total))

        del writer

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolyline [as 别名]
 def testCrosses(self):
     myLine = QgsGeometry.fromPolyline([QgsPoint(0, 0),QgsPoint(1, 1),QgsPoint(3, 3)])
     myPoly = QgsGeometry.fromPolygon([[QgsPoint(1, 0),QgsPoint(2, 0),QgsPoint(2, 2),QgsPoint(1, 2), QgsPoint(1, 0)]])
     crossesGeom = QgsGeometry.crosses(myLine, myPoly)
     myMessage = ('Expected:\n%s\nGot:\n%s\n' %
                   ("True", crossesGeom))
     assert crossesGeom == True, myMessage

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolyline [as 别名]
 def canvasDoubleClickEvent(self,event):
     self.points.append(QgsPoint( self.toMapCoordinates( event.pos()) ))
     if len(self.points) <= 1 : return
   
     self.rubberBand.setToGeometry( QgsGeometry.fromPolyline(self.points), None )
     self.callback( self.rubberBand )
     QgsMapTool.deactivate(self)

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolyline [as 别名]
    def create_edge(self):

        # If edge already exists, delete it..
        if self.edge:
            self.l_edge.deleteFeature(self.edge.id())

        # Two vertices are needed..
        if not self.vtx_start or not self.vtx_end:
            return self.canvas.refresh()

        # Two DIFFERENT vertices..
        if self.vtx_start == self.vtx_end:
            return self.canvas.refresh()

        # Create line geometry..
        line = QgsGeometry.fromPolyline([self.vtx_start.geometry().asPoint(),
                                         self.vtx_end.geometry().asPoint()])

        # Create the feature..
        self.edge = QgsFeature()
        self.edge.setGeometry(line)
        self.edge.setFields(self.l_edge.pendingFields())
        self.edge.setAttributes(
                [QPyNullVariant(int), QPyNullVariant(int), QPyNullVariant(int)])

        # Add feature to layer..
        self.l_edge.addFeature(self.edge)
        self.canvas.refresh()

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolyline [as 别名]
 def canvasMoveEvent(self, event):
     if self.snapCursorRubberBand:
         self.snapCursorRubberBand.hide()
         self.snapCursorRubberBand.reset(geometryType=QGis.Point)
         self.snapCursorRubberBand = None
     oldPoint = QgsPoint(event.mapPoint())
     event.snapPoint(QgsMapMouseEvent.SnapProjectConfig)
     point = QgsPoint(event.mapPoint())
     if oldPoint != point:
         self.createSnapCursor(point)
     point = QgsPoint(event.mapPoint())   
     if self.qntPoint == 1:
         self.distanceToolTip.canvasMoveEvent(self.geometry[0], point)
         geom = QgsGeometry.fromPolyline([self.geometry[0], point])
         self.rubberBand.setToGeometry(geom, None)
     elif self.qntPoint >= 2:
         self.distanceToolTip.canvasMoveEvent(self.geometry[-1], point)
         if self.free:
             geom = QgsGeometry.fromPolygon([self.geometry+[QgsPoint(point.x(), point.y())]])
             self.rubberBand.setToGeometry(geom, None)             
         else:       
             if (self.qntPoint % 2 == 1): 
                 self.setAvoidStyleSnapRubberBand()
             else:
                 self.setAllowedStyleSnapRubberBand()
             projectedMousePoint = self.projectPoint(self.geometry[-2], self.geometry[-1], point)
             if projectedMousePoint:
                 geom, pf = self.completePolygon(self.geometry, projectedMousePoint)
                 self.rubberBand.setToGeometry(geom, None)