Exemple #1
0
def buffering(progress, writer, distance, field, useField, layer, dissolve,
              segments):

    if useField:
        field = layer.fieldNameIndex(field)

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

    current = 0
    features = vector.features(layer)
    total = 100.0 / float(len(features))

    # With dissolve
    if dissolve:
        first = True
        for inFeat in features:
            attrs = inFeat.attributes()
            if useField:
                value = attrs[field]
            else:
                value = distance

            inGeom = QgsGeometry(inFeat.geometry())
            outGeom = inGeom.buffer(float(value), segments)
            if first:
                tempGeom = QgsGeometry(outGeom)
                first = False
            else:
                tempGeom = tempGeom.combine(outGeom)

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

        outFeat.setGeometry(tempGeom)
        outFeat.setAttributes(attrs)
        writer.addFeature(outFeat)
    else:
        # Without dissolve
        for inFeat in features:
            attrs = inFeat.attributes()
            if useField:
                value = attrs[field]
            else:
                value = distance
            inGeom = QgsGeometry(inFeat.geometry())
            outGeom = inGeom.buffer(float(value), segments)
            outFeat.setGeometry(outGeom)
            outFeat.setAttributes(attrs)
            writer.addFeature(outFeat)
            current += 1
            progress.setPercentage(int(current * total))

    del writer
Exemple #2
0
    def mask_geometry(self):
        if not self.parameters.geometry:
            geom = QgsGeometry()
            return geom, QgsRectangle()

        geom = QgsGeometry(self.parameters.geometry)  # COPY !!

        if self.parameters.do_simplify:
            if hasattr(self.canvas, 'mapSettings'):
                tol = self.parameters.simplify_tolerance * \
                    self.canvas.mapSettings().mapUnitsPerPixel()
            else:
                tol = self.parameters.simplify_tolerance * \
                    self.canvas.mapRenderer().mapUnitsPerPixel()

            if tol in list(self.simplified_geometries.keys()):
                geom, bbox = self.simplified_geometries[tol]
            else:
                if self.has_simplifier:
                    simplifier = QgsMapToPixelSimplifier(QgsMapToPixelSimplifier.SimplifyGeometry,
                                                         tol)
                    geom = simplifier.simplify(geom)
                    if not geom.isGeosValid():
                        # make valid
                        geom = geom.buffer(0.0, 1)
                bbox = geom.boundingBox()
                self.simplified_geometries[tol] = (QgsGeometry(geom), QgsRectangle(bbox))
        else:
            bbox = geom.boundingBox()

        return geom, bbox
Exemple #3
0
 def vectorRandom(self, n, layer, xmin, xmax, ymin, ymax):
     provider = layer.dataProvider()
     index = ftools_utils.createIndex(provider)
     seed()
     points = []
     feat = QgsFeature()
     i = 1
     count = 40.00
     add = (70.00 - 40.00) / n
     while i <= n:
         point = QgsPoint(xmin + (xmax - xmin) * random(),
                          ymin + (ymax - ymin) * random())
         pGeom = QgsGeometry().fromPoint(point)
         ids = index.intersects(pGeom.buffer(5, 5).boundingBox())
         for id in ids:
             provider.getFeatures(QgsFeatureRequest().setFilterFid(
                 int(id))).nextFeature(feat)
             tGeom = QgsGeometry(feat.geometry())
             if pGeom.intersects(tGeom):
                 points.append(pGeom)
                 i = i + 1
                 count = count + add
                 self.progressBar.setValue(count)
                 break
     return points
Exemple #4
0
    def mask_geometry(self):
        if not self.parameters.geometry:
            geom = QgsGeometry()
            return geom, QgsRectangle()

        geom = QgsGeometry(self.parameters.geometry)  # COPY !!

        if self.parameters.do_simplify:
            if hasattr(self.canvas, "mapSettings"):
                tol = (self.parameters.simplify_tolerance *
                       self.canvas.mapSettings().mapUnitsPerPixel())
            else:
                tol = (self.parameters.simplify_tolerance *
                       self.canvas.mapRenderer().mapUnitsPerPixel())

            if tol in list(self.simplified_geometries.keys()):
                geom, bbox = self.simplified_geometries[tol]
            else:
                if self.has_simplifier:
                    simplifier = QgsMapToPixelSimplifier(
                        QgsMapToPixelSimplifier.SimplifyGeometry, tol)
                    geom = simplifier.simplify(geom)
                    if not geom.isGeosValid():
                        # make valid
                        geom = geom.buffer(0.0, 1)
                bbox = geom.boundingBox()
                self.simplified_geometries[tol] = (
                    QgsGeometry(geom),
                    QgsRectangle(bbox),
                )
        else:
            bbox = geom.boundingBox()

        return geom, bbox
    def createFeatureRequestForSelectedFeatures(self, layer, layerInfo):
        featureRequest = None

        transform = None
        selectedTargetLayerCRS = self.selectedTargetLayer.sourceCrs()
        if layer.sourceCrs() != selectedTargetLayerCRS:
            transform = QgsCoordinateTransform(selectedTargetLayerCRS,
                                               layer.sourceCrs(),
                                               QgsProject.instance())

        features = self.selectedTargetLayer.selectedFeatures()

        maxSearchDistance = self.dialogAddSourceDataLinks.spinBoxMaxSearchDistance.value(
        )

        xMin = None
        yMin = None
        xMax = None
        yMax = None

        for feature in features:
            geom = feature.geometry()

            if not geom.isNull():
                transformedSourceGeom = None
                if transform is not None:
                    transformedGeom = QgsGeometry(geom)
                    transformedGeom.transform(transform)
                else:
                    transformedGeom = QgsGeometry(geom)

                bufferGeom = transformedGeom.buffer(maxSearchDistance, 5)
                bbox = bufferGeom.boundingBox()
                if xMin is None or bbox.xMinimum() < xMin:
                    xMin = bbox.xMinimum()
                if yMin is None or bbox.yMinimum() < yMin:
                    yMin = bbox.yMinimum()
                if xMax is None or bbox.xMaximum() > xMax:
                    xMax = bbox.xMaximum()
                if yMax is None or bbox.yMaximum() < yMax:
                    yMax = bbox.yMaximum()

        # QgsMessageLog.logMessage('createFeatureRequestForSelectedFeatures - xMin: ' + str(xMin) + ", yMin: " + str(yMin) + ", xMax: " + str(xMax) + ", yMax: " + str(yMax), 'Yleiskaava-työkalu', Qgis.Info)

        if xMin is not None and yMin is not None and xMax is not None and yMax is not None:
            bboxAllFeatures = QgsRectangle(xMin, yMin, xMax, yMax)
            featureRequest = QgsFeatureRequest().setFilterRect(bboxAllFeatures)
            # featureRequest = QgsFeatureRequest().setFilterRect(bboxAllFeatures).setFlags(QgsFeatureRequest.NoGeometry)
            # featureRequest = QgsFeatureRequest().setFilterRect(bboxAllFeatures).setFlags(QgsFeatureRequest.NoGeometry).setSubsetOfAttributes([layerInfo["nimi"], layerInfo["linkki_data"]], layer.fields())

        return featureRequest
Exemple #6
0
    def compute_mask_geometries(self, parameters, poly):
        geom = None
        for g in poly:
            if geom is None:
                geom = QgsGeometry(g)
            else:
                # do an union here
                geom = geom.combine(g)

        if parameters.do_buffer:
            geom = geom.buffer(parameters.buffer_units, parameters.buffer_segments)

        # reset the simplified geometries dict
        self.simplified_geometries = {}

        return geom
Exemple #7
0
    def compute_mask_geometries(self, parameters, poly):
        geom = None
        for g in poly:
            if geom is None:
                geom = QgsGeometry(g)
            else:
                # do an union here
                geom = geom.combine(g)

        if parameters.do_buffer:
            geom = geom.buffer(parameters.buffer_units,
                               parameters.buffer_segments)

        # reset the simplified geometries dict
        self.simplified_geometries = {}

        return geom
Exemple #8
0
 def vectorRandom(self, n, layer, xmin, xmax, ymin, ymax):
     provider = layer.dataProvider()
     index = ftools_utils.createIndex(provider)
     seed()
     points = []
     feat = QgsFeature()
     i = 1
     count = 40.00
     add = ( 70.00 - 40.00 ) / n
     while i <= n:
         point = QgsPoint(xmin + (xmax-xmin) * random(), ymin + (ymax-ymin) * random())
         pGeom = QgsGeometry().fromPoint(point)
         ids = index.intersects(pGeom.buffer(5,5).boundingBox())
         for id in ids:
             provider.getFeatures( QgsFeatureRequest().setFilterFid( int(id) ) ).nextFeature( feat )
             tGeom = QgsGeometry(feat.geometry())
             if pGeom.intersects(tGeom):
                 points.append(pGeom)
                 i = i + 1
                 count = count + add
                 self.progressBar.setValue(count)
                 break
     return points
Exemple #9
0
    def run(self):
        """Run method that performs all the real work"""

        # Create the dialog with elements (after translation) and keep reference
        # Only create GUI ONCE in callback, so that it will only load when the plugin is started
        if self.first_start == True:
            self.first_start = False
            self.dlg = NewRaptorDialog()
            self.dlg.cmbSpecies.currentTextChanged.connect(
                self.evt_cmbSpecies_changed)

        QMessageBox.information(self.dlg, "Message", "Should run every time")
        # get coordinates from center of mapCanvas
        mc = self.iface.mapCanvas()
        self.dlg.spbLatitude.setValue(mc.center().y())
        self.dlg.spbLongitude.setValue(mc.center().x())

        # set current date in the dialog
        self.dlg.dteLast.setDate(QDate.currentDate())

        # check if layer in which we want write data to exists
        # first create list of layers that exist in project
        map_layers = []
        for lyr in mc.layers():
            map_layers.append(lyr.name())
        QMessageBox.information(self.dlg, "Layers", str(map_layers))

        # check for layers that are necessary to run plugin in list above, if they don't exist inform user about it
        missing_layers = []
        if not "Raptor Nests" in map_layers:
            missing_layers.append("Raptor Nests")
        if not "Raptor Buffer" in map_layers:
            missing_layers.append("Raptor Nests")
        if not "Linear Buffer" in map_layers:
            missing_layers.append("Linear Buffer")
        if missing_layers:
            msg = "The follwoing layers are missing from this project\n"
            for lyr in missing_layers:
                msg += "\n{}".format(lyr)
            QMessageBox.critical(self.dlg, "Missing layers", msg)
            # stop execution of method by ending it with return
            return

        # show the dialog
        self.dlg.show()
        # Run the dialog event loop
        result = self.dlg.exec_()
        # See if OK was pressed
        if result:
            # Do something useful here - delete the line containing pass and
            # substitute with your code.
            #             QMessageBox.information(self.dlg, "Message", "Should run if OK button clicked")

            #create reference to nests table
            lyrNests = QgsProject.instance().mapLayersByName("Raptor Nests")[0]
            lyrBuffer = QgsProject.instance().mapLayersByName(
                "Raptor Buffer")[0]

            #create reference to linear buffer table
            lyrLinear = QgsProject.instance().mapLayersByName(
                "Linear Buffer")[0]
            #get maximum value of ide to increment it properly
            idxNestID = lyrNests.fields().indexOf("Nest_ID")
            valNestID = lyrNests.maximumValue(idxNestID) + 1
            valLat = self.dlg.spbLatitude.value()
            valLng = self.dlg.spbLongitude.value()
            valSpecies = self.dlg.cmbSpecies.currentText()
            valBuffer = self.dlg.spbBuffer.value()
            valStatus = self.dlg.cmbStatus.currentText()
            valLast = self.dlg.dteLast.date()
            QMessageBox.information(
                self.dlg, "Message",
                "New Nest ID: {}\n\nLatitude: {}\nLongitude: {}\nSpecies: {}\nBuffer: {}\nStatus: {}\nLast Survey: {}"
                .format(valNestID, valLat, valLng, valSpecies, valBuffer,
                        valStatus, valLast))

            #create new feature based on Nests layer
            ftrNest = QgsFeature(lyrNests.fields())
            ftrNest.setAttribute("lat_y_dd", valLat)
            ftrNest.setAttribute("long_x_dd", valLng)
            ftrNest.setAttribute("recentspec", valSpecies)
            ftrNest.setAttribute("buf_dist", valBuffer)
            ftrNest.setAttribute("recentstat", valStatus)
            ftrNest.setAttribute("lastsurvey", valLast)
            ftrNest.setAttribute("Nest_ID", valNestID)
            geom = QgsGeometry(QgsPoint(valLng, valLat))
            ftrNest.setGeometry(geom)

            #insert feature into layer, using data provider
            pr = lyrNests.dataProvider()
            pr.addFeatures([ftrNest])
            lyrNests.reload()

            #code to insert the buffer
            pr = lyrBuffer.dataProvider()
            buffer = geom.buffer(valBuffer, 10)
            ftrNest.setGeometry(buffer)
            pr.addFeatures([ftrNest])
            lyrBuffer.reload()

            #code to popup table from impact_table.ui
            dlgTable = DlgTable()
            dlgTable.setWindowTitle(
                "Impacts Table for Nest{}".format(valNestID))

            #create bounding box to limit selection and improve algorithm speed
            bb = buffer.boundingBox()

            #Find linear projects that will be impacted and report
            linears = lyrLinear.getFeatures(bb)
            for linear in linears:
                valID = linear.attribute("Project")
                valType = linear.attribute("type")
                #return distance beetween linear buffer and the nest
                valDistance = linear.geometry().distance(geom)
                if valDistance < valBuffer:
                    #Populate table with linear data
                    row = dlgTable.tblImpacts.rowCount()
                    dlgTable.tblImpacts.insertRow(row)
                    dlgTable.tblImpacts.setItem(row, 0,
                                                QTableWidgetItem(str(valID)))
                    dlgTable.tblImpacts.setItem(row, 1,
                                                QTableWidgetItem(valType))
                    twi = QTableWidgetItem(str("{:4.5f}".format(valDistance)))
                    twi.setTextAlignment(QtCore.Qt.AlignRight)
                    dlgTable.tblImpacts.setItem(row, 2, twi)
                    #sort data in table
                    dlgTable.tblImpacts.sortItems(2)
            dlgTable.show()
            dlgTable.exec_()

        else:
            QMessageBox.information(self.dlg, "Message",
                                    "Should only run if cancelled")
Exemple #10
0
def multi_buffering(layer, radii, callback=None):
    """Buffer a vector layer using many buffers (for volcanoes or rivers).

    This processing algorithm will keep the original attribute table and
    will add a new one for the hazard class name according to
    safe.definitions.fields.hazard_value_field.

    radii = OrderedDict()
    radii[500] = 'high'
    radii[1000] = 'medium'
    radii[2000] = 'low'

    Issue https://github.com/inasafe/inasafe/issues/3185

    :param layer: The layer to polygonize.
    :type layer: QgsVectorLayer

    :param radii: A dictionary of radius.
    :type radii: OrderedDict

    :param callback: A function to all to indicate progress. The function
        should accept params 'current' (int), 'maximum' (int) and 'step' (str).
        Defaults to None.
    :type callback: function

    :return: The buffered vector layer.
    :rtype: QgsVectorLayer
    """
    # Layer output
    output_layer_name = buffer_steps['output_layer_name']
    processing_step = buffer_steps['step_name']

    input_crs = layer.crs()
    feature_count = layer.featureCount()

    fields = layer.fields()
    # Set the new hazard class field.
    new_field = create_field_from_definition(hazard_class_field)
    fields.append(new_field)
    # Set the new buffer distances field.
    new_field = create_field_from_definition(buffer_distance_field)
    fields.append(new_field)

    buffered = create_memory_layer(
        output_layer_name, QGis.Polygon, input_crs, fields)
    data_provider = buffered.dataProvider()

    # Reproject features if needed into UTM if the layer is in 4326.
    if layer.crs().authid() == 'EPSG:4326':
        center = layer.extent().center()
        utm = QgsCoordinateReferenceSystem(
            get_utm_epsg(center.x(), center.y(), input_crs))
        transform = QgsCoordinateTransform(layer.crs(), utm)
        reverse_transform = QgsCoordinateTransform(utm, layer.crs())
    else:
        transform = None
        reverse_transform = None

    for i, feature in enumerate(layer.getFeatures()):
        geom = QgsGeometry(feature.geometry())

        if transform:
            geom.transform(transform)

        inner_ring = None

        for radius in radii:
            attributes = feature.attributes()

            # We add the hazard value name to the attribute table.
            attributes.append(radii[radius])
            # We add the value of buffer distance to the attribute table.
            attributes.append(radius)

            circle = geom.buffer(radius, 30)

            if inner_ring:
                circle.addRing(inner_ring)

            inner_ring = circle.asPolygon()[0]

            new_feature = QgsFeature()
            if reverse_transform:
                circle.transform(reverse_transform)

            new_feature.setGeometry(circle)
            new_feature.setAttributes(attributes)

            data_provider.addFeatures([new_feature])

        if callback:
            callback(current=i, maximum=feature_count, step=processing_step)

    # We transfer keywords to the output.
    buffered.keywords = layer.keywords
    buffered.keywords['layer_geometry'] = 'polygon'
    buffered.keywords['layer_purpose'] = layer_purpose_hazard['key']
    buffered.keywords['inasafe_fields'][hazard_class_field['key']] = (
        hazard_class_field['field_name'])

    check_layer(buffered)
    return buffered
