Python QgsRectangle.setMinimal方法代码示例

# 需要导入模块: from qgis.core import QgsRectangle [as 别名]
# 或者: from qgis.core.QgsRectangle import setMinimal [as 别名]
    def add_resource(self):
        sel_index = self.trvResources.selectionModel().currentIndex()
        if sel_index.isValid():
            #extent for_zoom
            summary_extent = QgsRectangle()
            summary_extent.setMinimal()

            self.hide() #hack
            ngw_resource = sel_index.data(Qt.UserRole)
            if ngw_resource.common.cls == NGWFoclProject.type_id:
                for child in ngw_resource.get_children():
                    self._append_resource_to_map(child, ngw_resource, summary_extent)
            else:
                parent_resource = sel_index.parent().data(Qt.UserRole)
                self._append_resource_to_map(ngw_resource, parent_resource, summary_extent)

            self.zoom_to_extent(summary_extent)
            self.close()

# 需要导入模块: from qgis.core import QgsRectangle [as 别名]
# 或者: from qgis.core.QgsRectangle import setMinimal [as 别名]
def add_resource_as_wfs_layers(wfs_resource, return_extent=False):
    if not isinstance(wfs_resource, NGWWfsService):
        raise NGWError('Resource type is not WfsService!')
    #Extent stuff
    if return_extent:
        summary_extent = QgsRectangle()
        summary_extent.setMinimal()
    #Add group
    toc_root = QgsProject.instance().layerTreeRoot()
    layers_group = toc_root.insertGroup(0, wfs_resource.common.display_name)
    #Add layers
    for wfs_layer in wfs_resource.wfs.layers:
        url = wfs_resource.get_wfs_url(wfs_layer.keyname) + '&srsname=EPSG:3857&VERSION=1.0.0&REQUEST=GetFeature'
        qgs_wfs_layer = QgsVectorLayer(url, wfs_layer.display_name, 'WFS')
        #summarize extent
        if return_extent:
            _summ_extent(summary_extent, qgs_wfs_layer)
        QgsMapLayerRegistry.instance().addMapLayer(qgs_wfs_layer, False)
        layers_group.insertLayer(0, qgs_wfs_layer)

    if return_extent:
        return summary_extent

# 需要导入模块: from qgis.core import QgsRectangle [as 别名]
# 或者: from qgis.core.QgsRectangle import setMinimal [as 别名]
class PyProvider(QgsVectorDataProvider):

    next_feature_id = 1

    @classmethod
    def providerKey(cls):
        """Returns the memory provider key"""
        return 'pythonprovider'

    @classmethod
    def description(cls):
        """Returns the memory provider description"""
        return 'Python Test Provider'

    @classmethod
    def createProvider(cls, uri, providerOptions):
        return PyProvider(uri, providerOptions)

    # Implementation of functions from QgsVectorDataProvider

    def __init__(self, uri='', providerOptions=QgsDataProvider.ProviderOptions()):
        super().__init__(uri)
        # Use the memory layer to parse the uri
        mlayer = QgsVectorLayer(uri, 'ml', 'memory')
        self.setNativeTypes(mlayer.dataProvider().nativeTypes())
        self._uri = uri
        self._fields = mlayer.fields()
        self._wkbType = mlayer.wkbType()
        self._features = {}
        self._extent = QgsRectangle()
        self._extent.setMinimal()
        self._subset_string = ''
        self._crs = mlayer.crs()
        self._spatialindex = None
        self._provider_options = providerOptions
        if 'index=yes'in self._uri:
            self.createSpatialIndex()

    def featureSource(self):
        return PyFeatureSource(self)

    def dataSourceUri(self, expandAuthConfig=True):
        return self._uri

    def storageType(self):
        return "Python test memory storage"

    def getFeatures(self, request=QgsFeatureRequest()):
        return QgsFeatureIterator(PyFeatureIterator(PyFeatureSource(self), request))

    def uniqueValues(self, fieldIndex, limit=1):
        results = set()
        if fieldIndex >= 0 and fieldIndex < self.fields().count():
            req = QgsFeatureRequest()
            req.setFlags(QgsFeatureRequest.NoGeometry)
            req.setSubsetOfAttributes([fieldIndex])
            for f in self.getFeatures(req):
                results.add(f.attributes()[fieldIndex])
        return results

    def wkbType(self):
        return self._wkbType

    def featureCount(self):
        if not self.subsetString():
            return len(self._features)
        else:
            req = QgsFeatureRequest()
            req.setFlags(QgsFeatureRequest.NoGeometry)
            req.setSubsetOfAttributes([])
            return len([f for f in self.getFeatures(req)])

    def fields(self):
        return self._fields

    def addFeatures(self, flist, flags=None):
        added = False
        f_added = []
        for f in flist:
            if f.hasGeometry() and (f.geometry().wkbType() != self.wkbType()):
                return added, f_added

        for f in flist:
            _f = QgsFeature(self.fields())
            _f.setGeometry(f.geometry())
            attrs = [None for i in range(_f.fields().count())]
            for i in range(min(len(attrs), len(f.attributes()))):
                attrs[i] = f.attributes()[i]
            _f.setAttributes(attrs)
            _f.setId(self.next_feature_id)
            self._features[self.next_feature_id] = _f
            self.next_feature_id += 1
            added = True
            f_added.append(_f)

            if self._spatialindex is not None:
                self._spatialindex.insertFeature(_f)

        if len(f_added):
            self.clearMinMaxCache()
