Python QgsGeometry.fromWkb方法代码示例

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromWkb [as 别名]
    def unserialize(self, st):
        style = None
        orig_geom = None
        geom = None

        try:
            t = pickle.loads(st)
        except Exception as e:
            try:
                t = pickle.loads(st, encoding='utf-8')
                # strange, Exception says : No module named 'PyQt4'
            except Exception as e:
                for m in e.args:
                    QgsMessageLog.logMessage(str(m), 'Extensions')

                raise Exception("Mask - Error when loading mask")

        if len(t) == 12:  # older version
            (self.do_buffer,
             self.buffer_units,
             self.buffer_segments,
             self.do_simplify,
             self.simplify_tolerance,
             self.do_save_as,
             self.file_path,
             self.file_format,
             self.limited_layers_obsolete,
             style,
             self.polygon_mask_method,
             self.line_mask_method) = t
        else:
            (self.do_buffer,
             self.buffer_units,
             self.buffer_segments,
             self.do_simplify,
             self.simplify_tolerance,
             self.do_save_as,
             self.file_path,
             self.file_format,
             self.limited_layers_obsolete,
             style,
             self.polygon_mask_method,
             self.line_mask_method,
             orig_geom,
             geom
             ) = t
        self.style = None
        self.geometry = None
        if style is not None:
            self.style = style
        if geom is not None:
            self.geometry = QgsGeometry()
            self.geometry.fromWkb(geom)
        if orig_geom is not None:
            gl = []
            for g in orig_geom:
                geo = QgsGeometry()
                geo.fromWkb(g)
                gl.append(geo)
            self.orig_geometry = gl

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromWkb [as 别名]
    def ewkb2gqgis(self, ewkb):
        geom = QgsGeometry()

        geomType = int("0x" + self.decodeBinary(ewkb[2:10]), 0)
        if geomType & SRID_FLAG:
            ewkb = ewkb[:2] + self.encodeBinary(geomType ^ SRID_FLAG) + ewkb[18:]
        geom.fromWkb(binascii.a2b_hex(ewkb))
        return geom

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromWkb [as 别名]
 def wkb2qgis(self, wkb):
     geom = QgsGeometry()
     try:
         geomType = int("0x" + self.decodeBinary(wkb[2:10]), 0)
         if geomType & SRID_FLAG:
             wkb = wkb[:2] + self.encodeBinary(geomType ^ SRID_FLAG) + wkb[18:]
         geom.fromWkb(binascii.a2b_hex(wkb))
     except TypeError:
         pass
     return geom

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromWkb [as 别名]
    def find(self, to_find):
        if self.settings.value("qftsfilepath") == '':
            return
        if not self.isValid:
            self.message.emit("Cannot search in project. QuickFinder file is probably currently in use.",QgsMessageBar.WARNING)
            return
        # add star after each word except numbers
        to_find = to_find.split(' ')
        for i,word in enumerate(to_find):
            try:
                int(word)
            except ValueError:
                to_find[i] = '%s*' % word
        to_find = ' '.join(to_find)
        # FTS request
        sql = "SELECT search_id,content,x,y,wkb_geom FROM quickfinder_data WHERE content MATCH ?"
        cur = self.conn.cursor()

        catLimit = self.settings.value("categoryLimit")
        totalLimit = self.settings.value("totalLimit")
        catFound = {}
        for row in cur.execute(sql, [to_find]):
            search_id, content, x, y, wkb_geom = row
            if catFound.has_key(search_id):
                if catFound[search_id] >= catLimit:
                    continue
                catFound[search_id] += 1
            else:
                catFound[search_id] = 1

            if not self._searches.has_key(search_id):
                continue

            gs = self._searches[search_id].geometryStorage
            geometry = QgsGeometry()
            if gs == 'wkb':
                geometry.fromWkb(binascii.a2b_hex(wkb_geom))
            else:
                # wkt or extent are stored as wkt
                geometry = geometry.fromWkt(wkb_geom)

            crs = QgsCoordinateReferenceSystem()
            crs.createFromString(self._searches[search_id].srid)
            self.result_found.emit(self,
                                  self._searches[search_id].searchName,
                                  content,
                                  geometry,
                                  crs.postgisSrid())

            if sum(catFound.values()) >= totalLimit:
                break

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromWkb [as 别名]
    def find(self, toFind):
        if self.settings.value("qftsfilepath") == "":
            return
        if not self.isValid:
            self.message.emit(
                "Cannot search in project. QuickFinder file is probably currently in use.", QgsMessageBar.WARNING
            )
            return
        # add star after each word except numbers
        toFind = toFind.split(" ")
        for i, word in enumerate(toFind):
            try:
                int(word)
            except ValueError:
                toFind[i] = "%s*" % word
        toFind = " ".join(toFind)
        # FTS request
        sql = "SELECT search_id,content,x,y,wkb_geom FROM quickfinder_data WHERE content MATCH ?"
        cur = self.conn.cursor()
        cur.execute(sql, [toFind])
        catLimit = self.settings.value("categoryLimit")
        totalLimit = self.settings.value("totalLimit")
        nFound = 0
        catFound = {}
        while True:
            s = cur.fetchone()
            if s is None:
                return
            search_id, content, x, y, wkb_geom = s
            if catFound.has_key(search_id):
                if catFound[search_id] >= catLimit:
                    continue
                catFound[search_id] += 1
            else:
                catFound[search_id] = 1

            if not self._searches.has_key(search_id):
                continue

            geometry = QgsGeometry()
            geometry.fromWkb(binascii.a2b_hex(wkb_geom))

            crs = QgsCoordinateReferenceSystem()
            crs.createFromString(self._searches[search_id].srid)
            self.resultFound.emit(self, self._searches[search_id].searchName, content, geometry, crs.postgisSrid())

            nFound += 1
            if nFound >= totalLimit:
                break

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromWkb [as 别名]
    def find(self, toFind):
        if not self.isValid:
            return
        sql = "SELECT search_id,content,x,y,wkb_geom FROM quickfinder_data WHERE content MATCH ?"
        cur = self.conn.cursor()
        cur.execute(sql, [toFind])
        catLimit = self.settings.value("categoryLimit")
        totalLimit = self.settings.value("totalLimit")
        nFound = 0
        catFound = {}
        while True:
            s = cur.fetchone()
            if s is None:
                return
            search_id, content, x, y, wkb_geom = s
            if catFound.has_key(search_id):
                if catFound[search_id] >= catLimit:
                    continue
                catFound[search_id] += 1
            else:
                catFound[search_id] = 1

            if not self._searches.has_key(search_id):
                continue

            geometry = QgsGeometry()
            geometry.fromWkb(binascii.a2b_hex(wkb_geom))

            self.resultFound.emit(self,
                                  self._searches[search_id].searchName,
                                  content,
                                  geometry,
                                  self._searches[search_id].srid)

            nFound += 1
            if nFound >= totalLimit:
                break

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromWkb [as 别名]
def _wkbFromGml(tree, swap_xy, default_srs = None):
    # extract the srid
    srid = None
    srid_axis_swapped = False

    srs_name = _get_srs_name(tree)
    if srs_name is None and default_srs is not None:
        srid, srid_axis_swapped = _get_srid_from_name(default_srs)
    elif srs_name is not None:
        srid, srid_axis_swapped = _get_srid_from_name(srs_name)
    else:
        # No SRID found, force to 4326
        srid, srid_axis_swapped = 4326, True

	# inversion
    swap_xy = swap_xy ^ srid_axis_swapped
            
    # call ogr for GML parsing
    s = ET.tostring(tree, encoding="unicode")
    g = ogr.CreateGeometryFromGML(s)
    if g is None:
        return None

    wkb = g.ExportToWkb()
    if g.GetGeometryType() in (ogr.wkbPolyhedralSurface, ogr.wkbTIN):
        # Polyhedral and TIN are not supported by QGIS
        # So we convert them to multipolygon by poking the geometry type
        # It works only because the memory structure is the same
        wkb = wkb[:4] + b"\x06" + wkb[5:]

    qgsgeom = QgsGeometry()
    qgsgeom.fromWkb(wkb)

    if swap_xy:
        qgsgeom = _swap_qgs_geometry(qgsgeom)
    return qgsgeom, srid

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromWkb [as 别名]