Exemple #11
0
    def in_mask(self, feature, srid=None):
        if feature is None:  # expression overview
            return False

        if self.layer is None:
            return False

        try:
            # layer is not None but destroyed ?
            self.layer.id()
        except:
            self.reset_mask_layer()
            return False

        # mask layer empty due to unloaded memlayersaver plugin > no filtering
        if self.layer.featureCount() == 0:
            return True

        mask_geom, bbox = self.mask_geometry()
        geom = QgsGeometry(feature.geometry())
        if not geom.isGeosValid():
            geom = geom.buffer(0.0, 1)

        if geom is None:
            return False

        if srid is not None and self.layer.crs().postgisSrid() != srid:
            src_crs = QgsCoordinateReferenceSystem(srid)
            dest_crs = self.layer.crs()
            xform = QgsCoordinateTransform(src_crs, dest_crs,
                                           QgsProject.instance())
            try:
                geom.transform(xform)

            except Exception as e:
                for m in e.args:
                    QgsMessageLog.logMessage("in_mask - {}".format(m),
                                             "Extensions")
                    # transformation error. Check layer projection.
                    pass

        if geom.type() == QgsWkbTypes.PolygonGeometry:
            if (self.parameters.polygon_mask_method == 2
                    and not self.has_point_on_surface):
                self.parameters.polygon_mask_method = 1

            if self.parameters.polygon_mask_method == 0:
                # this method can only work when no geometry simplification is involved
                return mask_geom.overlaps(geom) or mask_geom.contains(geom)
            elif self.parameters.polygon_mask_method == 1:
                # the fastest method, but with possible inaccuracies
                pt = geom.vertexAt(0)
                return bbox.contains(QgsPointXY(pt)) and mask_geom.contains(
                    geom.centroid())
            elif self.parameters.polygon_mask_method == 2:
                # will always work
                pt = geom.vertexAt(0)
                return bbox.contains(QgsPointXY(pt)) and mask_geom.contains(
                    geom.pointOnSurface())
            else:
                return False
        elif geom.type() == QgsWkbTypes.LineGeometry:
            if self.parameters.line_mask_method == 0:
                return mask_geom.intersects(geom)
            elif self.parameters.line_mask_method == 1:
                return mask_geom.contains(geom)
            else:
                return False
        elif geom.type() == QgsWkbTypes.PointGeometry:
            return mask_geom.intersects(geom)
        else:
            return False
Exemple #12
0
    def run(self):
        """Run method that performs all the real work"""

        # Create the dialog with elements (after translation) and keep reference
        # Only create GUI ONCE in callback, so that it will only load when the plugin is started
        if self.first_start == True:
            self.first_start = False
            self.dlg = NewRaptorDialog()

            #
            self.dlg.cmbSpecies.currentTextChanged.connect(
                self.evt_cmbSpecies_changed)

        mc = self.iface.mapCanvas()

        self.dlg.spbLatitude.setValue(mc.center().y())
        self.dlg.spbLongitude.setValue(mc.center().x())
        self.dlg.dteLast.setDate(QDate.currentDate())

        # Lista de camada do mapa
        map_layers = []
        for lyr in mc.layers():
            map_layers.append(lyr.name())

        # Coloca o nome dos layrs em uma caixa de mensagem, com o titulo camadas
        #QMessageBox.information(self.dlg, "Layers", str(map_layers))

        # cria uma caixa de mensagem caso não achar alguams das layrs descritas abaixo
        missing_layers = []
        if not 'Raptor Nests' in map_layers:
            missing_layers.append('Raptor Nests')
        if not 'Raptor Buffer' in map_layers:
            missing_layers.append('Raptor Buffer')
        if not 'Linear Buffer' in map_layers:
            missing_layers.append('Linear Buffer')

        if missing_layers:
            msg = 'The following layres are missing from ths project\n'
            for lyr in missing_layers:
                msg += f'\n {lyr}'
            QMessageBox.critical(self.dlg, 'Missing layers', msg)
            # o return barra a execução das demais linhas de códigos
            return

        # show the dialog
        self.dlg.show()
        # Run the dialog event loop
        result = self.dlg.exec_()
        # See if OK was pressed
        if result:
            # Do something useful here - delete the line containing pass and
            # substitute with your code.

            # irá retornar uma lista com o as camdas com nome Raptor Nests, mas iremos pegar apenas a primeira camadd
            lyrNests = QgsProject.instance().mapLayersByName('Raptor Nests')[0]
            lyrBuffer = QgsProject.instance().mapLayersByName(
                'Raptor Buffer')[0]
            lyrLinear = QgsProject.instance().mapLayersByName(
                'Linear Buffer')[0]
            # Irá pegar o ultimo valor de índice
            idxNestID = lyrNests.fields().indexOf('Nest_ID')
            valNestID = lyrNests.maximumValue(idxNestID) + 1

            # Irá pegar os valores que foram digitados na caixa de texto
            valLat = self.dlg.spbLatitude.value()
            valLng = self.dlg.spbLongitude.value()
            valSpecies = self.dlg.cmbSpecies.currentText()
            valBuffer = self.dlg.spbBuffer.value()
            valStatus = self.dlg.cmbStatus.currentText()
            valLast = self.dlg.dteLast.date()
            QMessageBox.information(
                self.dlg, 'Message',
                f'New Nest ID: {valNestID}\n \nLatitude: {valLat} '
                f'\nLongitude: {valLng} \nSpecies: {valSpecies} '
                f'\nBuffer: {valBuffer} \nStatus: {valStatus} \nLast: {valLast}'
            )
            # cria um novo objeto da classe QgsFeature, no qual a classe terá os mesmoa campos do lyrnet.fildes
            # (objeto da Layer Raptor Nests)
            ftrNest = QgsFeature(lyrNests.fields())
            # Irá começar a adicoanr atributos de acordo com o nome dos campos da layer Raptor Nests
            ftrNest.setAttribute('lat_y_dd', valLat)
            ftrNest.setAttribute('long_x_dd', valLng)
            ftrNest.setAttribute('recentspec', valSpecies)
            ftrNest.setAttribute('buf_dist', valBuffer)
            ftrNest.setAttribute('recentstat', valStatus)
            ftrNest.setAttribute('lastsurvey', valLast)
            ftrNest.setAttribute('Nest_ID', valNestID)

            # colcoando o tipo de geometria
            geom = QgsGeometry(QgsPoint(valLng, valLat))
            ftrNest.setGeometry(geom)

            # Cada tipo de dados pode ter um provedor diferente, o qgis tem extensões para varios tipos de provedor,
            # a função abaixo pega o provedor e inclui os dados de acordo com o proveor
            pr = lyrNests.dataProvider()
            pr.addFeatures([ftrNest])
            lyrNests.reload()

            # Adiconando a camada de buffer
            pr = lyrBuffer.dataProvider()
            buffer = geom.buffer(valBuffer, 10)
            ftrNest.setGeometry(buffer)
            pr.addFeatures([ftrNest])
            lyrBuffer.reload()

            dlgTable = DlgTable()
            dlgTable.setWindowTitle(f"Impacts Table for Nest {valNestID}")

            # Find linear projects that will impacted and report then in the table
            bb = buffer.boundingBox()
            linears = lyrLinear.getFeatures(bb)
            for linear in linears:
                valID = linear.attribute('Project')
                valType = linear.attribute('type')
                valDistance = linear.geometry().distance(geom)
                if valDistance < valBuffer:
                    #populate table with Linear data
                    row = dlgTable.tblImpacts.rowCount()
                    dlgTable.tblImpacts.insertRow(row)
                    dlgTable.tblImpacts.setItem(row, 0,
                                                QTableWidgetItem(str(valID)))
                    dlgTable.tblImpacts.setItem(row, 1,
                                                QTableWidgetItem(valType))
                    twi = QTableWidgetItem(f"{valDistance:4.5f}")
                    twi.setTextAlignment(QtCore.Qt.AlignRight)
                    dlgTable.tblImpacts.setItem(row, 2, twi)

            dlgTable.tblImpacts.sortItems(2)
            dlgTable.show()
            dlgTable.exec_()

        else:
            QMessageBox.information(self.dlg, "Message",
                                    "Should only run if cancelled")
Exemple #13
0
    def compute(self, inName, joinName, outName, summary, sumList, keep,
                progressBar):
        layer1 = ftools_utils.getVectorLayerByName(inName)
        provider1 = layer1.dataProvider()
        fieldList1 = ftools_utils.getFieldList(layer1)

        layer2 = ftools_utils.getVectorLayerByName(joinName)
        provider2 = layer2.dataProvider()

        fieldList2 = ftools_utils.getFieldList(layer2)
        fieldList = QgsFields()
        if provider1.crs() != provider2.crs():
            QMessageBox.warning(
                self, self.tr("CRS warning!"),
                self.
                tr("Warning: Input layers have non-matching CRS.\nThis may cause unexpected results."
                   ))
        if not summary:
            fieldList2 = ftools_utils.testForUniqueness(fieldList1, fieldList2)
            seq = range(0, len(fieldList1) + len(fieldList2))
            fieldList1.extend(fieldList2)
            fieldList1 = dict(zip(seq, fieldList1))
        else:
            numFields = {}
            for j in xrange(len(fieldList2)):
                if fieldList2[j].type() == QVariant.Int or fieldList2[j].type(
                ) == QVariant.Double:
                    numFields[j] = []
                    for i in sumList:
                        field = QgsField(i + unicode(fieldList2[j].name()),
                                         QVariant.Double, "real", 24, 16,
                                         self.tr("Summary field"))
                        fieldList.append(field)
            field = QgsField("COUNT", QVariant.Double, "real", 24, 16,
                             self.tr("Summary field"))
            fieldList.append(field)
            fieldList2 = ftools_utils.testForUniqueness(fieldList1, fieldList)
            fieldList1.extend(fieldList)
            seq = range(0, len(fieldList1))
            fieldList1 = dict(zip(seq, fieldList1))

        sRs = provider1.crs()
        progressBar.setValue(13)
        check = QFile(self.shapefileName)
        if check.exists():
            if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName):
                QMessageBox.warning(
                    self, self.tr('Error deleting shapefile'),
                    self.tr("Can't delete existing shapefile\n%s") %
                    (self.shapefileName))
                return False
        fields = QgsFields()
        for f in fieldList1.values():
            fields.append(f)
        writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fields,
                                     provider1.geometryType(), sRs)
        #writer = QgsVectorFileWriter(outName, "UTF-8", fieldList1, provider1.geometryType(), sRs)
        inFeat = QgsFeature()
        outFeat = QgsFeature()
        inFeatB = QgsFeature()
        inGeom = QgsGeometry()
        progressBar.setValue(15)
        start = 15.00
        add = 85.00 / provider1.featureCount()

        index = ftools_utils.createIndex(provider2)

        # cache all features from provider2 to avoid huge number of feature requests in the inner loop
        mapP2 = {}
        for f in provider2.getFeatures():
            mapP2[f.id()] = QgsFeature(f)

        fit1 = provider1.getFeatures()
        while fit1.nextFeature(inFeat):
            inGeom = inFeat.geometry()
            atMap1 = inFeat.attributes()
            outFeat.setGeometry(inGeom)
            none = True
            joinList = []
            if inGeom.type() == QGis.Point:
                #(check, joinList) = layer2.featuresInRectangle(inGeom.buffer(10,2).boundingBox(), True, True)
                #layer2.select(inGeom.buffer(10,2).boundingBox(), False)
                #joinList = layer2.selectedFeatures()
                joinList = index.intersects(inGeom.buffer(10, 2).boundingBox())
                if len(joinList) > 0:
                    check = 0
                else:
                    check = 1
            else:
                #(check, joinList) = layer2.featuresInRectangle(inGeom.boundingBox(), True, True)
                #layer2.select(inGeom.boundingBox(), False)
                #joinList = layer2.selectedFeatures()
                joinList = index.intersects(inGeom.boundingBox())
                if len(joinList) > 0:
                    check = 0
                else:
                    check = 1
            if check == 0:
                count = 0
                for i in joinList:
                    inFeatB = mapP2[i]  # cached feature from provider2
                    if inGeom.intersects(inFeatB.geometry()):
                        count = count + 1
                        none = False
                        atMap2 = inFeatB.attributes()
                        if not summary:
                            atMap = atMap1
                            atMap2 = atMap2
                            atMap.extend(atMap2)
                            atMap = dict(zip(seq, atMap))
                            break
                        else:
                            for j in numFields.keys():
                                numFields[j].append(atMap2[j])
                if summary and not none:
                    atMap = atMap1
                    for j in numFields.keys():
                        for k in sumList:
                            if k == "SUM":
                                atMap.append(sum(filter_null(numFields[j])))
                            elif k == "MEAN":
                                try:
                                    nn_count = sum(
                                        1 for _ in filter_null(numFields[j]))
                                    atMap.append(
                                        sum(filter_null(numFields[j])) /
                                        nn_count)
                                except ZeroDivisionError:
                                    atMap.append(NULL)
                            elif k == "MIN":
                                try:
                                    atMap.append(min(filter_null(
                                        numFields[j])))
                                except ValueError:
                                    atMap.append(NULL)
                            elif k == "MED":
                                atMap.append(myself(numFields[j]))
                            else:
                                try:
                                    atMap.append(max(filter_null(
                                        numFields[j])))
                                except ValueError:
                                    atMap.append(NULL)

                        numFields[j] = []
                    atMap.append(count)
                    atMap = dict(zip(seq, atMap))
            if none:
                outFeat.setAttributes(atMap1)
            else:
                outFeat.setAttributes(atMap.values())
            if keep:  # keep all records
                writer.addFeature(outFeat)
            else:  # keep only matching records
                if not none:
                    writer.addFeature(outFeat)
            start = start + add
            progressBar.setValue(start)
        del writer
        return True