#.........这里部分代码省略.........

# 需要导入模块: from qgis.core import QgsRectangle [as 别名]
# 或者: from qgis.core.QgsRectangle import setMinimal [as 别名]
def qgis_composer_renderer(impact_report, component):
    """Default Map Report Renderer using QGIS Composer.

    Render using qgis composer for a given impact_report data and component
    context

    :param impact_report: ImpactReport contains data about the report that is
        going to be generated
    :type impact_report: safe.report.impact_report.ImpactReport

    :param component: Contains the component metadata and context for
        rendering the output
    :type component:
        safe.report.report_metadata.QgisComposerComponentsMetadata

    :return: whatever type of output the component should be

    .. versionadded:: 4.0
    """
    context = component.context
    """:type: safe.report.extractors.composer.QGISComposerContext"""
    qgis_composition_context = impact_report.qgis_composition_context
    inasafe_context = impact_report.inasafe_context

    # load composition object
    composition = QgsComposition(qgis_composition_context.map_settings)

    # load template
    main_template_folder = impact_report.metadata.template_folder
    template_path = os.path.join(main_template_folder, component.template)

    with open(template_path) as template_file:
        template_content = template_file.read()

    document = QtXml.QDomDocument()
    document.setContent(template_content)

    load_status = composition.loadFromTemplate(
        document, context.substitution_map)

    if not load_status:
        raise TemplateLoadingError(
            tr('Error loading template: %s') % template_path)

    # replace image path
    for img in context.image_elements:
        item_id = img.get('id')
        path = img.get('path')
        image = composition.getComposerItemById(item_id)
        """:type: qgis.core.QgsComposerPicture"""
        if image is not None and path is not None:
            try:
                image.setPicturePath(path)
            except:
                pass

    # replace html frame
    for html_el in context.html_frame_elements:
        item_id = html_el.get('id')
        mode = html_el.get('mode')
        html_element = composition.getComposerItemById(item_id)
        """:type: qgis.core.QgsComposerHtml"""
        if html_element:
            if mode == 'text':
                text = html_el.get('text')
                text = text if text else ''
                html_element.setContentMode(QgsComposerHtml.ManualHtml)
                html_element.setHtml(text)
                html_element.loadHtml()
            elif mode == 'url':
                url = html_el.get('url')
                html_element.setContentMode(QgsComposerHtml.Url)
                qurl = QUrl.fromLocalFile(url)
                html_element.setUrl(qurl)

    # resize map extent
    for map_el in context.map_elements:
        item_id = map_el.get('id')
        split_count = map_el.get('grid_split_count')
        layers = map_el.get('layers')
        map_extent_option = map_el.get('extent')
        composer_map = composition.getComposerItemById(item_id)
        """:type: qgis.core.QgsComposerMap"""
        if isinstance(composer_map, QgsComposerMap):
            composer_map.setKeepLayerSet(True)
            layer_set = [l.id() for l in layers if isinstance(l, QgsMapLayer)]
            composer_map.setLayerSet(layer_set)
            if map_extent_option and isinstance(
                    map_extent_option, QgsRectangle):
                # use provided map extent
                extent = map_extent_option
            else:
                # if map extent not provided, try to calculate extent
                # from list of given layers. Combine it so all layers were
                # shown properly
                extent = QgsRectangle()
                extent.setMinimal()
                for l in layers:
                    # combine extent if different layer is provided.
                    extent.combineExtentWith(l.extent())