#.........这里部分代码省略.........
             self.buffer_units,
             self.buffer_segments,
             self.do_simplify,
             self.simplify_tolerance,
             self.do_save_as,
             self.file_path,
             self.file_format,
             self.limited_layers_obsolete,
             style,
             self.polygon_mask_method,
             self.line_mask_method) = t
        else:
            (self.do_buffer,
             self.buffer_units,
             self.buffer_segments,
             self.do_simplify,
             self.simplify_tolerance,
             self.do_save_as,
             self.file_path,
             self.file_format,
             self.limited_layers_obsolete,
             style,
             self.polygon_mask_method,
             self.line_mask_method,
             orig_geom,
             geom
             ) = t
        self.style = None
        self.geometry = None
        if style is not None:
            self.style = style
        if geom is not None:
            self.geometry = QgsGeometry()
            self.geometry.fromWkb(geom)
        if orig_geom is not None:
            gl = []
            for g in orig_geom:
                geo = QgsGeometry()
                geo.fromWkb(g)
                gl.append(geo)
            self.orig_geometry = gl

    def have_same_layer_options(self, other):
        """ Returns true if the other parameters have the same layer options
           (file path, file format) than self
        """
        if not self.do_save_as:
            return not other.do_save_as
        else:
            if not other.do_save_as:
                return False
            else:
                return self.file_path == other.file_path and self.file_format == other.file_format

    def save_to_project(self):
        serialized = base64.b64encode(self.serialize())
        try:
            QgsProject.instance().writeEntry("Mask", "parameters", serialized)
        except:
            # strange behaviour, pickle change his format ?
            QgsProject.instance().writeEntry("Mask", "parameters", str(serialized)[2:-1])

        return True

    def load_from_project(self):
        st, ok = QgsProject.instance().readEntry("Mask", "parameters")

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromWkb [as 别名]
 def __qgPntFromShplyPnt(self, shapelyPnt):
     wkbPnt = dumps(shapelyPnt)
     qgGeom = QgsGeometry()
     qgGeom.fromWkb(wkbPnt)
     return qgGeom.asPoint()

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromWkb [as 别名]
 def addFeatures(self, layerid, features, fields, points=None, lines=None, polygons=None, permissions={}, add_empty=False, addToMap=True):
     """ Add DIVI layer to QGIS """
     qgis_fields = [ QgsField(field['key'], self.TYPES_MAP.get(field['type'], QVariant.String)) for field in fields ]
     #print (qgis_fields)
     #print (points, lines, polygons)
     if points is not None:
         points_pr = points.dataProvider()
         if points_pr.fields():
             points_pr.deleteAttributes(list(range(len(points_pr.fields()))))
         points_pr.addAttributes(qgis_fields)
         points.updateFields()
     if lines is not None:
         lines_pr = lines.dataProvider()
         if lines_pr.fields():
             lines_pr.deleteAttributes(list(range(len(lines_pr.fields()))))
         lines_pr.addAttributes(qgis_fields)
         lines.updateFields()
     if polygons is not None:
         polygons_pr = polygons.dataProvider()
         if polygons_pr.fields():
             polygons_pr.deleteAttributes(list(range(len(polygons_pr.fields()))))
         x = polygons_pr.addAttributes(qgis_fields)
         polygons.updateFields()
     #Lists of QGIS features
     points_list = []
     lines_list = []
     polygons_list = []
     count = float(len(features))
     points_ids = []
     lines_ids = []
     polygons_ids = []
     for i, feature in enumerate(features, start=1):
         #Geometria w formacie WKB zakodowanym przez base64
         geom = QgsGeometry()
         geom.fromWkb(b64decode(feature['geometry']))
         f = QgsFeature()
         f.setGeometry(geom)
         f.setAttributes([ feature['properties'].get(field['key']) for field in fields ])
         #Add feature to list by geometry type
         if geom.type() == QgsWkbTypes.PointGeometry:
             points_list.append(f)
             points_ids.append(feature['id'])
         elif geom.type() == QgsWkbTypes.LineGeometry:
             lines_list.append(f)
             lines_ids.append(feature['id'])
         elif geom.type() == QgsWkbTypes.PolygonGeometry:
             polygons_list.append(f)
             polygons_ids.append(feature['id'])
         else:
             continue
         if self.msgBar is not None:
             #self.msgBar.setProgress(i/count)
             pass
             QgsApplication.processEvents()
             if self.msgBar.aborted:
                 #Użytkownik anulował operację
                 return []
     #Add only layers that have features
     result = []
     register = partial(self.registerLayer, layerid=layerid, permissions=permissions,
         addToMap=addToMap, fields=fields)
     if points is not None and (points_list or add_empty):
         lyr, added = register(layer=points, features=points_list)
         result.append(lyr)
         self.ids_map[points.id()] = dict(list(zip(added, points_ids)))
     if lines is not None and (lines_list or add_empty):
         lyr, added = register(layer=lines, features=lines_list)
         result.append(lyr)
         self.ids_map[lines.id()] = dict(list(zip(added, lines_ids)))
     if polygons is not None and (polygons_list or add_empty):
         lyr, added = register(layer=polygons, features=polygons_list)
         result.append(lyr)
         self.ids_map[polygons.id()] = dict(list(zip(added, polygons_ids)))
     return result