Exemple #14
0
    def processAlgorithm(self, progress):
        target = dataobjects.getObjectFromUri(
            self.getParameterValue(self.TARGET))
        join = dataobjects.getObjectFromUri(
            self.getParameterValue(self.JOIN))
        predicates = self.getParameterValue(self.PREDICATE)
        precision = self.getParameterValue(self.PRECISION)

        summary = self.getParameterValue(self.SUMMARY) == 1
        keep = self.getParameterValue(self.KEEP) == 1

        sumList = self.getParameterValue(self.STATS).lower().split(',')

        targetFields = target.fields()
        joinFields = join.fields()

        fieldList = QgsFields()

        if not summary:
            joinFields = vector.testForUniqueness(targetFields, joinFields)
            seq = list(range(len(targetFields) + len(joinFields)))
            targetFields.extend(joinFields)
            targetFields = dict(list(zip(seq, targetFields)))
        else:
            numFields = {}
            for j in range(len(joinFields)):
                if joinFields[j].type() in [QVariant.Int, QVariant.Double, QVariant.LongLong, QVariant.UInt, QVariant.ULongLong]:
                    numFields[j] = []
                    for i in sumList:
                        field = QgsField(i + str(joinFields[j].name()), QVariant.Double, '', 24, 16)
                        fieldList.append(field)
            field = QgsField('count', QVariant.Double, '', 24, 16)
            fieldList.append(field)
            joinFields = vector.testForUniqueness(targetFields, fieldList)
            targetFields.extend(fieldList)
            seq = list(range(len(targetFields)))
            targetFields = dict(list(zip(seq, targetFields)))

        fields = QgsFields()
        for f in list(targetFields.values()):
            fields.append(f)

        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
            fields, target.wkbType(), target.crs())

        outFeat = QgsFeature()
        inFeatB = QgsFeature()
        inGeom = QgsGeometry()

        index = vector.spatialindex(join)

        mapP2 = dict()
        features = vector.features(join)
        for f in features:
            mapP2[f.id()] = QgsFeature(f)

        features = vector.features(target)
        total = 100.0 / len(features)
        for c, f in enumerate(features):
            atMap1 = f.attributes()
            outFeat.setGeometry(f.geometry())
            inGeom = vector.snapToPrecision(f.geometry(), precision)
            none = True
            joinList = []
            if inGeom.type() == QgsWkbTypes.PointGeometry:
                bbox = inGeom.buffer(10, 2).boundingBox()
            else:
                bbox = inGeom.boundingBox()
            bufferedBox = vector.bufferedBoundingBox(bbox, 0.51 * precision)
            joinList = index.intersects(bufferedBox)
            if len(joinList) > 0:
                count = 0
                for i in joinList:
                    inFeatB = mapP2[i]
                    inGeomB = vector.snapToPrecision(inFeatB.geometry(), precision)

                    res = False
                    for predicate in predicates:
                        if predicate == 'intersects':
                            res = inGeom.intersects(inGeomB)
                        elif predicate == 'contains':
                            res = inGeom.contains(inGeomB)
                        elif predicate == 'equals':
                            res = inGeom.equals(inGeomB)
                        elif predicate == 'touches':
                            res = inGeom.touches(inGeomB)
                        elif predicate == 'overlaps':
                            res = inGeom.overlaps(inGeomB)
                        elif predicate == 'within':
                            res = inGeom.within(inGeomB)
                        elif predicate == 'crosses':
                            res = inGeom.crosses(inGeomB)
                        if res:
                            break

                    if res:
                        count = count + 1
                        none = False
                        atMap2 = inFeatB.attributes()
                        if not summary:
                            atMap = atMap1
                            atMap2 = atMap2
                            atMap.extend(atMap2)
                            atMap = dict(list(zip(seq, atMap)))
                            break
                        else:
                            for j in list(numFields.keys()):
                                numFields[j].append(atMap2[j])

                if summary and not none:
                    atMap = atMap1
                    for j in list(numFields.keys()):
                        for k in sumList:
                            if k == 'sum':
                                atMap.append(sum(self._filterNull(numFields[j])))
                            elif k == 'mean':
                                try:
                                    nn_count = sum(1 for _ in self._filterNull(numFields[j]))
                                    atMap.append(sum(self._filterNull(numFields[j])) / nn_count)
                                except ZeroDivisionError:
                                    atMap.append(NULL)
                            elif k == 'min':
                                try:
                                    atMap.append(min(self._filterNull(numFields[j])))
                                except ValueError:
                                    atMap.append(NULL)
                            elif k == 'median':
                                atMap.append(self._median(numFields[j]))
                            else:
                                try:
                                    atMap.append(max(self._filterNull(numFields[j])))
                                except ValueError:
                                    atMap.append(NULL)

                        numFields[j] = []
                    atMap.append(count)
                    atMap = dict(list(zip(seq, atMap)))
            if none:
                outFeat.setAttributes(atMap1)
            else:
                outFeat.setAttributes(list(atMap.values()))

            if keep:
                writer.addFeature(outFeat)
            else:
                if not none:
                    writer.addFeature(outFeat)

            progress.setPercentage(int(c * total))
        del writer
Exemple #15
0
    def processAlgorithm(self, progress):
        target = dataobjects.getObjectFromUri(
            self.getParameterValue(self.TARGET))
        join = dataobjects.getObjectFromUri(
            self.getParameterValue(self.JOIN))
        predicates = self.getParameterValue(self.PREDICATE)
        precision = self.getParameterValue(self.PRECISION)

        summary = self.getParameterValue(self.SUMMARY) == 1
        keep = self.getParameterValue(self.KEEP) == 1

        sumList = self.getParameterValue(self.STATS).lower().split(',')

        targetFields = target.fields()
        joinFields = join.fields()

        fieldList = QgsFields()

        if not summary:
            joinFields = vector.testForUniqueness(targetFields, joinFields)
            seq = list(range(len(targetFields) + len(joinFields)))
            targetFields.extend(joinFields)
            targetFields = dict(list(zip(seq, targetFields)))
        else:
            numFields = {}
            for j in range(len(joinFields)):
                if joinFields[j].type() in [QVariant.Int, QVariant.Double, QVariant.LongLong, QVariant.UInt, QVariant.ULongLong]:
                    numFields[j] = []
                    for i in sumList:
                        field = QgsField(i + str(joinFields[j].name()), QVariant.Double, '', 24, 16)
                        fieldList.append(field)
            field = QgsField('count', QVariant.Double, '', 24, 16)
            fieldList.append(field)
            joinFields = vector.testForUniqueness(targetFields, fieldList)
            targetFields.extend(fieldList)
            seq = list(range(len(targetFields)))
            targetFields = dict(list(zip(seq, targetFields)))

        fields = QgsFields()
        for f in list(targetFields.values()):
            fields.append(f)

        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
            fields, target.wkbType(), target.crs())

        outFeat = QgsFeature()
        inFeatB = QgsFeature()
        inGeom = QgsGeometry()

        index = vector.spatialindex(join)

        mapP2 = dict()
        features = vector.features(join)
        for f in features:
            mapP2[f.id()] = QgsFeature(f)

        features = vector.features(target)
        total = 100.0 / len(features)
        for c, f in enumerate(features):
            atMap1 = f.attributes()
            outFeat.setGeometry(f.geometry())
            inGeom = vector.snapToPrecision(f.geometry(), precision)
            none = True
            joinList = []
            if inGeom.type() == QgsWkbTypes.PointGeometry:
                bbox = inGeom.buffer(10, 2).boundingBox()
            else:
                bbox = inGeom.boundingBox()
            bufferedBox = vector.bufferedBoundingBox(bbox, 0.51 * precision)
            joinList = index.intersects(bufferedBox)
            if len(joinList) > 0:
                count = 0
                for i in joinList:
                    inFeatB = mapP2[i]
                    inGeomB = vector.snapToPrecision(inFeatB.geometry(), precision)

                    res = False
                    for predicate in predicates:
                        res = getattr(inGeom, predicate)(inGeomB)
                        if res:
                            break

                    if res:
                        count = count + 1
                        none = False
                        atMap2 = inFeatB.attributes()
                        if not summary:
                            atMap = atMap1
                            atMap2 = atMap2
                            atMap.extend(atMap2)
                            atMap = dict(list(zip(seq, atMap)))
                            break
                        else:
                            for j in list(numFields.keys()):
                                numFields[j].append(atMap2[j])

                if summary and not none:
                    atMap = atMap1
                    for j in list(numFields.keys()):
                        for k in sumList:
                            if k == 'sum':
                                atMap.append(sum(self._filterNull(numFields[j])))
                            elif k == 'mean':
                                try:
                                    nn_count = sum(1 for _ in self._filterNull(numFields[j]))
                                    atMap.append(sum(self._filterNull(numFields[j])) / nn_count)
                                except ZeroDivisionError:
                                    atMap.append(NULL)
                            elif k == 'min':
                                try:
                                    atMap.append(min(self._filterNull(numFields[j])))
                                except ValueError:
                                    atMap.append(NULL)
                            elif k == 'median':
                                atMap.append(self._median(numFields[j]))
                            else:
                                try:
                                    atMap.append(max(self._filterNull(numFields[j])))
                                except ValueError:
                                    atMap.append(NULL)

                        numFields[j] = []
                    atMap.append(count)
                    atMap = dict(list(zip(seq, atMap)))
            if none:
                outFeat.setAttributes(atMap1)
            else:
                outFeat.setAttributes(list(atMap.values()))

            if keep:
                writer.addFeature(outFeat)
            else:
                if not none:
                    writer.addFeature(outFeat)

            progress.setPercentage(int(c * total))
        del writer
    def run(self):
        """Run method that performs all the real work"""

        # Create the dialog with elements (after translation) and keep reference
        # Only create GUI ONCE in callback, so that it will only load when the plugin is started
        if self.first_start == True:
            self.first_start = False
            self.dlg = NuevoNidoDialog()
            #QMessageBox.information(self.dlg, "Mensaje", "Esto solo debe correr una vez" )
            self.dlg.Cb_Estado.currentTextChanged.connect(
                self.evt_Cb_Estado_change)

        #Codigo que siempre se ejecuta la primera vez que se ejecuta
        #QMessageBox.information(self.dlg, "Mensaje", "Esto solo debe correr siempre" )

        #Crear conexion al Map Canvas
        mc = self.iface.mapCanvas()
        self.dlg.SpbD_Coord_X.setValue(mc.center().x())
        self.dlg.SpbD_Coord_Y.setValue(mc.center().y())
        self.dlg.DtE_Fecha.setDate(QDate.currentDate())

        #Revisar capas cargadas
        map_layers = []
        for lyr in mc.layers():
            map_layers.append(lyr.name())

        missing_layers = []
        if not "Avistamientos" in map_layers:
            missing_layers.append("Avistamientos")
        if not "Buffer Nidos" in map_layers:
            missing_layers.append("Buffer Nidos")
        if not "Buffer Lineal" in map_layers:
            missing_layers.append("Buffer Lineal")

        if missing_layers:
            mag = "Las siguientes capas falta en este proyecto"
            for lyr in missing_layers:
                mag += f"\n{lyr}"
            QMessageBox.critical(self.dlg, "Capas Faltantes", mag)
            return

        # show the dialog
        self.dlg.show()
        # Run the dialog event loop
        result = self.dlg.exec_()
        # See if OK was pressed
        if result:
            # Do something useful here - delete the line containing pass and
            # substitute with your code.
            #QMessageBox.information(self.dlg, "Mensaje", "Esto solo debe correr si presiona Ok" )
            lyrNido = QgsProject.instance().mapLayersByName("Avistamientos")[0]
            lyrBuffer = QgsProject.instance().mapLayersByName(
                "Buffer Nidos")[0]
            idxNidoId = lyrNido.fields().indexOf("nidoID")
            valNidoId = lyrNido.maximumValue(idxNidoId) + 1

            lyrLineal = QgsProject.instance().mapLayersByName(
                "Buffer Lineal")[0]

            #QMessageBox.information(self.dlg, "Mensaje", f"Nuevo Nido Id = {valNidoId}")
            valX = self.dlg.SpbD_Coord_X.value()
            valY = self.dlg.SpbD_Coord_Y.value()
            valEsp = self.dlg.Cb_Especie.currentText()
            valEst = self.dlg.Cb_Estado.currentText()
            valBuff = self.dlg.Spb_BuffDist.value()
            valFecha = self.dlg.DtE_Fecha.date()
            #QMessageBox.information(self.dlg, "Mensaje", f"Nuevo Nido Id = {valNidoId}\nCoord X = {valX}\nCoord Y = {valY}\nEspecie = {valEsp}\nEstado = {valEst}\nBuffer = {valBuff}\nFecha = {valFecha}")
            ftrNido = QgsFeature(lyrNido.fields())
            ftrNido.setAttribute("id", valNidoId)
            ftrNido.setAttribute("coord_x", valX)
            ftrNido.setAttribute("coord_y", valY)
            ftrNido.setAttribute("fecha", valFecha)
            ftrNido.setAttribute("especie", valEsp)
            ftrNido.setAttribute("estado", valEst)
            ftrNido.setAttribute("nidoID", valNidoId)
            ftrNido.setAttribute("dist_buf", valBuff)
            geom = QgsGeometry(QgsPoint(valX, valY))
            ftrNido.setGeometry(geom)
            pr = lyrNido.dataProvider()
            pr.addFeatures([ftrNido])
            lyrNido.reload()

            #Agregar el buffer
            pr = lyrBuffer.dataProvider()
            buffer = geom.buffer(valBuff, 10)
            ftrNido.setGeometry(buffer)
            pr.addFeatures([ftrNido])
            lyrBuffer.reload()

            dlgTabla = DlgTabla()
            dlgTabla.setWindowTitle(f"Tabla de Impactos para Nido {valNidoId}")
            bb = buffer.boundingBox()
            lineales = lyrLineal.getFeatures(bb)
            for lineal in lineales:
                valID = lineal.attribute("Proyecto")
                valTipo = lineal.attribute("Tipo")
                valDistancia = lineal.geometry().distance(geom)
                if valDistancia < valBuff:
                    fila = dlgTabla.Tbw_Impactos.rowCount()
                    dlgTabla.Tbw_Impactos.insertRow(fila)
                    dlgTabla.Tbw_Impactos.setItem(fila, 0,
                                                  QTableWidgetItem(str(valID)))
                    dlgTabla.Tbw_Impactos.setItem(fila, 1,
                                                  QTableWidgetItem(valTipo))
                    #dlgTabla.Tbw_Impactos.setItem(fila, 2, QTableWidgetItem(f"{valDistancia:.2f}")) #"{:.2f}".format(valDistancia)
                    twi = QTableWidgetItem(f"{valDistancia:.2f}")
                    twi.setTextAlignment(QtCore.Qt.AlignRight)
                    dlgTabla.Tbw_Impactos.setItem(fila, 2, twi)

            dlgTabla.Tbw_Impactos.sortItems(2)
            dlgTabla.show()
            dlgTabla.exec_()

        else:
            QMessageBox.information(
                self.dlg, "Mensaje",
                "Esto solo debe correr si presiona Cancel")
def buffering(progress, writer, distance, field, useField, layer, dissolve,
              segments):

    if useField:
        field = layer.fieldNameIndex(field)

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

    current = 0
    features = vector.features(layer)
    total = 100.0 / float(len(features))

    # With dissolve
    if dissolve:
        first = True
        for inFeat in features:
            attrs = inFeat.attributes()
            if useField:
                value = attrs[field]
            else:
                value = distance

            inGeom = QgsGeometry(inFeat.geometry())
            if inGeom.isGeosEmpty():
                ProcessingLog.addToLog(
                    ProcessingLog.LOG_WARNING,
                    'Feature {} has empty geometry. Skipping...'.format(
                        inFeat.id()))
                continue
            if not inGeom.isGeosValid():
                ProcessingLog.addToLog(
                    ProcessingLog.LOG_WARNING,
                    'Feature {} has invalid geometry. Skipping...'.format(
                        inFeat.id()))
                continue
            outGeom = inGeom.buffer(float(value), segments)
            if first:
                tempGeom = QgsGeometry(outGeom)
                first = False
            else:
                tempGeom = tempGeom.combine(outGeom)

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

        outFeat.setGeometry(tempGeom)
        outFeat.setAttributes(attrs)
        writer.addFeature(outFeat)
    else:
        # Without dissolve
        for inFeat in features:
            attrs = inFeat.attributes()
            if useField:
                value = attrs[field]
            else:
                value = distance
            inGeom = QgsGeometry(inFeat.geometry())
            if inGeom.isGeosEmpty():
                ProcessingLog.addToLog(
                    ProcessingLog.LOG_WARNING,
                    'Feature {} has empty geometry. Skipping...'.format(
                        inFeat.id()))
                continue
            if not inGeom.isGeosValid():
                ProcessingLog.addToLog(
                    ProcessingLog.LOG_WARNING,
                    'Feature {} has invalid geometry. Skipping...'.format(
                        inFeat.id()))
                continue

            outGeom = inGeom.buffer(float(value), segments)
            outFeat.setGeometry(outGeom)
            outFeat.setAttributes(attrs)
            writer.addFeature(outFeat)
            current += 1
            progress.setPercentage(int(current * total))

    del writer
