Python QgsGeometry.fromMultiPolyline方法代码示例

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolyline [as 别名]
 def densifyGeometry(self, geometry, pointsNumber, isPolygon):
     output = []
     if isPolygon:
         if geometry.isMultipart():
             polygons = geometry.asMultiPolygon()
             for poly in polygons:
                 p = []
                 for ring in poly:
                     p.append(self.densify(ring, pointsNumber))
                 output.append(p)
             return QgsGeometry.fromMultiPolygon(output)
         else:
             rings = geometry.asPolygon()
             for ring in rings:
                 output.append(self.densify(ring, pointsNumber))
             return QgsGeometry.fromPolygon(output)
     else:
         if geometry.isMultipart():
             lines = geometry.asMultiPolyline()
             for points in lines:
                 output.append(self.densify(points, pointsNumber))
             return QgsGeometry.fromMultiPolyline(output)
         else:
             points = geometry.asPolyline()
             output = self.densify(points, pointsNumber)
             return QgsGeometry.fromPolyline(output)

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolyline [as 别名]
  def toQgsGeometry(self):
    count = len(self.lines)
    if count > 1:
      lines = map(lineToQgsPolyline, self.lines)
      return QgsGeometry.fromMultiPolyline(lines)

    if count == 1:
      return QgsGeometry.fromPolyline(lineToQgsPolyline(self.lines[0]))

    return QgsGeometry()

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolyline [as 别名]
 def flipFeature(self, layer, feature, geomType=None, refreshCanvas=False):
     """
     Inverts the flow from a given feature. THE GIVEN FEATURE IS ALTERED. Standard behaviour is to not
     refresh canvas map.
     :param layer: layer containing the target feature for flipping.
     :param feature: feature to be flipped.
     :param geomType: if layer geometry type is not given, it'll calculate it (0,1 or 2)
     :param refreshCanvas: indicates whether the canvas should be refreshed after flipping feature.
     :returns: flipped feature as of [layer, feature, geometry_type].
     """
     if not geomType:
         geomType = layer.geometryType()
     # getting whether geometry is multipart or not
     isMulti = QgsWKBTypes.isMultiType(int(layer.wkbType()))
     geom = feature.geometry()
     if geomType == 0:
         if isMulti:
             nodes = geom.asMultiPoint()
             # inverting the point list by parts
             for idx, part in enumerate(nodes):
                 nodes[idx] = part[::-1]
             # setting flipped geometry
             flippedFeatureGeom = QgsGeometry.fromMultiPoint(nodes)                
         else:
             # inverting the point list
             nodes = geom.asPoint()
             nodes = nodes[::-1]
             flippedFeatureGeom = QgsGeometry.fromPoint(nodes)                
     elif geomType == 1:
         if isMulti:
             nodes = geom.asMultiPolyline()
             for idx, part in enumerate(nodes):
                 nodes[idx] = part[::-1]
             flippedFeatureGeom = QgsGeometry.fromMultiPolyline(nodes)
         else:
             nodes = geom.asPolyline()
             nodes = nodes[::-1]
             flippedFeatureGeom = QgsGeometry.fromPolyline(nodes)         
     elif geomType == 2:
         if isMulti:
             nodes = geom.asMultiPolygon()                
             for idx, part in enumerate(nodes):
                 nodes[idx] = part[::-1]
             flippedFeatureGeom = QgsGeometry.fromMultiPolygon(nodes)                
         else:
             nodes = geom.asPolygon()
             nodes = nodes[::-1]
             flippedFeatureGeom = QgsGeometry.fromPolygon(nodes)
     # setting feature geometry to the flipped one
     # feature.setGeometry(flippedFeatureGeom)
     # layer.updateFeature(feature)
     layer.changeGeometry(feature.id(), flippedFeatureGeom)
     if refreshCanvas:
         self.iface.mapCanvas().refresh()
     return [layer, feature, geomType]

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolyline [as 别名]
 def merge_geoms(self, group):
     geoms = [self.edge_geoms[line]['wkt'] for line in group]
     line_segms = []
     for line_wkt in geoms:
         line = QgsGeometry.fromWkt(line_wkt)
         if line.wkbType() == 2:
             line_segms.append([QgsPoint(i[0], i[1]) for i in line.asPolyline()])
         elif line.wkbType() == 5:
             for segm in line.asGeometryCollection():
                 line_segms.append([QgsPoint(i[0], i[1]) for i in segm.asPolyline()])
     ml_geom = QgsGeometry.fromMultiPolyline(line_segms)
     return ml_geom.exportToWkt()

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolyline [as 别名]
    def testAddFeatures(self):
        # test adding features to an edit buffer
        layer = createEmptyLayer()
        self.assertTrue(layer.startEditing())

        self.assertEqual(layer.editBuffer().addedFeatures(), {})
        self.assertFalse(layer.editBuffer().isFeatureAdded(1))
        self.assertFalse(layer.editBuffer().isFeatureAdded(3))

        # add two features
        f1 = QgsFeature(layer.fields(), 1)
        f1.setGeometry(QgsGeometry.fromPoint(QgsPointXY(1, 2)))
        f1.setAttributes(["test", 123])
        self.assertTrue(layer.addFeature(f1))

        f2 = QgsFeature(layer.fields(), 2)
        f2.setGeometry(QgsGeometry.fromPoint(QgsPointXY(2, 4)))
        f2.setAttributes(["test2", 246])

        self.assertTrue(layer.addFeature(f2))

        # test contents of buffer
        added = layer.editBuffer().addedFeatures()
        new_feature_ids = list(added.keys())
        self.assertEqual(added[new_feature_ids[0]]['fldtxt'], 'test2')
        self.assertEqual(added[new_feature_ids[0]]['fldint'], 246)
        self.assertEqual(added[new_feature_ids[1]]['fldtxt'], 'test')
        self.assertEqual(added[new_feature_ids[1]]['fldint'], 123)

        self.assertTrue(layer.editBuffer().isFeatureAdded(new_feature_ids[0]))
        self.assertTrue(layer.editBuffer().isFeatureAdded(new_feature_ids[1]))

        # check if error in case adding not adaptable geometry
        # eg. a Multiline in a Line
        layer = createEmptyLinestringLayer()
        self.assertTrue(layer.startEditing())

        self.assertEqual(layer.editBuffer().addedFeatures(), {})
        self.assertFalse(layer.editBuffer().isFeatureAdded(1))
        self.assertFalse(layer.editBuffer().isFeatureAdded(3))

        # add a features with a multi line geometry of not touched lines =>
        # cannot be forced to be linestring
        multiline = [
            [QgsPointXY(1, 1), QgsPointXY(2, 2)],
            [QgsPointXY(3, 3), QgsPointXY(4, 4)],
        ]
        f1 = QgsFeature(layer.fields(), 1)
        f1.setGeometry(QgsGeometry.fromMultiPolyline(multiline))
        f1.setAttributes(["test", 123])
        self.assertTrue(layer.addFeatures([f1]))
        self.assertFalse(layer.commitChanges())

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolyline [as 别名]
 def testMeasureMultiLine(self):
     #   +-+ +-+-+
     #   | | |   |
     # +-+ + +   +-+
     linestring = QgsGeometry.fromMultiPolyline(
         [
             [QgsPoint(0, 0), QgsPoint(1, 0), QgsPoint(1, 1), QgsPoint(2, 1), QgsPoint(2, 0)],
             [QgsPoint(3, 0), QgsPoint(3, 1), QgsPoint(5, 1), QgsPoint(5, 0), QgsPoint(6, 0)],
         ]
     )
     da = QgsDistanceArea()
     length = da.measure(linestring)
     myMessage = "Expected:\n%f\nGot:\n%f\n" % (9, length)
     assert length == 9, myMessage

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolyline [as 别名]
    def parse_geometry(gr):
        """node s ISLH grafikou"""

        g = gr[0] #obraz ma jen jeden prvek

        geom = (
                QgsGeometry.fromPoint(islh_parser.parse_point(g)) if g.tag == 'B'
                else QgsGeometry.fromPolyline(islh_parser.parse_line(g)) if g.tag == 'L'
                else QgsGeometry.fromMultiPoint(islh_parser.parse_multipoint(g)) if g.tag == 'MB'
                else QgsGeometry.fromMultiPolyline(islh_parser.parse_multiline(g)) if g.tag == 'ML'
                else QgsGeometry.fromPolygon(islh_parser.parse_polygon(g)) if g.tag == 'P'
                else QgsGeometry.fromMultiPolygon(islh_parser.parse_multipolygon(g)) if g.tag == 'MP' 
                else None) 

        return(geom)

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolyline [as 别名]
 def testMeasureMultiLine(self):
     #   +-+ +-+-+
     #   | | |   |
     # +-+ + +   +-+
     linestring = QgsGeometry.fromMultiPolyline(
         [
             [QgsPointXY(0, 0), QgsPointXY(1, 0), QgsPointXY(1, 1), QgsPointXY(2, 1), QgsPointXY(2, 0), ],
             [QgsPointXY(3, 0), QgsPointXY(3, 1), QgsPointXY(5, 1), QgsPointXY(5, 0), QgsPointXY(6, 0), ]
         ]
     )
     da = QgsDistanceArea()
     length = da.measureLength(linestring)
     myMessage = ('Expected:\n%f\nGot:\n%f\n' %
                  (9, length))
     assert length == 9, myMessage

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolyline [as 别名]
def extractlinestrings(f):
    """If input is a geometrycollection returns a linestring or multilinestring built from the the input"""
    g = togeometry(f)

    # Short circuit
    if g.type() == QGis.Line:
        return g

    singlegeoms = extractassingle(f)
    lines = [g for g in singlegeoms if g.type() == QGis.Line ]
    if lines:
        if len(lines) > 1:
            return QgsGeometry.fromMultiPolyline([g.asPolyline() for g in lines])
        else:
            return lines[0]
    return None

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolyline [as 别名]
 def getTree(self,point):
     backupCursor = self.canvas.cursor()
     self.canvas.setCursor(Qt.WaitCursor)
     upstream = False
     if self.direction == "upstream":
         upstream = True
     
     self.rubberBand.reset()
     
     edges = self.networkAnalyzer.getTree(point,upstream)
     polylines = self.networkAnalyzer.getEdgeGeometry( [edge[2]['feature'] for edge in edges] )
     
     # Fix for QGIS < 2.0
     filteredPolylines = [pl for pl in polylines if len(pl) > 0]
     
     self.rubberBand.addGeometry( QgsGeometry.fromMultiPolyline( filteredPolylines ), self.networkAnalyzer.getNodeLayer() )
     
     self.canvas.setCursor(backupCursor)

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolyline [as 别名]
    def __line_grid(self, feature, wkb_type):

        if feature.geometry().isMultipart():
            polylines = feature.geometry().asMultiPolyline()
            cleaned_polylines = list()
            for polyline in polylines:
                snapped_points = self.__points_to_grid(polyline)
                if len(snapped_points) < 2:
                    continue
                cleaned_polyline = snapped_points
                cleaned_polylines.append(cleaned_polyline)
            geom = QgsGeometry.fromMultiPolyline([x for x in cleaned_polylines])
        else:
            points = feature.geometry().asPolyline()
            snapped_points = self.__points_to_grid(points)
            geom = QgsGeometry.fromPolyline(snapped_points)

        return geom

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolyline [as 别名]
def spGeometry(geom, type):
    def split(L):
        n = len(L)/2
        return [L[:n], L[n:]]
    if type == "Polygon":
        coords = [map(lambda p: QgsPoint(*p), zip(*split(list(po.do_slot('coords')))))
                 for po in geom.do_slot('Polygons')]
        coords = QgsGeometry.fromMultiPolygon([coords])
    elif type == "LineString":
        coords = [map(lambda p: QgsPoint(*p), zip(*split(list(line.do_slot('coords')))))
                 for line in geom.do_slot('Lines')]
        coords = QgsGeometry.fromMultiPolyline(coords)
    elif type == "Point":
        coords = [QgsPoint(*geom)]
        coords = QgsGeometry.fromMultiPoint(coords)
    else:
        raise Exception("unable to convert geometries")
    return coords

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolyline [as 别名]
    def build_qgis_feature(self, vector_item):
        """
        Constructs a QGIS feature for rendering
        :param vector_item: The item returned
        :return a VectorFeature that can be rendered by QGIS
        """

        feature = VectorFeature()
        geometry = vector_item[KEY_JSON_GEOMETRY]
        coordinates = geometry[KEY_JSON_GEOMETRY_COORDINATES]
        geometry_type = geometry[KEY_JSON_GEOMETRY_TYPE]
        if geometry_type == u'Point':
            feature.setGeometry(QgsGeometry.fromPoint(self.get_point_from_json(coordinates)))
        elif geometry_type == u'LineString':
            feature.setGeometry(QgsGeometry.fromPolyline(self.get_linestring_from_json(coordinates)))
        elif geometry_type == u'MultiPoint':
            feature.setGeometry(QgsGeometry.fromMultiPoint(self.get_linestring_from_json(coordinates)))
        elif geometry_type == u'Polygon':
            feature.setGeometry(QgsGeometry.fromPolygon(self.get_polygon_from_json(coordinates)))
        elif geometry_type == u'MultiLineString':
            feature.setGeometry(QgsGeometry.fromMultiPolyline(self.get_polygon_from_json(coordinates)))
        elif geometry_type == u'MultiPolygon':
            feature.setGeometry(QgsGeometry.fromMultiPolygon(self.get_multipolygon_from_json(coordinates)))
        else:
            QgsMessageLog.instance().logMessage(u"Encountered odd geometry type: " + geometry_type, TAG_NAME,
                                                level=QgsMessageLog.CRITICAL)
        feature.geometry_type = geometry_type
        attributes = self.get_attributes_from_json(vector_item[KEY_JSON_PROPERTIES])
        fields = QgsFields()
        values = []
        for key, value in attributes.iteritems():
            type_value = None
            if key.endswith(u'int'):
                type_value = QVariant.Int
            elif key.endswith(u'dbl'):
                type_value = QVariant.Double
            else:
                type_value = QVariant.String
            fields.append(QgsField(key, type_value))
            values.append(value)
        feature.setFields(fields)
        feature.setAttributes(values)
        return feature

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolyline [as 别名]
    def getTree(self, point):
        """
        Does the work. Tracks the graph up- or downstream.
        :param point: The node from which the tracking should be started
        """
        QApplication.setOverrideCursor(Qt.WaitCursor)
        upstream = False
        if self.direction == "upstream":
            upstream = True

        self.rubberBand.reset()

        edges = self.networkAnalyzer.getTree(point, upstream)
        polylines = self.networkAnalyzer.getEdgeGeometry(
            [edge[2]['feature'] for edge in edges])

        # Fix for QGIS < 2.0
        filtered_polylines = [pl for pl in polylines if pl]

        self.rubberBand.addGeometry(QgsGeometry.fromMultiPolyline(filtered_polylines),
                                    self.networkAnalyzer.getNodeLayer())

        QApplication.restoreOverrideCursor()

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolyline [as 别名]
    def testBoundingBox(self):
        # 2-+-+-+-+-3
        # |         |
        # + 6-+-+-7 +
        # | |     | |
        # + + 9-+-8 +
        # | |       |
        # ! 5-+-+-+-4 !
        # |
        # 1-+-+-+-+-0 !
        points = [ QgsPoint(5,0), QgsPoint(0,0), QgsPoint(0,4), QgsPoint(5,4), QgsPoint(5,1), QgsPoint(1,1), QgsPoint(1,3), QgsPoint(4,3), QgsPoint(4,2), QgsPoint(2,2) ]
        polyline = QgsGeometry.fromPolyline(points)
        expbb = QgsRectangle(0,0,5,4)
        bb = polyline.boundingBox()
        assert expbb == bb, "Expected:\n%s\nGot:\n%s\n" % (expbb.toString(), bb.toString())

        #   2-3 6-+-7
        #   | | |   |
        # 0-1 4 5   8-9
        points = [
            [ QgsPoint(0,0), QgsPoint(1,0), QgsPoint(1,1), QgsPoint(2,1), QgsPoint(2,0), ],
            [ QgsPoint(3,0), QgsPoint(3,1), QgsPoint(5,1), QgsPoint(5,0), QgsPoint(6,0), ]
          ]
        polyline = QgsGeometry.fromMultiPolyline(points)
        expbb = QgsRectangle(0,0,6,1)
        bb = polyline.boundingBox()
        assert expbb == bb, "Expected:\n%s\nGot:\n%s\n" % (expbb.toString(), bb.toString())

        # 5---4
        # |   |
        # | 2-3
        # | |
        # 0-1
        points = [[
            QgsPoint(0,0), QgsPoint(1,0), QgsPoint(1,1), QgsPoint(2,1), QgsPoint(2,2), QgsPoint(0,2), QgsPoint(0,0),
          ]]
        polygon = QgsGeometry.fromPolygon(points)
        expbb = QgsRectangle(0,0,2,2)
        bb = polygon.boundingBox()
        assert expbb == bb, "Expected:\n%s\nGot:\n%s\n" % (expbb.toString(), bb.toString())

        # 3-+-+-2
        # |     |
        # + 8-7 +
        # | | | |
        # + 5-6 +
        # |     |
        # 0-+-+-1
        points = [
            [ QgsPoint(0,0), QgsPoint(3,0), QgsPoint(3,3), QgsPoint(0,3), QgsPoint(0,0) ],
            [ QgsPoint(1,1), QgsPoint(2,1), QgsPoint(2,2), QgsPoint(1,2), QgsPoint(1,1) ],
          ]
        polygon = QgsGeometry.fromPolygon(points)
        expbb = QgsRectangle(0,0,3,3)
        bb = polygon.boundingBox()
        assert expbb == bb, "Expected:\n%s\nGot:\n%s\n" % (expbb.toString(), bb.toString())

        # 5-+-4 0-+-9
        # |   | |   |
        # | 2-3 1-2 |
        # | |     | |
        # 0-1     7-8
        points = [
            [ [ QgsPoint(0,0), QgsPoint(1,0), QgsPoint(1,1), QgsPoint(2,1), QgsPoint(2,2), QgsPoint(0,2), QgsPoint(0,0), ] ],
            [ [ QgsPoint(4,0), QgsPoint(5,0), QgsPoint(5,2), QgsPoint(3,2), QgsPoint(3,1), QgsPoint(4,1), QgsPoint(4,0), ] ]
          ]

        polygon = QgsGeometry.fromMultiPolygon(points)
        expbb = QgsRectangle(0,0,5,2)
        bb = polygon.boundingBox()
        assert expbb == bb, "Expected:\n%s\nGot:\n%s\n" % (expbb.toString(), bb.toString())