#.........这里部分代码省略.........

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

#.........这里部分代码省略.........
                QgsProject.instance().addMapLayer(layer)

        """:type: qgis.core.QgsLayoutItemMap"""
        if composer_map:

            # Search for specified map extent in the template.
            min_x = composer_map.extent().xMinimum() if (
                impact_report.use_template_extent) else None
            min_y = composer_map.extent().yMinimum() if (
                impact_report.use_template_extent) else None
            max_x = composer_map.extent().xMaximum() if (
                impact_report.use_template_extent) else None
            max_y = composer_map.extent().yMaximum() if (
                impact_report.use_template_extent) else None

            composer_map.setKeepLayerSet(True)
            layer_set = [l for l in layers if isinstance(l, QgsMapLayer)]
            composer_map.setLayers(layer_set)
            map_overview_extent = None
            if map_extent_option and isinstance(
                    map_extent_option, QgsRectangle):
                # use provided map extent
                extent = coord_transform.transform(map_extent_option)
                for l in [layer for layer in layers if
                          isinstance(layer, QgsMapLayer)]:
                    layer_extent = coord_transform.transform(l.extent())
                    if l.name() == map_overview['id']:
                        map_overview_extent = layer_extent
            else:
                # if map extent not provided, try to calculate extent
                # from list of given layers. Combine it so all layers were
                # shown properly
                extent = QgsRectangle()
                extent.setMinimal()
                for l in [layer for layer in layers if
                          isinstance(layer, QgsMapLayer)]:
                    # combine extent if different layer is provided.
                    layer_extent = coord_transform.transform(l.extent())
                    extent.combineExtentWith(layer_extent)
                    if l.name() == map_overview['id']:
                        map_overview_extent = layer_extent

            width = extent.width()
            height = extent.height()
            longest_width = width if width > height else height
            half_length = longest_width / 2
            margin = half_length / 5
            center = extent.center()
            min_x = min_x or (center.x() - half_length - margin)
            max_x = max_x or (center.x() + half_length + margin)
            min_y = min_y or (center.y() - half_length - margin)
            max_y = max_y or (center.y() + half_length + margin)

            # noinspection PyCallingNonCallable
            square_extent = QgsRectangle(min_x, min_y, max_x, max_y)

            if component.key == 'population-infographic' and (
                    map_overview_extent):
                square_extent = map_overview_extent

            composer_map.zoomToExtent(square_extent)
            composer_map.invalidateCache()

            actual_extent = composer_map.extent()

            # calculate intervals for grid