Exemple #18
0
    def traf(self, geometry, trafic, spatial, lines, echelle, angle_max,
             dist_min, double_sens):
        lignes = lines
        conn = db.connect(':memory:')
        conn.enable_load_extension(True)
        conn.execute("select load_extension('mod_spatialite')")
        c = conn.cursor()
        proj = str(self.lines.crs().postgisSrid())
        t = geometry[trafic]

        texte = "select astext(st_buffer(st_geomfromtext('" + geometry.geometry(
        ).asWkt() + "'," + proj + ")," + str(echelle * t) + "))"
        rs = c.execute(texte)
        resultat = c.fetchall()
        conn.commit()
        texte_buf = resultat[0][0]
        texte_buf = texte_buf.replace("Polygon", "MultiLineString")
        buf = QgsGeometry.fromWkt(texte_buf)
        #buf=buf.convertToType(QgsWkbTypes.LineGeometry,False)
        texte = "select astext(st_union(st_exteriorring(st_geomfromtext('" + buf.asWkt(
        ) + "'," + proj + "))))"
        rs = c.execute(texte)
        resultat = c.fetchall()
        conn.commit()
        buf = QgsGeometry.fromWkt(resultat[0][0])
        #QgsMessageLog.logMessage(texte)
        #QgsMessageLog.logMessage(buf.asWkt())
        buf_poly = buf
        geom = geometry.geometry()
        buf_sav = buf
        buf_l = buf.length()
        l2 = QgsLineString()
        #print(geom.asWkt())
        geom.convertToSingleType()
        #print(geom.asWkt())
        l2.fromWkt(geom.asWkt())
        #print(l2.asWkt())
        pt1 = QgsGeometry(l2.startPoint())
        pt2 = QgsGeometry(l2.endPoint())
        ###point debut
        debut = spatial.intersects(
            QgsGeometry.buffer(pt1, 10, 3).boundingBox())
        fe = [f for f in debut]

        feats = []
        for f in fe:
            ff = QgsLineString()
            #QgsMessageLog.logMessage(lignes[f].geometry().asWkt())
            geom = lignes[f].geometry()
            geom.convertToSingleType()
            ff.fromWkt(geom.asWkt())
            #QgsMessageLog.logMessage(ff.asWkt())
            #print(pt1.distance(QgsGeometry(ff.startPoint())))
            if pt1.distance(QgsGeometry(ff.startPoint())) < 10:
                if lignes[f] not in feats:
                    feats.append(f)
            elif pt1.distance(QgsGeometry(ff.endPoint())) < 10:
                if lignes[f] not in feats:
                    feats.append(f)
        #QgsMessageLog.logMessage(str(fe))
        #QgsMessageLog.logMessage(str(feats))

        distances = {}
        angles = {}
        for i in feats:
            longueur = lignes[i].geometry().length()
            if not (geometry.id() == i):
                distances[i] = lignes[i].geometry().lineLocatePoint(pt1)
                if distances[i] < dist_min:
                    angles[i] = ((lignes[i].geometry().interpolateAngle(
                        min(dist_min, longueur)) * 180 / math.pi) + 180) % 360
                else:
                    angles[i] = lignes[i].geometry().interpolateAngle(
                        longueur - min(dist_min, longueur)) * 180 / math.pi
            else:
                angle1 = lignes[i].geometry().interpolateAngle(
                    min(dist_min, longueur)) * 180 / math.pi
        angle_maxi = 1e38
        voisin = None
        angle_voisin = None
        angle2 = None
        if len(distances) == 0:
            angle = (angle1) % 360
            angle2 = angle1
            angle_voisin = angle2
        for i in distances:
            if distances[i] < dist_min:
                angle = (angles[i]) % 360
                min_angle = min(
                    abs((angle + 180) % 360 - (angle1 + 180) % 360),
                    abs(angle - angle1))
                if min_angle < angle_maxi:
                    angle_maxi = min_angle
                    angle_voisin = angle
                    voisin = i
            else:
                angle = angles[i]
                min_angle = min(
                    abs((angle + 180) % 360 - (angle1 + 180) % 360),
                    abs(angle - angle1))
                if min_angle < angle_maxi:
                    angle_maxi = min_angle
                    angle_voisin = angle
                    voisin = i

        if min(abs((angle_voisin + 180) % 360 - (angle1 + 180) % 360),
               abs(angle_voisin - angle1)) < angle_max:
            if abs((angle_voisin + 180) % 360 -
                   (angle1 + 180) % 360) < abs(angle_voisin - angle1):
                angle2 = (0.5 * (((angle_voisin + 180) % 360 +
                                  (angle1 + 180) % 360)) + 180) % 360
            else:
                angle2 = 0.5 * (angle_voisin + angle1)
        else:
            angle2 = angle1

        if angle2 == None:
            angle2 = (angle1) % 360

        start_line = QgsGeometry.fromPolyline([
            QgsPoint(
                pt1.asPoint().x() - 40 * echelle * t * math.cos(
                    (180 - angle2) * math.pi / 180),
                pt1.asPoint().y() - 40 * echelle * t * math.sin(
                    (180 - angle2) * math.pi / 180)),
            QgsPoint(pt1.asPoint().x(),
                     pt1.asPoint().y())
        ])
        int1 = buf.intersection(start_line)
        start_line2 = QgsGeometry.fromPolyline([
            QgsPoint(
                pt1.asPoint().x() + 40 * echelle * t * math.cos(
                    (180 - angle2) * math.pi / 180),
                pt1.asPoint().y() + 40 * echelle * t * math.sin(
                    (180 - angle2) * math.pi / 180)),
            QgsPoint(pt1.asPoint().x(),
                     pt1.asPoint().y())
        ])
        int3 = buf.intersection(start_line2)
        if int1.isMultipart():
            points = int1.asMultiPoint()
            dmax = 1e38
            for p in points:
                d = pt1.distance(QgsGeometry.fromPointXY(p))
                if d < dmax:
                    dmax = d
                    pmax = p
            int1 = QgsGeometry.fromPointXY(pmax)
        if int3.isMultipart():
            points = int3.asMultiPoint()
            dmax = 1e38
            for p in points:
                d = pt1.distance(QgsGeometry.fromPointXY(p))
                if d < dmax:
                    dmax = d
                    pmax = p
            int3 = QgsGeometry.fromPointXY(pmax)

        ###point fin

        debut = spatial.intersects(
            QgsGeometry.buffer(pt2, 10, 3).boundingBox())
        fe = [f for f in debut]
        for f in fe:
            ff = QgsLineString()
            geom = lignes[f].geometry()
            geom.convertToSingleType()
            ff.fromWkt(geom.asWkt())
            if pt2.distance(QgsGeometry(ff.startPoint())) < 10:
                if lignes[f] not in feats:
                    feats.append(f)
            elif pt2.distance(QgsGeometry(ff.endPoint())) < 10:
                if lignes[f] not in feats:
                    feats.append(f)
        distances = {}
        angles = {}
        for i in feats:
            longueur = lignes[i].geometry().length()
            if not (geometry.id() == i):
                distances[i] = lignes[i].geometry().lineLocatePoint(pt2)
                if distances[i] < dist_min:
                    angles[i] = (lignes[i].geometry().interpolateAngle(
                        min(dist_min, longueur)) * 180 / math.pi) % 360
                else:
                    angles[i] = (((lignes[i].geometry().interpolateAngle(
                        longueur - min(dist_min, longueur)) * 180) / math.pi) +
                                 180) % 360
            else:
                angle1 = ((lignes[i].geometry().interpolateAngle(
                    longueur - min(dist_min, longueur)) * 180 / math.pi))
        angle_maxi = 1e38
        voisin = None
        angle_voisin = None
        angle2 = None
        if len(distances) == 0:
            angle = (angle1) % 360
            angle2 = angle1
            angle_voisin = angle2
        for i in distances:
            if distances[i] < dist_min:
                angle = (angles[i])
                min_angle = min(
                    abs((angle + 180) % 360 - (angle1 + 180) % 360),
                    abs(angle - angle1))
                if min_angle < angle_maxi:
                    angle_maxi = min_angle
                    angle_voisin = angle
                    voisin = i
            else:
                angle = (angles[i])
                min_angle = min(
                    abs((angle + 180) % 360 - (angle1 + 180) % 360),
                    abs(angle - angle1))
                if min_angle < angle_maxi:
                    angle_maxi = min_angle
                    angle_voisin = angle
                    voisin = i

        if min(abs((angle_voisin + 180) % 360 - (angle1 + 180) % 360),
               abs(angle_voisin - angle1)) < angle_max:
            if abs((angle_voisin + 180) % 360 -
                   (angle1 + 180) % 360) < abs(angle_voisin - angle1):
                angle2 = (0.5 * (((angle_voisin + 180) % 360 +
                                  (angle1 + 180) % 360)) + 180) % 360
            else:
                angle2 = 0.5 * (angle_voisin + angle1)
        else:
            angle2 = angle1
        if angle2 == None:
            angle2 = (angle1) % 360

        end_line = QgsGeometry.fromPolyline([
            QgsPoint(
                pt2.asPoint().x() - 40 * echelle * t * math.cos(
                    (180 - angle2) * math.pi / 180),
                pt2.asPoint().y() - 40 * echelle * t * math.sin(
                    (180 - angle2) * math.pi / 180)),
            QgsPoint(pt2.asPoint().x(),
                     pt2.asPoint().y())
        ])
        int2 = buf.intersection(end_line)
        end_line2 = QgsGeometry.fromPolyline([
            QgsPoint(
                pt2.asPoint().x() + 40 * echelle * t * math.cos(
                    (180 - angle2) * math.pi / 180),
                pt2.asPoint().y() + 40 * echelle * t * math.sin(
                    (180 - angle2) * math.pi / 180)),
            QgsPoint(pt2.asPoint().x(),
                     pt2.asPoint().y())
        ])
        int4 = buf.intersection(end_line2)

        int5 = start_line.intersection(end_line)
        int6 = start_line2.intersection(end_line2)
        m5 = -1
        m6 = -1

        if int5.type() == 0:
            if int5.within(buf_poly):
                m5 = 1
        if int6.type() == 0:
            if int6.within(buf_poly):
                m6 = 1

        if int2.isMultipart():
            points = int2.asMultiPoint()
            dmax = 1e38
            for p in points:
                d = pt2.distance(QgsGeometry.fromPointXY(p))
                if d < dmax:
                    dmax = d
                    pmax = p
            int2 = QgsGeometry.fromPointXY(pmax)
        if int4.isMultipart():
            points = int4.asMultiPoint()
            dmax = 1e38
            for p in points:
                d = pt2.distance(QgsGeometry.fromPointXY(p))
                if d < dmax:
                    dmax = d
                    pmax = p
            int4 = QgsGeometry.fromPointXY(pmax)

        #print(int1.exportToWkt(),int2.exportToWkt(),int3.exportToWkt(),int4.exportToWkt())
        #QgsMessageLog.logMessage(buf.asWkt())
        texte = "select astext(st_union(st_snap(st_geomfromtext('" + buf.asWkt(
        ) + "'," + proj + "),st_geomfromtext('" + int1.asWkt(
        ) + "'," + proj + "),1)))"
        rs = c.execute(texte)
        resultat = c.fetchall()
        conn.commit()
        buf = resultat[0][0]
        #QgsMessageLog.logMessage(texte)
        #QgsMessageLog.logMessage(buf)
        #QgsMessageLog.logMessage(proj)
        #QgsMessageLog.logMessage(int2.asWkt())
        texte = "select astext(st_union(st_snap(st_geomfromtext('" + buf + "'," + proj + "),st_geomfromtext('" + int2.asWkt(
        ) + "'," + proj + "),1)))"
        rs = c.execute(texte)
        resultat = c.fetchall()
        conn.commit()
        buf = resultat[0][0]
        texte = "select astext(st_union(st_snap(st_geomfromtext('" + buf + "'," + proj + "),st_geomfromtext('" + int3.asWkt(
        ) + "'," + proj + "),1)))"
        rs = c.execute(texte)
        resultat = c.fetchall()
        conn.commit()
        buf = resultat[0][0]
        texte = "select astext(st_union(st_snap(st_geomfromtext('" + buf + "'," + proj + "),st_geomfromtext('" + int4.asWkt(
        ) + "'," + proj + "),1)))"
        rs = c.execute(texte)
        resultat = c.fetchall()
        conn.commit()
        buf = QgsGeometry.fromWkt(resultat[0][0])

        m1 = buf.lineLocatePoint(int1)
        m2 = buf.lineLocatePoint(int2)
        m3 = buf.lineLocatePoint(int3)
        m4 = buf.lineLocatePoint(int4)

        #creation epaisseur

        buf_l = buf.length()
        m1 = m1 / buf_l
        m2 = m2 / buf_l
        m3 = m3 / buf_l
        m4 = m4 / buf_l

        if m2 < m1:
            texte = "select asText(st_line_substring(st_geomfromtext('" + buf.asWkt(
            ) + "'," + proj + ")" + ',' + str(m2) + ',' + str(m1) + "))"

            rs = c.execute(texte)
            resultat = c.fetchall()
            conn.commit()
            buf1 = QgsGeometry.fromWkt(resultat[0][0])

        else:
            texte = "select astext(st_union(st_snap(st_line_substring(geomfromtext('" + buf.asWkt(
            ) + "'," + proj + "),0," + str(
                m1) + "),st_line_substring(geomfromtext('" + buf.asWkt(
                ) + "'," + proj + ")," + str(
                    m3
                ) + ",1),1),st_line_substring(geomfromtext('" + buf.asWkt(
                ) + "'," + proj + ")," + str(m2) + ",1)))"
            rs = c.execute(texte)
            resultat = c.fetchall()
            conn.commit()
            buf1 = QgsGeometry.fromWkt(resultat[0][0])

        if m3 < m4:
            texte = "select asText(st_line_substring(st_geomfromtext('" + buf.asWkt(
            ) + "'," + proj + ")" + ',' + str(m3) + ',' + str(m4) + "))"
            rs = c.execute(texte)
            resultat = c.fetchall()
            conn.commit()
            buf2 = QgsGeometry.fromWkt(resultat[0][0])

        else:

            texte = "select astext(st_union(g)) from (select st_line_substring(st_geomfromtext('" + buf.asWkt(
            ) + "'," + proj + "),0," + str(
                m4
            ) + ") as \"g\" union all select st_line_substring(st_geomfromtext('" + buf.asWkt(
            ) + "'," + proj + ")," + str(m3) + ",1) as \"g\" )"
            rs = c.execute(texte)
            resultat = c.fetchall()
            conn.commit()
            buf2 = QgsGeometry.fromWkt(resultat[0][0])
            texte = "select astext(st_union(st_snap(st_line_substring(geomfromtext('" + buf.asWkt(
            ) + "'," + proj + "),0," + str(
                m4) + "),st_line_substring(geomfromtext('" + buf.asWkt(
                ) + "'," + proj + ")," + str(
                    m3
                ) + ",1),1),st_line_substring(geomfromtext('" + buf.asWkt(
                ) + "'," + proj + ")," + str(m3) + ",1)))"

            rs = c.execute(texte)
            resultat = c.fetchall()
            conn.commit()
            buf2 = QgsGeometry.fromWkt(resultat[0][0])

        g1 = buf
        g2 = buf.shortestLine(int1)
        g2 = g2.combine(g1)
        g3 = buf.shortestLine(int2)
        g3 = g3.combine(g2)
        g3 = g3.combine(pt1.shortestLine(int1))
        g3 = g3.combine(pt2.shortestLine(int2))
        g3 = g3.combine(pt1.shortestLine(geometry.geometry()))
        g3 = g3.combine(pt2.shortestLine(geometry.geometry()))
        g3 = g3.combine(geometry.geometry())
        buf3 = buf1.asWkt()
        buf4 = buf2.asWkt()
        if double_sens == False:
            if m5 > 0:
                texte = "select astext(st_union(st_snap(geomfromtext('" + geometry.geometry(
                ).asWkt(
                ) + "'," + proj + "),geomfromtext('" + pt1.shortestLine(
                    int5).asWkt(
                    ) + "'," + proj + "),1),geomfromtext('" + pt1.shortestLine(
                        int5).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]
                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt2.shortestLine(
                    int5).asWkt(
                    ) + "'," + proj + "),1),geomfromtext('" + pt2.shortestLine(
                        int5).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]
            else:
                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + buf1.shortestLine(
                    int1
                ).asWkt(
                ) + "'," + proj + "),1),geomfromtext('" + buf1.shortestLine(
                    int1).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]
                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + buf1.shortestLine(
                    int2
                ).asWkt(
                ) + "'," + proj + "),1),geomfromtext('" + buf1.shortestLine(
                    int2).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]
                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt1.shortestLine(
                    int1).asWkt(
                    ) + "'," + proj + "),1),geomfromtext('" + pt1.shortestLine(
                        int1).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]
                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt2.shortestLine(
                    int2).asWkt() + "'),1),geomfromtext('" + pt2.shortestLine(
                        int2).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]
                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt1.shortestLine(
                    geometry.geometry()).asWkt(
                    ) + "'," + proj + "),1),geomfromtext('" + pt1.shortestLine(
                        geometry.geometry()).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]
                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt2.shortestLine(
                    geometry.geometry()).asWkt(
                    ) + "'," + proj + "),1),geomfromtext('" + pt2.shortestLine(
                        geometry.geometry()).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + geometry.geometry(
                ).asWkt(
                ) + "'," + proj + "),1),geomfromtext('" + geometry.geometry(
                ).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]

        else:

            if m5 > 0:
                texte = "select astext(st_union(st_snap(geomfromtext('" + buf4 + "'," + proj + "),geomfromtext('" + pt1.shortestLine(
                    int3).asWkt(
                    ) + "'," + proj + "),1),geomfromtext('" + pt1.shortestLine(
                        int3).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]
                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt2.shortestLine(
                    int4).asWkt(
                    ) + "'," + proj + "),1),geomfromtext('" + pt2.shortestLine(
                        int4).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]
                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt1.shortestLine(
                    int5).asWkt(
                    ) + "'," + proj + "),1),geomfromtext('" + pt1.shortestLine(
                        int5).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]
                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt2.shortestLine(
                    int5).asWkt(
                    ) + "'," + proj + "),1),geomfromtext('" + pt2.shortestLine(
                        int5).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]

            elif m6 > 0:
                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt1.shortestLine(
                    int1).asWkt(
                    ) + "'," + proj + "),1),geomfromtext('" + pt1.shortestLine(
                        int1).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]
                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt2.shortestLine(
                    int2).asWkt(
                    ) + "'," + proj + "),1),geomfromtext('" + pt2.shortestLine(
                        int2).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]
                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt1.shortestLine(
                    int6).asWkt(
                    ) + "'," + proj + "),1),geomfromtext('" + pt1.shortestLine(
                        int6).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]
                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt2.shortestLine(
                    int6).asWkt(
                    ) + "'," + proj + "),1),geomfromtext('" + pt2.shortestLine(
                        int6).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]

            else:

                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + buf1.shortestLine(
                    int1
                ).asWkt(
                ) + "'," + proj + "),1),geomfromtext('" + buf1.shortestLine(
                    int1).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]

                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + buf1.shortestLine(
                    int2
                ).asWkt(
                ) + "'," + proj + "),1),geomfromtext('" + buf1.shortestLine(
                    int2).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]
                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + int3.shortestLine(
                    int1
                ).asWkt(
                ) + "'," + proj + "),1),geomfromtext('" + int3.shortestLine(
                    int1).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]
                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + int4.shortestLine(
                    int2
                ).asWkt(
                ) + "'," + proj + "),1),geomfromtext('" + int4.shortestLine(
                    int2).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]
                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + buf2.shortestLine(
                    int3
                ).asWkt(
                ) + "'," + proj + "),1),geomfromtext('" + buf2.shortestLine(
                    int3).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]
                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + buf2.shortestLine(
                    int4
                ).asWkt(
                ) + "'," + proj + "),1),geomfromtext('" + buf2.shortestLine(
                    int4).asWkt() + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]
                texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + buf4 + "'," + proj + "),1),geomfromtext('" + buf4 + "'," + proj + ")))"
                rs = c.execute(texte)
                resultat = c.fetchall()
                conn.commit()
                buf3 = resultat[0][0]

        texte = "select astext(st_buildarea(st_union(g))) from  ((select geomfromtext('" + buf3 + "'," + proj + ") as \"g\"))"
        rs = c.execute(texte)
        resultat = c.fetchall()
        conn.commit()

        buf = QgsGeometry.fromWkt(resultat[0][0])

        return (buf)
