Python QgsGeometry.fromMultiPolygon方法代码示例

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolygon [as 别名]
def qgsgeom_from_mpl_collec(collections):
    polygons = []
    for i, polygon in enumerate(collections):
        mpoly = []
        for path in polygon.get_paths():
            path.should_simplify = False
            poly = path.to_polygons()
            if len(poly) > 0 and len(poly[0]) > 3:
                exterior = [QgsPoint(*p.tolist()) for p in poly[0]]
                holes = [[QgsPoint(*p.tolist()) for p in h]
                         for h in poly[1:] if len(h) > 3]
                if len(holes) == 1:
                    mpoly.append([exterior, holes[0]])
                elif len(holes) > 1:
                    mpoly.append([exterior] + [h for h in holes])
                else:
                    mpoly.append([exterior])

        if len(mpoly) == 1:
            polygons.append(QgsGeometry.fromPolygon(mpoly[0]))
        elif len(mpoly) > 1:
            polygons.append(QgsGeometry.fromMultiPolygon(mpoly))
        else:
            polygons.append(QgsGeometry.fromPolygon([]))
    return polygons

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

        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
            layer.pendingFields(), layer.wkbType(), layer.crs()
        )

        features = vector.features(layer)
        total = 100.0 / len(features)

        feat = QgsFeature()
        for current, f in enumerate(features):
            geometry = f.geometry()
            if geometry:
                if geometry.isMultipart():
                    multi_polygon = geometry.asMultiPolygon()
                    for polygon in multi_polygon:
                        for ring in polygon[1:]:
                            polygon.remove(ring)
                    geometry = QgsGeometry.fromMultiPolygon(multi_polygon)

                else:
                    polygon = geometry.asPolygon()
                    for ring in polygon[1:]:
                        polygon.remove(ring)
                    geometry = QgsGeometry.fromPolygon(polygon)
            else:
                geometry = QgsGeometry(None)

            feat.setGeometry(geometry)
            feat.setAttributes(f.attributes())
            writer.addFeature(feat)
            progress.setPercentage(int(current * total))

        del writer

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolygon [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 fromMultiPolygon [as 别名]
        def fillHoles(self, layer, minWidth, minHeight, layerName):
            provider = layer.dataProvider()
            fields = provider.fields()
            writer = QgsVectorLayer("Polygon?crs=EPSG:2180", layerName, "memory")
            writer.startEditing()
            layer.startEditing()
            for feat in layer.getFeatures():
                geometry = feat.geometry()
                if geometry.isMultipart():
                    multi_polygon = geometry.asMultiPolygon()
                    for polygon in multi_polygon:
                        for ring in polygon[1:]:
                            geometry, area, perim, angle, width, height = self.OMBBox(QgsGeometry.fromPolygon([ring]))
                            if width <= minWidth or height <= minHeight or area <=minWidth*minHeight:
                                polygon.remove(ring)
                    geometry = QgsGeometry.fromMultiPolygon(multi_polygon)
                else:
                    polygon = geometry.asPolygon()
                    for ring in polygon[1:]:
                        geometry, area, perim, angle, width, height = self.OMBBox(QgsGeometry.fromPolygon([ring]))
                        if width <= minWidth or height <= minHeight or area <= minWidth * minHeight:
                            polygon.remove(ring)
                    geometry = QgsGeometry.fromPolygon(polygon)

                outFeat = QgsFeature()
                outFeat.setGeometry(geometry)
                writer.addFeature(feat)
            writer.commitChanges()
            layer.commitChanges()
            return writer

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolygon [as 别名]
 def reprojectGridZone(self, multipoly):
     crsSrc = QgsCoordinateReferenceSystem(self.crs.geographicCRSAuthId())
     coordinateTransformer = QgsCoordinateTransform(crsSrc, self.crs)
     polyline = multipoly.asMultiPolygon()[0][0]
     newPolyline = []
     for point in polyline:
         newPolyline.append(coordinateTransformer.transform(point))
     qgsMultiPolygon = QgsGeometry.fromMultiPolygon([[newPolyline]])
     return qgsMultiPolygon

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

    if count == 1:
      return QgsGeometry.fromPolygon(polygonToQgsPolygon(self.polygons[0]))

    return QgsGeometry()

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolygon [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 fromMultiPolygon [as 别名]
 def testFromMultiPolygon(self):
     myMultiPolygon = QgsGeometry.fromMultiPolygon([
         [[QgsPoint(1, 1),
            QgsPoint(2, 2),
            QgsPoint(1, 2),
            QgsPoint(1, 1)]],
            [[QgsPoint(2, 2),
              QgsPoint(3, 3),
              QgsPoint(3, 1),
              QgsPoint(2, 2)]]
         ])
     myMessage = ('Expected:\n%s\nGot:\n%s\n' %
                   (QGis.WKBMultiPolygon, myMultiPolygon.type()))
     assert myMultiPolygon.wkbType() == QGis.WKBMultiPolygon, myMessage

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolygon [as 别名]
    def transform(self, meta_features, force_reduction_factor, geometry):
        """Transform the geometry based on the force reduction factor."""

        if geometry.isMultipart():
            geometries = []
            for polygon in geometry.asMultiPolygon():
                new_polygon = self.transform_polygon(polygon, meta_features,
                    force_reduction_factor)
                geometries.append(new_polygon)
            return QgsGeometry.fromMultiPolygon(geometries)
        else:
            polygon = geometry.asPolygon()
            new_polygon = self.transform_polygon(polygon, meta_features,
                force_reduction_factor)
            return QgsGeometry.fromPolygon(new_polygon)

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolygon [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 fromMultiPolygon [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 fromMultiPolygon [as 别名]
    def testMeasureMultiPolygon(self):
        # +-+-+ +-+-+
        # |   | |   |
        # + +-+ +-+ +
        # | |     | |
        # +-+     +-+
        polygon = QgsGeometry.fromMultiPolygon(
            [
                [[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), ]]
            ]
        )

        da = QgsDistanceArea()
        area = da.measureArea(polygon)
        assert area == 6, 'Expected:\n%f\nGot:\n%f\n' % (6, area)

        perimeter = da.measurePerimeter(polygon)
        assert perimeter == 16, "Expected:\n%f\nGot:\n%f\n" % (16, perimeter)

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolygon [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 fromMultiPolygon [as 别名]
    def __polygon_grid(self, feature, wkb_type):

        if feature.geometry().isMultipart():
            polygons = feature.geometry().asMultiPolygon()
            cleaned_polygons = list()
            for polygon in polygons:
                cleaned_polylines = list()
                for polyline in polygon:
                    snapped_points = self.__points_to_grid(polyline)
                    cleaned_polyline = snapped_points
                    cleaned_polylines.append(cleaned_polyline)
                cleaned_polygons.append(cleaned_polylines)
            geom = QgsGeometry.fromMultiPolygon([x for x in cleaned_polygons])
        else:
            polygon = feature.geometry().asPolygon()
            cleaned_polylines = list()
            for polyline in polygon:
                snapped_points = self.__points_to_grid(polyline)
                cleaned_polyline = snapped_points
                cleaned_polylines.append(cleaned_polyline)
            geom = QgsGeometry.fromPolyline(x for x in cleaned_polylines)

        return geom

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromMultiPolygon [as 别名]
    def makeQgsPolygon(self, xmin, ymin, xmax, ymax):
        """Creating a polygon for the given coordinates
        """
        dx = (xmax - xmin)/3
        dy = (ymax - ymin)/3
        
        polyline = []

        point = QgsPoint(xmin, ymin)
        polyline.append(point)
        point = QgsPoint(xmin+dx, ymin)
        polyline.append(point)
        point = QgsPoint(xmax-dx, ymin) 
        polyline.append(point)
        point = QgsPoint(xmax, ymin)
        polyline.append(point)
        point = QgsPoint(xmax, ymin+dy)
        polyline.append(point)
        point = QgsPoint(xmax, ymax-dy)
        polyline.append(point)
        point = QgsPoint(xmax, ymax)
        polyline.append(point)
        point = QgsPoint(xmax-dx, ymax)
        polyline.append(point)
        point = QgsPoint(xmin+dx, ymax)
        polyline.append(point)
        point = QgsPoint(xmin, ymax)
        polyline.append(point)
        point = QgsPoint(xmin, ymax-dy)
        polyline.append(point)
        point = QgsPoint(xmin, ymin+dy)
        polyline.append(point)
        point = QgsPoint(xmin, ymin)
        polyline.append(point)

        qgsPolygon = QgsGeometry.fromMultiPolygon([[polyline]])
        return qgsPolygon