# 需要导入模块: from qgis.core import QgsRectangle [as 别名]
# 或者: from qgis.core.QgsRectangle import setMinimal [as 别名]
 def init_layers(self, scenario):
     '''
     initialize the layers in layer-window for given scenario
     including adding groups and background-layers and setting the
     editability of the institutional layers
     '''
     if not scenario:
         return
     scen_group = get_group(scenario.name, add_at_index=0)
     # just for the right initial order
     get_group('Filter', scen_group)
     cat_group = get_group('Einrichtungen', scen_group)
     get_group('Erreichbarkeiten PKW', scen_group)
     get_group(u'Erreichbarkeiten ÖPNV')
     border_group = get_group('Verwaltungsgrenzen')
     self.add_wms_background_map(group=get_group('Hintergrundkarte',
                                                 add_at_index=-1))
     self.add_xml_background_map(GOOGLE_XML,
                                 group=get_group('Hintergrundkarte'),
                                 visible=False)
     
     for name, tablename in [('Gemeinden', 'gemeinden_20161231'),
                             ('Verwaltungsgemeinschaften', 'vwg_20161231'),
                             ('Kreise', 'kreis_20161231')]:
         border_style = self.borders[name]
         symbology = SimpleFillSymbology(border_style=border_style)
         self.add_db_layer(name, 'verwaltungsgrenzen', tablename,
                           'geom', group=border_group, visible=False,
                           symbology=symbology)
     
     self.canvas.refresh()
     
     ### SET THE EDITABILITY OF INSTITUTIONAL LAYER-FIELDS###
 
     columns = ['spalte', 'editierbar', 'nur_auswahl_zulassen',
                'auswahlmoeglichkeiten', 'alias', 'auto_vervollst',
                'typ', 'min', 'max']
     for category, filter_tree in self.categories.iteritems():
         table = filter_tree.tablename
         symbology = SimpleSymbology(self.colors[category])
         layer = self.add_db_layer(category, SCHEMA, table, 'geom_gk',
                                   symbology, group=cat_group, zoom=False,
                                   where='szenario_id={}'.format(scenario.id))
         rows = get_values('editierbare_spalten', columns,
                           self.db_conn, schema='einrichtungen',
                           where="tabelle='{}'".format(table),
                           order_by='reihenfolge')
         editable_columns = [r.spalte for r in rows]
         #if not rows:
             #continue
         for i, f in enumerate(layer.fields()):
             if f.name() == 'szenario_id':
                 layer.setEditorWidgetV2(i, 'Hidden')
                 layer.setDefaultValueExpression(i, str(scenario.id))
                 continue
             try:
                 idx = editable_columns.index(f.name())
             except:
                 layer.setEditorWidgetV2(i, 'Hidden')
                 continue
             col, is_ed, is_sel, selections, alias, auto_complete, typ, min_value, max_value = rows[idx]
             if alias:
                 layer.addAttributeAlias(i, alias) 
             if not is_ed:
                 layer.setEditorWidgetV2(i, 'Hidden')
                 continue
             # type range (integers)
             if typ == 'range':
                 layer.setEditorWidgetV2(i, 'Range')
                 layer.setEditorWidgetV2Config(
                     i, {'AllowNull': False,
                         'Min': min_value, 'Max': max_value})
             # auto complete: take all existing unique values of field,
             # text will can be auto completed to one of those in UI
             if auto_complete:
                 layer.setEditorWidgetV2(i, 'UniqueValues')
                 layer.setEditorWidgetV2Config(i, {u'Editable': True})
             # selectable values are predefined in database
             elif is_sel and selections:
                 layer.setEditorWidgetV2(i, 'ValueMap')
                 sel = []
                 for s in selections:
                     try:
                         s = s.decode('utf-8')
                     except:
                         pass
                     sel.append(s)
                 d = dict([(s, s) for s in sel])
                 layer.setEditorWidgetV2Config(i, d)
             elif is_sel:
                 layer.setEditorWidgetV2(i, 'UniqueValues')
     # zoom to extent
     extent = QgsRectangle()
     extent.setMinimal()
     for child in cat_group.children():
         if isinstance(child, QgsLayerTreeLayer):
             #print child.layer().extent()
             extent.combineExtentWith(child.layer().extent())
     self.canvas.setExtent(extent)
     self.canvas.refresh()