Exemple #19
0
def buffering(progress, writer, distance, field, useField, layer, dissolve,
              segments):

    if useField:
        field = layer.fieldNameIndex(field)

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

    current = 0
    features = vector.features(layer)
    total = 100.0 / float(len(features))

    # With dissolve
    if dissolve:
        first = True
        for inFeat in features:
            attrs = inFeat.attributes()
            if useField:
                value = attrs[field]
            else:
                value = distance

            inGeom = QgsGeometry(inFeat.geometry())
            if inGeom.isGeosEmpty() or not inGeom.isGeosValid():
                ProcessingLog.addToLog(ProcessingLog.LOG_WARNING, 'Feature {} has empty or invalid geometry. Skipping...'.format(inFeat.id()))
                continue
            outGeom = inGeom.buffer(float(value), segments)
            if first:
                tempGeom = QgsGeometry(outGeom)
                first = False
            else:
                tempGeom = tempGeom.combine(outGeom)

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

        outFeat.setGeometry(tempGeom)
        outFeat.setAttributes(attrs)
        writer.addFeature(outFeat)
    else:
        # Without dissolve
        for inFeat in features:
            attrs = inFeat.attributes()
            if useField:
                value = attrs[field]
            else:
                value = distance
            inGeom = QgsGeometry(inFeat.geometry())
            if inGeom.isGeosEmpty() or not inGeom.isGeosValid():
                ProcessingLog.addToLog(ProcessingLog.LOG_WARNING, 'Feature {} has empty or invalid geometry. Skipping...'.format(inFeat.id()))
                continue

            outGeom = inGeom.buffer(float(value), segments)
            outFeat.setGeometry(outGeom)
            outFeat.setAttributes(attrs)
            writer.addFeature(outFeat)
            current += 1
            progress.setPercentage(int(current * total))

    del writer
    def run(self):

        # Converter escala textual para numérica (denominador)
        escala = self.escalaAvaliacao.currentText() # '1:100.000'
        escalaAval = escala.split(':')[1].replace('.','')    
        escalaAval = int(escalaAval)
        
        self.canvas.zoomScale(escalaAval)

        listaHomologosXY = {} # dicionario yx.
        listaHomologosZ = {} # dicionario z.    
       
        # Raio definido
        raio = self.spinBox.value()

        # Layers selecionados
        layer1 = self.referenciaComboBox.currentLayer()
        layer2 = self.avaliacaoComboBox.currentLayer()

        # Teste para identificar se esta setado.
        XY = False 
        Z = False

        if self.xy.isChecked():
            XY = True 
        if self.z.isChecked(): 
            Z = True

        # Troca de referência CRS para uma que utiliza medição em metros (3857).
        source1 = layer1.crs()
        source2 = layer2.crs()
        dest = QgsCoordinateReferenceSystem(3857)

        tr1 = QgsCoordinateTransform(source1, dest)
        tr2 = QgsCoordinateTransform(source2, dest)

        lista1 = [feat1 for feat1 in layer1.getFeatures()]
        lista2 = [feat2 for feat2 in layer2.getFeatures()]
        lista3 = []
         
        spIndex1 = QgsSpatialIndex()
        neighbour = QgsFeature()
        
        for feat1 in lista1: 

            spIndex1.insertFeature(feat1)  # transforma features em indices espaciais
            geom1 = QgsGeometry(feat1.geometry()) 
            geom1.transform(tr1)        
            raioTeste = raio 
            neighbour = None
            encontrado =  False
                        
            for feat2 in lista2:

                pt = feat2.geometry().asPoint()
                nearestid = spIndex1.nearestNeighbor(pt, 2)[0] # realiza a analise do vizinho mais próximo, numero de vizinhos é definido no segundo argumento.
                #print nearestid
                request = QgsFeatureRequest().setFilterFid(nearestid)
                geom2 = QgsGeometry(feat2.geometry()) 
                geom2.transform(tr2) 

                if geom1.buffer (raioTeste, 20 ) .contains (geom2):
                     raioTeste = sqrt (geom1.asPoint (). sqrDist (geom2.asPoint ()))
                     neighbour = feat2  
                     encontrado = True
                  
            # apenas pra descobrir se não foi encontrado.
            if encontrado == False: 
                #print u'\nHouve pontos nao encontrados dentro do raio definido.'
                frase = ("<span style='color:purple'>HOUVE PONTOS NAO ENCONTRADOS.</span>")
                lista3.append(frase)
            
            else:
                if XY:
                    listaHomologosXY[int(feat1.id()), int(neighbour.id())] = (raioTeste)
                
                if Z:
                    listaHomologosZ[int(feat1.id()), int(neighbour.id())]  = feat1.geometry().geometry().z() - neighbour.geometry().geometry().z()
                lista2.remove(neighbour)     

        if XY or Z:   
            #print '\nHomologos: \n', listaHomologosXY.keys()
            distAcum = 0
             
            resultado2 = "<span style='color:orange'>DISTANCIA ENTRE PONTOS: </span>",[ round(v, 2) for v in listaHomologosXY.values()]
            resultado1 = "<span style='color:orange'>PONTOS HOMOLOGOS: </span>",listaHomologosXY.keys()
            #print '\nDistancia entre pontos Homologados:\n',resultado2
            lista3.append(resultado1)
            lista3.append(resultado2)      
        
        if XY: 
            distAcum = 0
            for valorXY in listaHomologosXY.values():
                distAcum += valorXY    

            resultado = int(distAcum / len(listaHomologosXY))
            #print '\nDistancia media:\n', round(resultado,2)  
            b = "<span style='color:orange'>DISTANCIA MEDIA: </span>", round(resultado,2)
            lista3.append(b)
        
        if Z:
            zAcum = 0     
            for valorZ in listaHomologosZ.values(): 
                zAcum += valorZ

            resultado = int(zAcum / len(listaHomologosZ)) 
            #print '\nDiferenca media de elevacao: \n', round(resultado,3)
            a = "<span style='color:orange'>DISTANCIA MEDIA DE ELEVACAO: </span>", round(resultado,3)
            lista3.append(a)

        # Formatação para apresentar QmessageBox de forma bem distribuida.
        message = u""
        one_data = u"<p>{0}</p>"
        two_data = u"<p>{0} {1}</p>"
        for data in lista3:
            message += one_data.format(data) if type(data) == str else two_data.format(data[0], data[1])
  
        QMessageBox.about(self, "RESULTADO: ", message )  
Exemple #21
0
    def in_mask(self, feature, srid=None):
        if feature is None:  # expression overview
            return False

        if self.layer is None:
            return False

        try:
            # layer is not None but destroyed ?
            self.layer.id()
        except:
            self.reset_mask_layer()
            return False

        # mask layer empty due to unloaded memlayersaver plugin > no filtering
        if self.layer.featureCount() == 0:
            return True

        mask_geom, bbox = self.mask_geometry()
        geom = QgsGeometry(feature.geometry())
        if not geom.isGeosValid():
            geom = geom.buffer(0.0, 1)

        if geom is None:
            return False

        if srid is not None and self.layer.crs().postgisSrid() != srid:
            src_crs = QgsCoordinateReferenceSystem(srid)
            dest_crs = self.layer.crs()
            xform = QgsCoordinateTransform(src_crs, dest_crs, QgsProject.instance())
            try:
                geom.transform(xform)
            except:
                # transformation error. Check layer projection.
                pass

        if geom.type() == QgsWkbTypes.PolygonGeometry:
            if self.parameters.polygon_mask_method == 2 and not self.has_point_on_surface:
                self.parameters.polygon_mask_method = 1

            if self.parameters.polygon_mask_method == 0:
                # this method can only work when no geometry simplification is involved
                return (mask_geom.overlaps(geom) or mask_geom.contains(geom))
            elif self.parameters.polygon_mask_method == 1:
                # the fastest method, but with possible inaccuracies
                pt = geom.vertexAt(0)
                return bbox.contains(QgsPointXY(pt)) and mask_geom.contains(geom.centroid())
            elif self.parameters.polygon_mask_method == 2:
                # will always work
                pt = geom.vertexAt(0)
                return bbox.contains(QgsPointXY(pt)) and mask_geom.contains(geom.pointOnSurface())
            else:
                return False
        elif geom.type() == QgsWkbTypes.LineGeometry:
            if self.parameters.line_mask_method == 0:
                return mask_geom.intersects(geom)
            elif self.parameters.line_mask_method == 1:
                return mask_geom.contains(geom)
            else:
                return False
        elif geom.type() == QgsWkbTypes.PointGeometry:
            return mask_geom.intersects(geom)
        else:
            return False
Exemple #22
0
    def generateFootprintsForFilmOblique(self):
        self.reloadFpLayer()
        self.reloadCpLayer()

        caps = self.fpLayer.dataProvider().capabilities()
        if caps & QgsVectorDataProvider.AddFeatures:
            if self.cpLayer.dataProvider().featureCount() > 0:
                iter = self.cpLayer.getFeatures()
                existingFootpints = QgsVectorLayerUtils.getValues(
                    self.fpLayer, "bildnummer")[0]
                cpFt = QgsFeature()
                fpFts = []
                #iterate over points from CP Layer > LON, LAT
                while iter.nextFeature(cpFt):
                    if cpFt['bildnummer'] in existingFootpints:
                        #QMessageBox.warning(None, u"Bild Nummern", u"Footprint für das Bild mit der Nummer {0} wurde bereits erstellt.".format(ft['BILD']))
                        continue
                    cp = cpFt.geometry()
                    cpMetric = QgsGeometry(cp)
                    destCrs = QgsCoordinateReferenceSystem()
                    destCrs.createFromProj4(self.Proj4Utm(cp.asPoint()))
                    coordTransformF = QgsCoordinateTransform(
                        self.cpLayer.crs(), destCrs, QgsProject.instance())
                    coordTransformB = QgsCoordinateTransform(
                        destCrs, self.cpLayer.crs(), QgsProject.instance())
                    cpMetric.transform(coordTransformF)
                    if cpFt['radius'] == '':
                        r = 175
                    else:
                        r = float(cpFt['radius'])
                    fpMetric = QgsGeometry(cpMetric.buffer(r, 18))
                    fp = QgsGeometry(fpMetric)
                    fp.transform(coordTransformB)

                    fpFt = QgsFeature(self.fpLayer.fields())
                    fpFt.setGeometry(fp)
                    fpFt.setAttribute("bildnummer", cpFt["bildnummer"])
                    fpFt.setAttribute("filmnummer", cpFt["filmnummer"])
                    da = QgsDistanceArea()
                    da.setEllipsoid(self.fpLayer.crs().ellipsoidAcronym())
                    fpFt.setAttribute('shape_length', da.measurePerimeter(fp))
                    fpFt.setAttribute('shape_area', da.measureArea(fp))
                    fpFts.append(fpFt)

                (res,
                 outFeats) = self.fpLayer.dataProvider().addFeatures(fpFts)
                self.fpLayer.updateExtents()
                if self.canvas.isCachingEnabled():
                    self.fpLayer.triggerRepaint()
                else:
                    self.canvas.refresh()
            else:
                QMessageBox.warning(
                    None, "Keine Bildmittelpunkte",
                    "Keine Bildmittelpunkte für den Film {0} vorhanden.".
                    format(self.currentFilmNumber))
        else:
            QMessageBox.warning(
                None, "Layer Capabilities",
                "AddFeature is not enabled ({0})".format(
                    self.fpLayer.dataProvider().capabilitiesString()))
Exemple #23
0
    def processAlgorithm(self, progress):
        target = dataobjects.getObjectFromUri(
            self.getParameterValue(self.TARGET))
        join = dataobjects.getObjectFromUri(
            self.getParameterValue(self.JOIN))
        predicates = self.getParameterValue(self.PREDICATE)

        summary = self.getParameterValue(self.SUMMARY) == 1
        keep = self.getParameterValue(self.KEEP) == 1

        sumList = self.getParameterValue(self.STATS).lower().split(',')

        targetProvider = target.dataProvider()
        joinProvider = join.dataProvider()

        targetFields = targetProvider.fields()
        joinFields = joinProvider.fields()

        fieldList = QgsFields()

        if not summary:
            joinFields = vector.testForUniqueness(targetFields, joinFields)
            seq = range(0, len(targetFields) + len(joinFields))
            targetFields.extend(joinFields)
            targetFields = dict(zip(seq, targetFields))
        else:
            numFields = {}
            for j in xrange(len(joinFields)):
                if joinFields[j].type() in [QVariant.Int, QVariant.Double]:
                    numFields[j] = []
                    for i in sumList:
                        field = QgsField(i + unicode(joinFields[j].name()), QVariant.Double, '', 24, 16)
                        fieldList.append(field)
            field = QgsField('count', QVariant.Double, '', 24, 16)
            fieldList.append(field)
            joinFields = vector.testForUniqueness(targetFields, fieldList)
            targetFields.extend(fieldList)
            seq = range(0, len(targetFields))
            targetFields = dict(zip(seq, targetFields))

        fields = QgsFields()
        for f in targetFields.values():
            fields.append(f)

        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
            fields, targetProvider.geometryType(), targetProvider.crs())

        outFeat = QgsFeature()
        inFeatB = QgsFeature()
        inGeom = QgsGeometry()

        index = vector.spatialindex(join)

        mapP2 = dict()
        features = vector.features(join)
        for f in features:
            mapP2[f.id()] = QgsFeature(f)

        features = vector.features(target)
        total = 100.0 / len(features)
        for c, f in enumerate(features):
            inGeom = f.geometry()
            atMap1 = f.attributes()
            outFeat.setGeometry(inGeom)
            none = True
            joinList = []
            if inGeom.type() == QGis.Point:
                joinList = index.intersects(inGeom.buffer(10, 2).boundingBox())
                if len(joinList) > 0:
                    check = 0
                else:
                    check = 1
            else:
                joinList = index.intersects(inGeom.boundingBox())
                if len(joinList) > 0:
                    check = 0
                else:
                    check = 1

            if check == 0:
                count = 0
                for i in joinList:
                    inFeatB = mapP2[i]
                    inGeomB = inFeatB.geometry()

                    res = False
                    for predicate in predicates:
                        if predicate == 'intersects':
                            res = inGeom.intersects(inGeomB)
                        elif predicate == 'contains':
                            res = inGeom.contains(inGeomB)
                        elif predicate == 'equals':
                            res = inGeom.equals(inGeomB)
                        elif predicate == 'touches':
                            res = inGeom.touches(inGeomB)
                        elif predicate == 'overlaps':
                            res = inGeom.overlaps(inGeomB)
                        elif predicate == 'within':
                            res = inGeom.within(inGeomB)
                        elif predicate == 'crosses':
                            res = inGeom.crosses(inGeomB)
                        if res:
                            break

                    if res:
                        count = count + 1
                        none = False
                        atMap2 = inFeatB.attributes()
                        if not summary:
                            atMap = atMap1
                            atMap2 = atMap2
                            atMap.extend(atMap2)
                            atMap = dict(zip(seq, atMap))
                            break
                        else:
                            for j in numFields.keys():
                                numFields[j].append(atMap2[j])

                if summary and not none:
                    atMap = atMap1
                    for j in numFields.keys():
                        for k in sumList:
                            if k == 'sum':
                                atMap.append(sum(self._filterNull(numFields[j])))
                            elif k == 'mean':
                                try:
                                    nn_count = sum(1 for _ in self._filterNull(numFields[j]))
                                    atMap.append(sum(self._filterNull(numFields[j])) / nn_count)
                                except ZeroDivisionError:
                                    atMap.append(NULL)
                            elif k == 'min':
                                try:
                                    atMap.append(min(self._filterNull(numFields[j])))
                                except ValueError:
                                    atMap.append(NULL)
                            elif k == 'median':
                                atMap.append(self._median(numFields[j]))
                            else:
                                try:
                                    atMap.append(max(self._filterNull(numFields[j])))
                                except ValueError:
                                    atMap.append(NULL)

                        numFields[j] = []
                    atMap.append(count)
                    atMap = dict(zip(seq, atMap))
            if none:
                outFeat.setAttributes(atMap1)
            else:
                outFeat.setAttributes(atMap.values())

            if keep:
                writer.addFeature(outFeat)
            else:
                if not none:
                    writer.addFeature(outFeat)

            progress.setPercentage(int(c * total))
        del writer
Exemple #24
0
    def processAlgorithm(self, progress):
        target = dataobjects.getObjectFromUri(
            self.getParameterValue(self.TARGET))
        join = dataobjects.getObjectFromUri(self.getParameterValue(self.JOIN))

        summary = self.getParameterValue(self.SUMMARY) == 1
        keep = self.getParameterValue(self.KEEP) == 1

        sumList = self.getParameterValue(self.STATS).lower().split(',')

        targetProvider = target.dataProvider()
        joinProvider = join.dataProvider()

        targetFields = targetProvider.fields()
        joinFields = joinProvider.fields()

        fieldList = QgsFields()

        if not summary:
            joinFields = vector.testForUniqueness(targetFields, joinFields)
            seq = range(0, len(targetFields) + len(joinFields))
            targetFields.extend(joinFields)
            targetFields = dict(zip(seq, targetFields))
        else:
            numFields = {}
            for j in xrange(len(joinFields)):
                if joinFields[j].type() in [QVariant.Int, QVariant.Double]:
                    numFields[j] = []
                    for i in sumList:
                        field = QgsField(i + unicode(joinFields[j].name()),
                                         QVariant.Double, '', 24, 16)
                        fieldList.append(field)
            field = QgsField('count', QVariant.Double, '', 24, 16)
            fieldList.append(field)
            joinFields = vector.testForUniqueness(targetFields, fieldList)
            targetFields.extend(fieldList)
            seq = range(0, len(targetFields))
            targetFields = dict(zip(seq, targetFields))

        fields = QgsFields()
        for f in targetFields.values():
            fields.append(f)

        writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
            fields, targetProvider.geometryType(), targetProvider.crs())

        outFeat = QgsFeature()
        inFeatB = QgsFeature()
        inGeom = QgsGeometry()

        index = vector.spatialindex(join)

        mapP2 = dict()
        features = vector.features(join)
        for f in features:
            mapP2[f.id()] = QgsFeature(f)

        features = vector.features(target)
        total = 100.0 / len(features)
        for c, f in enumerate(features):
            inGeom = f.geometry()
            atMap1 = f.attributes()
            outFeat.setGeometry(inGeom)
            none = True
            joinList = []
            if inGeom.type() == QGis.Point:
                joinList = index.intersects(inGeom.buffer(10, 2).boundingBox())
                if len(joinList) > 0:
                    check = 0
                else:
                    check = 1
            else:
                joinList = index.intersects(inGeom.boundingBox())
                if len(joinList) > 0:
                    check = 0
                else:
                    check = 1

            if check == 0:
                count = 0
                for i in joinList:
                    inFeatB = mapP2[i]
                    if inGeom.intersects(inFeatB.geometry()):
                        count = count + 1
                        none = False
                        atMap2 = inFeatB.attributes()
                        if not summary:
                            atMap = atMap1
                            atMap2 = atMap2
                            atMap.extend(atMap2)
                            atMap = dict(zip(seq, atMap))
                            break
                        else:
                            for j in numFields.keys():
                                numFields[j].append(atMap2[j])

                if summary and not none:
                    atMap = atMap1
                    for j in numFields.keys():
                        for k in sumList:
                            if k == 'sum':
                                atMap.append(
                                    sum(self._filterNull(numFields[j])))
                            elif k == 'mean':
                                try:
                                    nn_count = sum(1 for _ in self._filterNull(
                                        numFields[j]))
                                    atMap.append(
                                        sum(self._filterNull(numFields[j])) /
                                        nn_count)
                                except ZeroDivisionError:
                                    atMap.append(NULL)
                            elif k == 'min':
                                try:
                                    atMap.append(
                                        min(self._filterNull(numFields[j])))
                                except ValueError:
                                    atMap.append(NULL)
                            elif k == 'median':
                                atMap.append(self._median(numFields[j]))
                            else:
                                try:
                                    atMap.append(
                                        max(self._filterNull(numFields[j])))
                                except ValueError:
                                    atMap.append(NULL)

                        numFields[j] = []
                    atMap.append(count)
                    atMap = dict(zip(seq, atMap))
            if none:
                outFeat.setAttributes(atMap1)
            else:
                outFeat.setAttributes(atMap.values())

            if keep:
                writer.addFeature(outFeat)
            else:
                if not none:
                    writer.addFeature(outFeat)

            progress.setPercentage(int(c * total))
        del writer
Exemple #25
0
def multi_buffering(layer, radii, callback=None):
    """Buffer a vector layer using many buffers (for volcanoes or rivers).

    This processing algorithm will keep the original attribute table and
    will add a new one for the hazard class name according to
    safe.definitions.fields.hazard_value_field.

    radii = OrderedDict()
    radii[500] = 'high'
    radii[1000] = 'medium'
    radii[2000] = 'low'

    Issue https://github.com/inasafe/inasafe/issues/3185

    :param layer: The layer to polygonize.
    :type layer: QgsVectorLayer

    :param radii: A dictionary of radius.
    :type radii: OrderedDict

    :param callback: A function to all to indicate progress. The function
        should accept params 'current' (int), 'maximum' (int) and 'step' (str).
        Defaults to None.
    :type callback: function

    :return: The buffered vector layer.
    :rtype: QgsVectorLayer
    """
    # Layer output
    output_layer_name = buffer_steps['output_layer_name']
    processing_step = buffer_steps['step_name']

    input_crs = layer.crs()
    feature_count = layer.featureCount()

    fields = layer.fields()
    # Set the new hazard class field.
    new_field = create_field_from_definition(hazard_class_field)
    fields.append(new_field)
    # Set the new buffer distances field.
    new_field = create_field_from_definition(buffer_distance_field)
    fields.append(new_field)

    buffered = create_memory_layer(
        output_layer_name, QGis.Polygon, input_crs, fields)
    data_provider = buffered.dataProvider()

    # Reproject features if needed into UTM if the layer is in 4326.
    if layer.crs().authid() == 'EPSG:4326':
        center = layer.extent().center()
        utm = QgsCoordinateReferenceSystem(
            get_utm_epsg(center.x(), center.y(), input_crs))
        transform = QgsCoordinateTransform(layer.crs(), utm)
        reverse_transform = QgsCoordinateTransform(utm, layer.crs())
    else:
        transform = None
        reverse_transform = None

    for i, feature in enumerate(layer.getFeatures()):
        geom = QgsGeometry(feature.geometry())

        if transform:
            geom.transform(transform)

        inner_ring = None

        for radius in radii:
            attributes = feature.attributes()

            # We add the hazard value name to the attribute table.
            attributes.append(radii[radius])
            # We add the value of buffer distance to the attribute table.
            attributes.append(radius)

            circle = geom.buffer(radius, 30)

            if inner_ring:
                circle.addRing(inner_ring)

            inner_ring = circle.asPolygon()[0]

            new_feature = QgsFeature()
            if reverse_transform:
                circle.transform(reverse_transform)

            new_feature.setGeometry(circle)
            new_feature.setAttributes(attributes)

            data_provider.addFeatures([new_feature])

        if callback:
            callback(current=i, maximum=feature_count, step=processing_step)

    # We transfer keywords to the output.
    buffered.keywords = layer.keywords
    buffered.keywords['layer_geometry'] = 'polygon'
    buffered.keywords['layer_purpose'] = layer_purpose_hazard['key']
    buffered.keywords['inasafe_fields'][hazard_class_field['key']] = (
        hazard_class_field['field_name'])

    check_layer(buffered)
    return buffered
Exemple #26
0
    def compute(self, inName, joinName, outName, summary, sumList, keep, progressBar):
        layer1 = ftools_utils.getVectorLayerByName(inName)
        provider1 = layer1.dataProvider()
        fieldList1 = ftools_utils.getFieldList(layer1)

        layer2 = ftools_utils.getVectorLayerByName(joinName)
        provider2 = layer2.dataProvider()

        fieldList2 = ftools_utils.getFieldList(layer2)
        fieldList = QgsFields()
        if provider1.crs() != provider2.crs():
            QMessageBox.warning(self, self.tr("CRS warning!"), self.tr("Warning: Input layers have non-matching CRS.\nThis may cause unexpected results."))
        if not summary:
            fieldList2 = ftools_utils.testForUniqueness(fieldList1, fieldList2)
            seq = range(0, len(fieldList1) + len(fieldList2))
            fieldList1.extend(fieldList2)
            fieldList1 = dict(zip(seq, fieldList1))
        else:
            numFields = {}
            for j in xrange(len(fieldList2)):
                if fieldList2[j].type() == QVariant.Int or fieldList2[j].type() == QVariant.Double:
                    numFields[j] = []
                    for i in sumList:
                        field = QgsField(i + unicode(fieldList2[j].name()), QVariant.Double, "real", 24, 16, self.tr("Summary field"))
                        fieldList.append(field)
            field = QgsField("COUNT", QVariant.Double, "real", 24, 16, self.tr("Summary field"))
            fieldList.append(field)
            fieldList2 = ftools_utils.testForUniqueness(fieldList1, fieldList)
            fieldList1.extend(fieldList)
            seq = range(0, len(fieldList1))
            fieldList1 = dict(zip(seq, fieldList1))

        sRs = provider1.crs()
        progressBar.setValue(13)
        check = QFile(self.shapefileName)
        if check.exists():
            if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName):
                QMessageBox.warning(
                    self, self.tr('Error deleting shapefile'),
                    self.tr("Can't delete existing shapefile\n%s") % (self.shapefileName))
                return False
        fields = QgsFields()
        for f in fieldList1.values():
            fields.append(f)
        writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fields, provider1.geometryType(), sRs)
        #writer = QgsVectorFileWriter(outName, "UTF-8", fieldList1, provider1.geometryType(), sRs)
        inFeat = QgsFeature()
        outFeat = QgsFeature()
        inFeatB = QgsFeature()
        inGeom = QgsGeometry()
        progressBar.setValue(15)
        start = 15.00
        add = 85.00 / provider1.featureCount()

        index = ftools_utils.createIndex(provider2)

        # cache all features from provider2 to avoid huge number of feature requests in the inner loop
        mapP2 = {}
        for f in provider2.getFeatures():
            mapP2[f.id()] = QgsFeature(f)

        fit1 = provider1.getFeatures()
        while fit1.nextFeature(inFeat):
            inGeom = inFeat.geometry()
            atMap1 = inFeat.attributes()
            outFeat.setGeometry(inGeom)
            none = True
            joinList = []
            if inGeom.type() == QGis.Point:
                #(check, joinList) = layer2.featuresInRectangle(inGeom.buffer(10,2).boundingBox(), True, True)
                #layer2.select(inGeom.buffer(10,2).boundingBox(), False)
                #joinList = layer2.selectedFeatures()
                joinList = index.intersects(inGeom.buffer(10, 2).boundingBox())
                if len(joinList) > 0:
                    check = 0
                else:
                    check = 1
            else:
                #(check, joinList) = layer2.featuresInRectangle(inGeom.boundingBox(), True, True)
                #layer2.select(inGeom.boundingBox(), False)
                #joinList = layer2.selectedFeatures()
                joinList = index.intersects(inGeom.boundingBox())
                if len(joinList) > 0:
                    check = 0
                else:
                    check = 1
            if check == 0:
                count = 0
                for i in joinList:
                    inFeatB = mapP2[i]  # cached feature from provider2
                    if inGeom.intersects(inFeatB.geometry()):
                        count = count + 1
                        none = False
                        atMap2 = inFeatB.attributes()
                        if not summary:
                            atMap = atMap1
                            atMap2 = atMap2
                            atMap.extend(atMap2)
                            atMap = dict(zip(seq, atMap))
                            break
                        else:
                            for j in numFields.keys():
                                numFields[j].append(atMap2[j])
                if summary and not none:
                    atMap = atMap1
                    for j in numFields.keys():
                        for k in sumList:
                            if k == "SUM":
                                atMap.append(sum(filter_null(numFields[j])))
                            elif k == "MEAN":
                                try:
                                    nn_count = sum(1 for _ in filter_null(numFields[j]))
                                    atMap.append(sum(filter_null(numFields[j])) / nn_count)
                                except ZeroDivisionError:
                                    atMap.append(NULL)
                            elif k == "MIN":
                                try:
                                    atMap.append(min(filter_null(numFields[j])))
                                except ValueError:
                                    atMap.append(NULL)
                            elif k == "MED":
                                atMap.append(myself(numFields[j]))
                            else:
                                try:
                                    atMap.append(max(filter_null(numFields[j])))
                                except ValueError:
                                    atMap.append(NULL)

                        numFields[j] = []
                    atMap.append(count)
                    atMap = dict(zip(seq, atMap))
            if none:
                outFeat.setAttributes(atMap1)
            else:
                outFeat.setAttributes(atMap.values())
            if keep: # keep all records
                writer.addFeature(outFeat)
            else: # keep only matching records
                if not none:
                    writer.addFeature(outFeat)
            start = start + add
            progressBar.setValue(start)
        del writer
        return True
Exemple #27
0
    def run(self):
        """Run method that performs all the real work"""

        # Create the dialog with elements (after translation) and keep reference
        # Only create GUI ONCE in callback, so that it will only load when the plugin is started
        if self.first_start == True:
            self.first_start = False
            self.dlg = NewRaptorDialog()
            self.dlg.cmbSpecies.currentTextChanged.connect(
                self.evt_cmbSpecies_changed)

        mc = self.iface.mapCanvas()
        self.dlg.spbLatitude.setValue(mc.center().y())
        self.dlg.spbLongitude.setValue(mc.center().x())
        self.dlg.dteLast.setDate(QDate.currentDate())

        map_layers = []
        for lyr in mc.layers():
            map_layers.append(lyr.name())
        missing_layers = []
        if not "Raptor Nests" in map_layers:
            missing_layers.append("Raptor Nests")
        if not "Raptor Buffer" in map_layers:
            missing_layers.append("Raptor Buffer")
        if not "Linear Buffer" in map_layers:
            missing_layers.append("Linear Buffer")
        if missing_layers:
            msg = "The following layers are missing from this project\n"
            for lyr in missing_layers:
                msg += "\n{}".format(lyr)
            QMessageBox.critical(self.dlg, "Missing Layers!", msg)
            return

        # show the dialog
        self.dlg.show()
        # Run the dialog event loop
        result = self.dlg.exec_()
        # See if OK was pressed
        if result:
            lyrNest = QgsProject.instance().mapLayersByName("Raptor Nests")[0]
            lyrBuffer = QgsProject.instance().mapLayersByName(
                "Raptor Buffer")[0]
            lyrLinear = QgsProject.instance().mapLayersByName(
                "Linear Buffer")[0]
            idxNestId = lyrNest.fields().indexOf("Nest_ID")
            valNestId = lyrNest.maximumValue(idxNestId) + 1
            valLat = self.dlg.spbLatitude.value()
            valLng = self.dlg.spbLongitude.value()
            valSpecies = self.dlg.cmbSpecies.currentText()
            valBuffer = self.dlg.spbBuffer.value()
            valStatus = self.dlg.cmbStatus.currentText()
            valLast = self.dlg.dteLast.date()
            QMessageBox.information(
                self.dlg, "Message",
                "New Nest ID: {}\nLatitude: {}\nLongitude: {}\nSpecies: {}\nBuffer: {}\nStatus: {}\nLast survey: {}"
                .format(valNestId, valLat, valLng, valSpecies, valBuffer,
                        valStatus, valLast))
            ftrNest = QgsFeature(lyrNest.fields())
            ftrNest.setAttribute("lat_y_dd", valLat)
            ftrNest.setAttribute("long_x_dd", valLng)
            ftrNest.setAttribute("recentspec", valSpecies)
            ftrNest.setAttribute("buf_dist", valBuffer)
            ftrNest.setAttribute("recentstat", valStatus)
            ftrNest.setAttribute("lastsurvey", valLast)
            ftrNest.setAttribute("Nest_ID", valNestId)
            geom = QgsGeometry(QgsPoint(valLng, valLat))
            ftrNest.setGeometry(geom)
            pr = lyrNest.dataProvider()
            pr.addFeatures([ftrNest])
            lyrNest.reload()

            pr = lyrBuffer.dataProvider()
            buffer = geom.buffer(valBuffer, 10)
            ftrNest.setGeometry(buffer)
            pr.addFeatures([ftrNest])
            lyrBuffer.reload()

            dlgTable = DlgTable()
            dlgTable.setWindowTitle(
                "Impacts Table for Nest {}".format(valNestId))
            #Find linear projects that will be impacted by the Nest
            bb = buffer.boundingBox()
            linears = lyrLinear.getFeatures(bb)
            for linear in linears:
                valId = linear.attribute("Project")
                valType = linear.attribute("type")
                valDistance = linear.geometry().distance(
                    geom)  #geom is de geometry of the nestpoint
                if valDistance < valBuffer:
                    # populate the table with linear data
                    row = dlgTable.tblImpacts.rowCount()
                    dlgTable.tblImpacts.insertRow(row)
                    dlgTable.tblImpacts.setItem(row, 0,
                                                QTableWidgetItem(str(valId)))
                    dlgTable.tblImpacts.setItem(row, 1,
                                                QTableWidgetItem(valType))
                    twi = QTableWidgetItem("{:4.5f}".format(valDistance))
                    twi.setTextAlignment(QtCore.Qt.AlignRight)
                    dlgTable.tblImpacts.setItem(row, 2, twi)
            dlgTable.tblImpacts.sortItems(2)
            dlgTable.show()
            dlgTable.exec_()

        else:
            QMessageBox.information(self.dlg, "Message",
                                    "Should only run if cancelled")
class Widget(QWidget):
    geometry_changed = pyqtSignal(QgsGeometry)

    def __init__(self, toolbar, parent=None):
        super(Widget, self).__init__(parent)
        uic.loadUi(
            os.path.join(os.path.dirname(__file__), 'gto_bufferselect.ui'),
            self)
        # from gtoAction
        self.toolbar = toolbar
        self.gtomain = self.toolbar.gtomain
        self.info = self.toolbar.info
        self.debug = self.toolbar.debug
        self.config = self.toolbar.config
        try:
            # references
            self.helper = self.gtomain.helper
            self.iface = self.gtomain.iface
            self.canvas = self.iface.mapCanvas()
            # references
            self.geo_original = QgsGeometry()
            self.geo_buffered = QgsGeometry()
            self.isCircle = False  # true=its a polgon geometry, but we need radius
            self.isRectangle = False
            # tool settings
            self.buffer_max = self.config.get('buffer_max', 100)
            self.sldBufferValue.setMaximum(self.buffer_max)
            self.sldBufferValue.setPageStep(self.buffer_max / 10)
            self.sldBufferValue.setSingleStep(self.buffer_max / 100)
            self.dblSpinBox.setMaximum(self.buffer_max)
            # init
            self.setOriginalGeometry(QgsGeometry(), False, False)
            # signals
            self.sldBufferValue.valueChanged.connect(self.buffer)
            self.dblSpinBox.valueChanged.connect(self.buffer)
            self.btnNewSelection.clicked.connect(lambda: self.select(0))
            self.btnAddSelection.clicked.connect(lambda: self.select(1))
            self.btnRemoveSelection.clicked.connect(lambda: self.select(2))
        except Exception as e:
            self.info.err(e)

    def setIconSizes(self, toolbar):
        try:
            self.btnNewSelection.setIconSize(toolbar.iconSize())
            self.btnAddSelection.setIconSize(toolbar.iconSize())
            self.btnRemoveSelection.setIconSize(toolbar.iconSize())
        except Exception as e:
            self.info.err(e)

    def setOriginalGeometry(self,
                            geo,
                            isValid,
                            isCircle=False,
                            isRectangle=False):
        self.isCircle = isCircle
        self.isRectangle = isRectangle
        if isValid and not geo.isEmpty():
            self.geo_original = geo
            self.geo_buffered = geo
        self.btnNewSelection.setEnabled(isValid and not geo.isEmpty())
        self.btnAddSelection.setEnabled(isValid and not geo.isEmpty())
        self.btnRemoveSelection.setEnabled(isValid and not geo.isEmpty())
        self.sldBufferValue.setEnabled(isValid and not geo.isEmpty())
        self.dblSpinBox.setEnabled(isValid and not geo.isEmpty())
        if geo.isEmpty():
            self.lblArea.setText('---')
        else:
            self.showInfo(geo)
        self.sldBufferValue.setValue(0)
        self.dblSpinBox.setValue(0)

    def buffer(self, value):
        try:
            if self.debug: self.info.log("buffer", "value", value)
            sld = self.sldBufferValue
            spin = self.dblSpinBox
            if sld.hasFocus():
                spin.setValue(value)
            else:
                sld.setValue(value)
            if self.debug: self.info.log(value)
            if value == 0:
                self.geo_buffered = self.geo_original
            else:
                self.geo_buffered = self.geo_original.buffer(
                    value, 100)  # roundfactor of buffer corner =3 (Segments)
                if self.isRectangle:
                    self.geo_buffered = QgsGeometry.fromRect(
                        self.geo_buffered.boundingBox())
            self.showInfo(self.geo_buffered)
            self.geometry_changed.emit(self.geo_buffered)
        except Exception as e:
            self.info.err(e)

    def select(self, mode):
        try:
            lay = self.iface.activeLayer()
            geo = self.geo_buffered
            req = QgsFeatureRequest()
            req.setFilterRect(geo.boundingBox())
            req.setNoAttributes()
            if mode == 0:
                selFeat = []
            else:
                selFeat = lay.selectedFeatureIds()
            for feat in lay.getFeatures(req):
                if geo.intersects(feat.geometry()):
                    if mode < 2:
                        selFeat.append(feat.id())
                    else:
                        try:
                            selFeat.remove(feat.id())
                        except:
                            pass
            lay.selectByIds(selFeat)
            self.gtomain.runcmd(self.config.get('tools', []))
        except Exception as e:
            self.info.err(e)

    def showInfo(self, geo):
        try:
            infoTxt = '---'
            lblInfo = self.lblArea
            if geo is not None:
                if geo.type() == QgsWkbTypes.PolygonGeometry:
                    if self.isCircle:
                        rec = geo.boundingBox()
                        radius = rec.width() / 2
                        if radius > 1000:
                            infoTxt = 'Radius: ' + str(round(radius / 1000,
                                                             4)) + ' km'
                        else:
                            infoTxt = 'Radius: ' + str(round(radius, 2)) + ' m'
                        if self.debug:
                            self.info.log("Fläche Kreis:", geo.area())
                    else:
                        if geo.area() > 1000000:
                            infoTxt = 'Fläche: ' + str(
                                round(geo.area() / 1000000, 4)) + ' km²'
                        else:
                            infoTxt = 'Fläche: ' + str(round(geo.area(),
                                                             2)) + ' m²'
                elif geo.type() == QgsWkbTypes.LineGeometry:
                    if geo.length() > 1000:
                        infoTxt = 'Länge: ' + str(round(
                            geo.length() / 1000, 4)) + ' km'
                    else:
                        infoTxt = 'Länge: ' + str(round(geo.length(),
                                                        1)) + ' m'
            lblInfo.setText(infoTxt)
        except Exception as e:
            self.info.err(e)
    def run(self):
        """Run method that performs all the real work"""

        # Create the dialog with elements (after translation) and keep reference
        # Only create GUI ONCE in callback, so that it will only load when the plugin is started
        if self.first_start == True:
            self.first_start = False
            self.dlg = Nuevo_nidoDialog()
            self.dlg.cmbnido.currentTextChanged.connect(
                self.event_estadochange)
        mapa = self.iface.mapCanvas()
        self.dlg.spbcoorx.setValue(mapa.center().x())
        self.dlg.spbcoory.setValue(mapa.center().y())
        self.dlg.QTDate.setDate(QDate.currentDate())
        capas_formulario = []
        for lyr in mapa.layers():
            capas_formulario.append(lyr.name())
        capas_faltantes = []
        if not "Avistamientos" in capas_formulario:
            capas_faltantes.append("Avistamientos")
        if not "Buffer Nidos" in capas_formulario:
            capas_faltantes.append("Buffer Nidos")
        if capas_faltantes:
            msg = "Faltan las siguientes capas en el proyecto para seguir"
            for lyrs in capas_faltantes:
                msg += f"\n {lyrs}"
            QMessageBox.critical(self.dlg, "capas faltantes", msg)
            return
        QMessageBox.information(self.dlg, "Mensaje",
                                "Esto debe correr siempre")
        # show the dialog
        self.dlg.show()
        # Run the dialog event loop
        result = self.dlg.exec_()
        # See if OK was pressed
        if result:
            # Do something useful here - delete the line containing pass and
            # substitute with your code.
            QMessageBox.information(self.dlg, "Mensaje",
                                    "Esto debe correr una vez si presiona ok")
            lry_avistamientos = QgsProject.instance().mapLayersByName(
                "Avistamientos")[0]
            lry_buffers = QgsProject.instance().mapLayersByName(
                "Buffer Nidos")[0]
            lry_buffer_lineal = QgsProject.instance().mapLayersByName(
                "Buffer Lineal")[0]
            indice = lry_avistamientos.fields().indexOf("nidoID")
            indice_max = lry_avistamientos.maximumValue(indice) + 1
            coorx = self.dlg.spbcoorx.value()
            coory = self.dlg.spbcoory.value()
            valor_especie = self.dlg.cmbespecie.currentText()
            valor_nido = self.dlg.cmbnido.currentText()
            valor_buffer = self.dlg.spbbuffer.value()
            valor_fecha = self.dlg.QTDate.date()
            feature_nido = QgsFeature(lry_avistamientos.fields())
            feature_nido.setAttribute("id", indice_max)
            feature_nido.setAttribute("coord_x", coorx)
            feature_nido.setAttribute("coord_y", coory)
            feature_nido.setAttribute("fecha", valor_fecha)
            feature_nido.setAttribute("especie", valor_especie)
            feature_nido.setAttribute("estado", valor_nido)
            feature_nido.setAttribute("dist_buf", valor_buffer)
            feature_nido.setAttribute("nidoID", indice_max)
            geom = QgsGeometry(QgsPoint(coorx, coory))
            feature_nido.setGeometry(geom)
            pr = lry_avistamientos.dataProvider()
            pr.addFeatures([feature_nido])
            lry_avistamientos.reload()
            pr = lry_buffers.dataProvider()
            buffer = geom.buffer(valor_buffer, 10)
            feature_nido.setGeometry(buffer)
            pr.addFeatures([feature_nido])
            lry_buffers.reload()
            tabla_impactos = tabla_dialog()
            bb = buffer.boundingBox()
            lineal = lry_buffer_lineal.getFeatures(bb)
            for linea in lineal:
                idvar = linea.attribute("Proyecto")
                idtipo = linea.attribute("Tipo")
                idbuffer = linea.geometry().distance(geom)
                if idbuffer < valor_buffer:
                    fila = tabla_impactos.tbl_impactos.rowCount()
                    tabla_impactos.tbl_impactos.insertRow(fila)
                    tabla_impactos.tbl_impactos.setItem(
                        fila, 0, QTableWidgetItem(str(idvar)))
                    tabla_impactos.tbl_impactos.setItem(
                        fila, 1, QTableWidgetItem(idtipo))
                    tabla_impactos.tbl_impactos.setItem(
                        fila, 2, QTableWidgetItem(f"{idbuffer:.2f}"))
            tabla_impactos.tbl_impactos.sortItems(2)
            tabla_impactos.show()
            tabla_impactos.exec_()
        else:
            QMessageBox.information(
                self.dlg, "Mensaje",
                "Esto debe correr una vez si presiona cancel o exit")
Exemple #30
0
    def traf(self,geometry,trafic,spatial,lines,echelle,angle_max,dist_min,double_sens):
        lignes=lines
        conn = db.connect(':memory:')
        conn.enable_load_extension(True)
        conn.execute("select load_extension('mod_spatialite')")
        c = conn.cursor()
        proj=str(self.lines.crs().postgisSrid())
        t=geometry[trafic]
        
        texte="select astext(st_buffer(st_geomfromtext('"+geometry.geometry().asWkt()+"',"+proj+"),"+str(echelle*t)+"))"
        rs = c.execute(texte)
        resultat=c.fetchall()
        conn.commit()
        texte_buf= resultat[0][0]
        texte_buf=texte_buf.replace("Polygon","MultiLineString")
        buf=QgsGeometry.fromWkt(texte_buf)
        #buf=buf.convertToType(QgsWkbTypes.LineGeometry,False)
        texte="select astext(st_union(st_exteriorring(st_geomfromtext('"+buf.asWkt()+"',"+proj+"))))"
        rs = c.execute(texte)
        resultat=c.fetchall()
        conn.commit()
        buf= QgsGeometry.fromWkt(resultat[0][0])
        #QgsMessageLog.logMessage(texte)
        #QgsMessageLog.logMessage(buf.asWkt())
        buf_poly=buf
        geom=geometry.geometry()
        buf_sav=buf
        buf_l=buf.length()
        l2=QgsLineString()
        #print(geom.asWkt())
        geom.convertToSingleType()
        #print(geom.asWkt())
        l2.fromWkt(geom.asWkt())
        #print(l2.asWkt())
        pt1=QgsGeometry(l2.startPoint())
        pt2=QgsGeometry(l2.endPoint())
        ###point debut
        debut=spatial.intersects(QgsGeometry.buffer(pt1,10,3).boundingBox())
        fe= [f for f in debut]

        feats=[]
        for f in fe:
            ff=QgsLineString()
            #QgsMessageLog.logMessage(lignes[f].geometry().asWkt())
            geom=lignes[f].geometry()
            geom.convertToSingleType()
            ff.fromWkt(geom.asWkt())
            #QgsMessageLog.logMessage(ff.asWkt())
            #print(pt1.distance(QgsGeometry(ff.startPoint())))
            if pt1.distance(QgsGeometry(ff.startPoint()))<10:
                if lignes[f] not in feats:
                    feats.append(f)
            elif pt1.distance(QgsGeometry(ff.endPoint()))<10:
                if lignes[f] not in feats:
                    feats.append(f)
        #QgsMessageLog.logMessage(str(fe))
        #QgsMessageLog.logMessage(str(feats))

                
            
        distances={}
        angles={}
        for i in feats:
            longueur=lignes[i].geometry().length()
            if not(geometry.id()==i):
                distances[i]=lignes[i].geometry().lineLocatePoint(pt1)
                if distances[i]<dist_min:
                    angles[i]=((lignes[i].geometry().interpolateAngle(min(dist_min,longueur))*180/math.pi)+180)%360
                else:
                    angles[i]=lignes[i].geometry().interpolateAngle(longueur-min(dist_min,longueur))*180/math.pi
            else:
                angle1=lignes[i].geometry().interpolateAngle(min(dist_min,longueur))*180/math.pi
        angle_maxi=1e38
        voisin=None
        angle_voisin=None
        angle2=None
        if len(distances)==0:
            angle=(angle1)%360
            angle2=angle1
            angle_voisin=angle2
        for i in distances:
            if distances[i]<dist_min:
                angle=(angles[i])%360
                min_angle=min(abs((angle+180)%360-(angle1+180)%360),abs(angle-angle1))
                if min_angle<angle_maxi:
                    angle_maxi=min_angle
                    angle_voisin=angle
                    voisin=i
            else:
                angle=angles[i]
                min_angle=min(abs((angle+180)%360-(angle1+180)%360),abs(angle-angle1))
                if min_angle<angle_maxi:
                    angle_maxi=min_angle
                    angle_voisin=angle
                    voisin=i

        if  min(abs((angle_voisin+180)%360-(angle1+180)%360),abs(angle_voisin-angle1))<angle_max:
            if abs((angle_voisin+180)%360-(angle1+180)%360)<abs(angle_voisin-angle1):
                angle2=(0.5*(((angle_voisin+180)%360+(angle1+180)%360))+180)%360
            else:
                angle2=0.5*(angle_voisin+angle1)
        else:
            angle2=angle1

        if angle2==None:
            angle2=(angle1)%360
        
        start_line=QgsGeometry.fromPolyline([QgsPoint(pt1.asPoint().x()-40*echelle*t*math.cos((180-angle2)*math.pi/180),pt1.asPoint().y()-40*echelle*t*math.sin((180-angle2)*math.pi/180)),QgsPoint(pt1.asPoint().x(),pt1.asPoint().y())])
        int1=buf.intersection(start_line)
        start_line2=QgsGeometry.fromPolyline([QgsPoint(pt1.asPoint().x()+40*echelle*t*math.cos((180-angle2)*math.pi/180),pt1.asPoint().y()+40*echelle*t*math.sin((180-angle2)*math.pi/180)),QgsPoint(pt1.asPoint().x(),pt1.asPoint().y())])
        int3=buf.intersection(start_line2)
        if int1.isMultipart():
            points=int1.asMultiPoint()
            dmax=1e38
            for p in points:
                d=pt1.distance(QgsGeometry.fromPointXY(p))
                if d<dmax:
                    dmax=d
                    pmax=p
            int1=QgsGeometry.fromPointXY(pmax)
        if int3.isMultipart():
            points=int3.asMultiPoint()
            dmax=1e38
            for p in points:
                d=pt1.distance(QgsGeometry.fromPointXY(p))
                if d<dmax:
                    dmax=d
                    pmax=p
            int3=QgsGeometry.fromPointXY(pmax)

        

        ###point fin

            
        debut=spatial.intersects(QgsGeometry.buffer(pt2,10,3).boundingBox())
        fe= [f for f in debut]
        for f in fe:
            ff=QgsLineString()
            geom=lignes[f].geometry()
            geom.convertToSingleType()
            ff.fromWkt(geom.asWkt())
            if pt2.distance(QgsGeometry(ff.startPoint()))<10:
                if lignes[f] not in feats:
                    feats.append(f)
            elif pt2.distance(QgsGeometry(ff.endPoint()))<10:
                if lignes[f] not in feats:
                    feats.append(f)
        distances={}
        angles={}
        for i in feats:
            longueur=lignes[i].geometry().length()
            if not(geometry.id()==i):
                distances[i]=lignes[i].geometry().lineLocatePoint(pt2)
                if distances[i]<dist_min:
                    angles[i]=(lignes[i].geometry().interpolateAngle(min(dist_min,longueur))*180/math.pi)%360
                else:
                    angles[i]=(((lignes[i].geometry().interpolateAngle(longueur-min(dist_min,longueur))*180)/math.pi)+180)%360
            else:
                 angle1=((lignes[i].geometry().interpolateAngle(longueur-min(dist_min,longueur))*180/math.pi))
        angle_maxi=1e38
        voisin=None
        angle_voisin=None
        angle2=None
        if len(distances)==0:
            angle=(angle1)%360
            angle2=angle1
            angle_voisin=angle2
        for i in distances:
            if distances[i]<dist_min:
                angle=(angles[i])
                min_angle=min(abs((angle+180)%360-(angle1+180)%360),abs(angle-angle1))
                if min_angle<angle_maxi:
                    angle_maxi=min_angle
                    angle_voisin=angle
                    voisin=i
            else:
                angle=(angles[i])
                min_angle=min(abs((angle+180)%360-(angle1+180)%360),abs(angle-angle1))
                if min_angle<angle_maxi:
                    angle_maxi=min_angle
                    angle_voisin=angle
                    voisin=i

        if  min(abs((angle_voisin+180)%360-(angle1+180)%360),abs(angle_voisin-angle1))<angle_max:
            if abs((angle_voisin+180)%360-(angle1+180)%360)<abs(angle_voisin-angle1):
                angle2=(0.5*(((angle_voisin+180)%360+(angle1+180)%360))+180)%360
            else:
                angle2=0.5*(angle_voisin+angle1)
        else:
            angle2=angle1
        if angle2==None:
            angle2=(angle1)%360


        end_line=QgsGeometry.fromPolyline([QgsPoint(pt2.asPoint().x()-40*echelle*t*math.cos((180-angle2)*math.pi/180),pt2.asPoint().y()-40*echelle*t*math.sin((180-angle2)*math.pi/180)),QgsPoint(pt2.asPoint().x(),pt2.asPoint().y())])
        int2=buf.intersection(end_line)
        end_line2=QgsGeometry.fromPolyline([QgsPoint(pt2.asPoint().x()+40*echelle*t*math.cos((180-angle2)*math.pi/180),pt2.asPoint().y()+40*echelle*t*math.sin((180-angle2)*math.pi/180)),QgsPoint(pt2.asPoint().x(),pt2.asPoint().y())])
        int4=buf.intersection(end_line2)
        
        int5=start_line.intersection(end_line)
        int6=start_line2.intersection(end_line2)
        m5=-1
        m6=-1
        
        if int5.type()==0:
            if int5.within(buf_poly):
                m5=1
        if int6.type()==0:
            if int6.within(buf_poly):
                m6=1
        
        if int2.isMultipart():
            points=int2.asMultiPoint()
            dmax=1e38
            for p in points:
                d=pt2.distance(QgsGeometry.fromPointXY(p))
                if d<dmax:
                    dmax=d
                    pmax=p
            int2=QgsGeometry.fromPointXY(pmax)
        if int4.isMultipart():
            points=int4.asMultiPoint()
            dmax=1e38
            for p in points:
                d=pt2.distance(QgsGeometry.fromPointXY(p))
                if d<dmax:
                    dmax=d
                    pmax=p
            int4=QgsGeometry.fromPointXY(pmax)


        #print(int1.exportToWkt(),int2.exportToWkt(),int3.exportToWkt(),int4.exportToWkt())
        #QgsMessageLog.logMessage(buf.asWkt())
        texte="select astext(st_union(st_snap(st_geomfromtext('"+buf.asWkt()+"',"+proj+"),st_geomfromtext('"+int1.asWkt()+"',"+proj+"),1)))"
        rs = c.execute(texte)
        resultat=c.fetchall()
        conn.commit()
        buf= resultat[0][0]
        #QgsMessageLog.logMessage(texte)
        #QgsMessageLog.logMessage(buf)
        #QgsMessageLog.logMessage(proj)
        #QgsMessageLog.logMessage(int2.asWkt())
        texte="select astext(st_union(st_snap(st_geomfromtext('"+buf+"',"+proj+"),st_geomfromtext('"+int2.asWkt()+"',"+proj+"),1)))"
        rs = c.execute(texte)
        resultat=c.fetchall()
        conn.commit()
        buf= resultat[0][0]
        texte="select astext(st_union(st_snap(st_geomfromtext('"+buf+"',"+proj+"),st_geomfromtext('"+int3.asWkt()+"',"+proj+"),1)))"
        rs = c.execute(texte)
        resultat=c.fetchall()
        conn.commit()
        buf= resultat[0][0]
        texte="select astext(st_union(st_snap(st_geomfromtext('"+buf+"',"+proj+"),st_geomfromtext('"+int4.asWkt()+"',"+proj+"),1)))"
        rs = c.execute(texte)
        resultat=c.fetchall()
        conn.commit()
        buf= QgsGeometry.fromWkt(resultat[0][0])

        m1=buf.lineLocatePoint(int1)        
        m2=buf.lineLocatePoint(int2)
        m3=buf.lineLocatePoint(int3)        
        m4=buf.lineLocatePoint(int4)

    #creation epaisseur

        buf_l=buf.length()
        m1=m1/buf_l
        m2=m2/buf_l
        m3=m3/buf_l
        m4=m4/buf_l


        if m2<m1:
            texte="select asText(st_line_substring(st_geomfromtext('"+buf.asWkt()+"',"+proj+")"+','+str(m2)+','+str(m1)+"))"

            rs = c.execute(texte)
            resultat=c.fetchall()
            conn.commit()
            buf1= QgsGeometry.fromWkt(resultat[0][0])


        else:
            texte="select astext(st_union(st_snap(st_line_substring(geomfromtext('"+buf.asWkt()+"',"+proj+"),0,"+str(m1)+"),st_line_substring(geomfromtext('"+buf.asWkt()+"',"+proj+"),"+str(m3)+",1),1),st_line_substring(geomfromtext('"+buf.asWkt()+"',"+proj+"),"+str(m2)+",1)))"
            rs = c.execute(texte)
            resultat=c.fetchall()
            conn.commit()
            buf1= QgsGeometry.fromWkt(resultat[0][0])
            
        if m3<m4:
            texte="select asText(st_line_substring(st_geomfromtext('"+buf.asWkt()+"',"+proj+")"+','+str(m3)+','+str(m4)+"))"
            rs = c.execute(texte)
            resultat=c.fetchall()
            conn.commit()
            buf2= QgsGeometry.fromWkt(resultat[0][0])


        else:

            texte="select astext(st_union(g)) from (select st_line_substring(st_geomfromtext('"+buf.asWkt()+"',"+proj+"),0,"+str(m4)+") as \"g\" union all select st_line_substring(st_geomfromtext('"+buf.asWkt()+"',"+proj+"),"+str(m3)+",1) as \"g\" )"
            rs = c.execute(texte)
            resultat=c.fetchall()
            conn.commit()
            buf2= QgsGeometry.fromWkt(resultat[0][0])
            texte="select astext(st_union(st_snap(st_line_substring(geomfromtext('"+buf.asWkt()+"',"+proj+"),0,"+str(m4)+"),st_line_substring(geomfromtext('"+buf.asWkt()+"',"+proj+"),"+str(m3)+",1),1),st_line_substring(geomfromtext('"+buf.asWkt()+"',"+proj+"),"+str(m3)+",1)))"

            rs = c.execute(texte)
            resultat=c.fetchall()
            conn.commit()
            buf2= QgsGeometry.fromWkt(resultat[0][0])

        


        


        
        g1=buf
        g2=buf.shortestLine(int1)
        g2=g2.combine(g1)
        g3=buf.shortestLine(int2)
        g3=g3.combine(g2)
        g3=g3.combine(pt1.shortestLine(int1))
        g3=g3.combine(pt2.shortestLine(int2))
        g3=g3.combine(pt1.shortestLine(geometry.geometry()))
        g3=g3.combine(pt2.shortestLine(geometry.geometry()))
        g3=g3.combine(geometry.geometry())
        buf3=buf1.asWkt()
        buf4=buf2.asWkt()
        if double_sens==False:
            if m5>0:
                texte="select astext(st_union(st_snap(geomfromtext('"+geometry.geometry().asWkt()+"',"+proj+"),geomfromtext('"+pt1.shortestLine(int5).asWkt()+"',"+proj+"),1),geomfromtext('"+pt1.shortestLine(int5).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt2.shortestLine(int5).asWkt()+"',"+proj+"),1),geomfromtext('"+pt2.shortestLine(int5).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]        
            else:
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+buf1.shortestLine(int1).asWkt()+"',"+proj+"),1),geomfromtext('"+buf1.shortestLine(int1).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+buf1.shortestLine(int2).asWkt()+"',"+proj+"),1),geomfromtext('"+buf1.shortestLine(int2).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt1.shortestLine(int1).asWkt()+"',"+proj+"),1),geomfromtext('"+pt1.shortestLine(int1).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt2.shortestLine(int2).asWkt()+"'),1),geomfromtext('"+pt2.shortestLine(int2).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt1.shortestLine(geometry.geometry()).asWkt()+"',"+proj+"),1),geomfromtext('"+pt1.shortestLine(geometry.geometry()).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]    
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt2.shortestLine(geometry.geometry()).asWkt()+"',"+proj+"),1),geomfromtext('"+pt2.shortestLine(geometry.geometry()).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+geometry.geometry().asWkt()+"',"+proj+"),1),geomfromtext('"+geometry.geometry().asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]
            
            
        else:

            if m5>0:
                texte="select astext(st_union(st_snap(geomfromtext('"+buf4+"',"+proj+"),geomfromtext('"+pt1.shortestLine(int3).asWkt()+"',"+proj+"),1),geomfromtext('"+pt1.shortestLine(int3).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt2.shortestLine(int4).asWkt()+"',"+proj+"),1),geomfromtext('"+pt2.shortestLine(int4).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt1.shortestLine(int5).asWkt()+"',"+proj+"),1),geomfromtext('"+pt1.shortestLine(int5).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt2.shortestLine(int5).asWkt()+"',"+proj+"),1),geomfromtext('"+pt2.shortestLine(int5).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]    

            elif m6>0:
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt1.shortestLine(int1).asWkt()+"',"+proj+"),1),geomfromtext('"+pt1.shortestLine(int1).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt2.shortestLine(int2).asWkt()+"',"+proj+"),1),geomfromtext('"+pt2.shortestLine(int2).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt1.shortestLine(int6).asWkt()+"',"+proj+"),1),geomfromtext('"+pt1.shortestLine(int6).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt2.shortestLine(int6).asWkt()+"',"+proj+"),1),geomfromtext('"+pt2.shortestLine(int6).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]        

            else:
                
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+buf1.shortestLine(int1).asWkt()+"',"+proj+"),1),geomfromtext('"+buf1.shortestLine(int1).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]
                    
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+buf1.shortestLine(int2).asWkt()+"',"+proj+"),1),geomfromtext('"+buf1.shortestLine(int2).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+int3.shortestLine(int1).asWkt()+"',"+proj+"),1),geomfromtext('"+int3.shortestLine(int1).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+int4.shortestLine(int2).asWkt()+"',"+proj+"),1),geomfromtext('"+int4.shortestLine(int2).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+buf2.shortestLine(int3).asWkt()+"',"+proj+"),1),geomfromtext('"+buf2.shortestLine(int3).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]    
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+buf2.shortestLine(int4).asWkt()+"',"+proj+"),1),geomfromtext('"+buf2.shortestLine(int4).asWkt()+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]
                texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+buf4+"',"+proj+"),1),geomfromtext('"+buf4+"',"+proj+")))"
                rs = c.execute(texte)
                resultat=c.fetchall()
                conn.commit()
                buf3= resultat[0][0]

        texte="select astext(st_buildarea(st_union(g))) from  ((select geomfromtext('"+buf3+"',"+proj+") as \"g\"))"
        rs = c.execute(texte)
        resultat=c.fetchall()
        conn.commit()

        buf=QgsGeometry.fromWkt(resultat[0][0])

        return(buf)