Python QgsGeometry.fromPolylineXY方法代码示例

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolylineXY [as 别名]
    def create_line(self, centroid, degree, radius):
        outer_ring = []

        outer_ring.append(centroid)
        outer_ring.append(self.create_point(centroid, math.radians(degree), radius))

        return QgsGeometry.fromPolylineXY(outer_ring)

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolylineXY [as 别名]
 def __signal_pbCopyKml_clicked(self, cheked):
     # Extent Openlayers
     action = "map.getExtent().toGeometry().toString();"
     wkt = self.webViewMap.page().mainFrame().evaluateJavaScript(action)
     rect = QgsGeometry.fromWkt(wkt).boundingBox()
     srsGE = QgsCoordinateReferenceSystem(
         4326, QgsCoordinateReferenceSystem.EpsgCrsId)
     coodTrans = QgsCoordinateTransform(self.__srsOL, srsGE,
                                        QgsProject.instance())
     rect = coodTrans.transform(
         rect, QgsCoordinateTransform.ForwardTransform)
     line = QgsGeometry.fromRect(rect).asPolygon()[0]
     wkt = str(QgsGeometry.fromPolylineXY(line).asWkt())
     # Kml
     proj4 = str(srsGE.toProj4())
     kmlLine = bindogr.exportKml(wkt, proj4)
     kml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"\
           "<kml xmlns=\"http://www.opengis.net/kml/2.2\" " \
           "xmlns:gx=\"http://www.google.com/kml/ext/2.2\" " \
           "xmlns:kml=\"http://www.opengis.net/kml/2.2\" " \
           "xmlns:atom=\"http://www.w3.org/2005/Atom\">" \
           "<Placemark>" \
           "<name>KML from Plugin Openlayers Overview for QGIS</name>" \
           "<description>Extent of openlayers map from Plugin Openlayers \
           Overview for QGIS</description>"\
           "%s" \
           "</Placemark></kml>" % kmlLine
     clipBoard = QApplication.clipboard()
     clipBoard.setText(kml)

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolylineXY [as 别名]
    def canvasReleaseEvent(self, event):
        if self.m2 and self.m1:
            self.reset()

        point = self.snappoint(event.pos())

        if not self.m1:
            self.m1 = QgsVertexMarker(self.canvas())
            self.m1.setIconType(1)
            self.m1.setColor(Qt.blue)
            self.m1.setIconSize(6)
            self.m1.setPenWidth(3)
            self.m1.setCenter(point)
            self.p1 = point
            return

        if not self.m2:
            self.m2 = QgsVertexMarker(self.canvas())
            self.m2.setIconType(1)
            self.m2.setColor(Qt.red)
            self.m2.setIconSize(6)
            self.m2.setPenWidth(3)
            self.m2.setCenter(point)
            self.p2 = point

        if self.m2 and self.m1:
            geom = QgsGeometry.fromPolylineXY([self.p1, self.p2])
            self.band.setToGeometry(geom, None)
            self.geometryComplete.emit(geom)

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolylineXY [as 别名]
 def __moved(self, position):
     if len(self.pointsToDraw) > 0:
         mapPos = self.canvas.getCoordinateTransform().toMapCoordinates(position["x"], position["y"])
         self.rubberband.reset(self.polygon)
         newPnt = QgsPointXY(mapPos.x(), mapPos.y())
         pnts = self.pointsToDraw + [newPnt]
         self.rubberband.setToGeometry(QgsGeometry.fromPolylineXY(pnts), None)

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolylineXY [as 别名]
    def processAlgorithm(self, parameters, context, feedback):
        if parameters[self.INPUT] == parameters[self.HUBS]:
            raise QgsProcessingException(
                self.tr('Same layer given for both hubs and spokes'))

        point_source = self.parameterAsSource(parameters, self.INPUT, context)
        hub_source = self.parameterAsSource(parameters, self.HUBS, context)
        fieldName = self.parameterAsString(parameters, self.FIELD, context)

        units = self.UNITS[self.parameterAsEnum(parameters, self.UNIT, context)]

        fields = point_source.fields()
        fields.append(QgsField('HubName', QVariant.String))
        fields.append(QgsField('HubDist', QVariant.Double))

        (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
                                               fields, QgsWkbTypes.LineString, point_source.sourceCrs())

        index = QgsSpatialIndex(hub_source.getFeatures(QgsFeatureRequest().setSubsetOfAttributes([]).setDestinationCrs(point_source.sourceCrs(), context.transformContext())))

        distance = QgsDistanceArea()
        distance.setSourceCrs(point_source.sourceCrs(), context.transformContext())
        distance.setEllipsoid(context.project().ellipsoid())

        # Scan source points, find nearest hub, and write to output file
        features = point_source.getFeatures()
        total = 100.0 / point_source.featureCount() if point_source.featureCount() else 0
        for current, f in enumerate(features):
            if feedback.isCanceled():
                break

            if not f.hasGeometry():
                sink.addFeature(f, QgsFeatureSink.FastInsert)
                continue
            src = f.geometry().boundingBox().center()

            neighbors = index.nearestNeighbor(src, 1)
            ft = next(hub_source.getFeatures(QgsFeatureRequest().setFilterFid(neighbors[0]).setSubsetOfAttributes([fieldName], hub_source.fields()).setDestinationCrs(point_source.sourceCrs(), context.transformContext())))
            closest = ft.geometry().boundingBox().center()
            hubDist = distance.measureLine(src, closest)

            if units != self.LAYER_UNITS:
                hub_dist_in_desired_units = distance.convertLengthMeasurement(hubDist, units)
            else:
                hub_dist_in_desired_units = hubDist

            attributes = f.attributes()
            attributes.append(ft[fieldName])
            attributes.append(hub_dist_in_desired_units)

            feat = QgsFeature()
            feat.setAttributes(attributes)

            feat.setGeometry(QgsGeometry.fromPolylineXY([src, closest]))

            sink.addFeature(feat, QgsFeatureSink.FastInsert)
            feedback.setProgress(int(current * total))

        return {self.OUTPUT: dest_id}

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolylineXY [as 别名]
def createLayerWithOneLine():
    # create a temporary layer
    # linelayer = iface.addVectorLayer("LineString?crs=epsg:4326&field=gid:int&field=name:string", "simple_line", "memory")
    linelayer = QgsVectorLayer("LineString?crs=epsg:4326&field=gid:int&field=name:string", "simple_line", "memory")
    one = QgsFeature(linelayer.dataProvider().fields(), 0)
    one.setAttributes([1, 'one'])
    one.setGeometry(QgsGeometry.fromPolylineXY([QgsPointXY(-7, 38), QgsPointXY(-8, 42)]))
    linelayer.dataProvider().addFeatures([one])
    return linelayer

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolylineXY [as 别名]
 def _setRubberBandMarker(self, geom):
     m = QgsRubberBand(self.qgisIface.mapCanvas(), False)  # not polygon
     if QgsWkbTypes.geometryType(geom.wkbType()) == QgsWkbTypes.LineGeometry:
         linegeom = geom
     elif QgsWkbTypes.geometryType(geom.wkbType()) == QgsWkbTypes.PolygonGeometry:
         linegeom = QgsGeometry.fromPolylineXY(geom.asPolygon()[0])
     m.setToGeometry(linegeom, None)
     m.setColor(QColor(self.config['rubber_color']))
     m.setWidth(self.config['rubber_width'])
     return m

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

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolylineXY [as 别名]
 def testWFSLineStrings(self):
     """
     Adds some lines, then check and clear all
     """
     layer_name = 'test_linestring'
     layer = self._getLayer(layer_name)
     wfs_layer = self._getWFSLayer(layer_name)
     feat1 = QgsFeature(wfs_layer.pendingFields())
     feat1['id'] = 11
     feat1['name'] = 'name 11'
     feat1.setGeometry(QgsGeometry.fromPolylineXY([QgsPointXY(9, 45), QgsPointXY(10, 46)]))
     feat2 = QgsFeature(wfs_layer.pendingFields())
     feat2.setGeometry(QgsGeometry.fromPolylineXY([QgsPointXY(9.5, 45.5), QgsPointXY(10.5, 46.5)]))
     feat2['id'] = 12
     feat2['name'] = 'name 12'
     old_features = [feat1, feat2]
     # Change feat1
     new_feat1 = QgsFeature(wfs_layer.pendingFields())
     new_feat1['id'] = 121
     new_feat1['name'] = 'name 121'
     new_feat1.setGeometry(QgsGeometry.fromPolylineXY([QgsPointXY(9.8, 45.8), QgsPointXY(10.8, 46.8)]))
     new_features = [new_feat1, feat2]
     self._testLayer(wfs_layer, layer, old_features, new_features)

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolylineXY [as 别名]
def _swap_qgs_geometry(qgsgeom):
    if qgsgeom.wkbType() == QgsWkbTypes.Point:
        p = qgsgeom.asPoint()
        qgsgeom = QgsGeometry.fromPointXY(QgsPointXY(p[1], p[0]))
    elif qgsgeom.wkbType() == QgsWkbTypes.MultiPoint:
        mp = qgsgeom.asMultiPoint()
        qgsgeom = QgsGeometry.fromMultiPointXY([QgsPointXY(p[1], p[0]) for p in mp])
    elif qgsgeom.wkbType() == QgsWkbTypes.LineString:
        pl = qgsgeom.asPolyline()
        qgsgeom = QgsGeometry.fromPolylineXY([QgsPointXY(p[1],p[0]) for p in pl])
    elif qgsgeom.wkbType() == QgsWkbTypes.MultiLineString:
        mls = qgsgeom.asMultiPolyline()
        qgsgeom = QgsGeometry.fromMultiPolylineXY([[QgsPointXY(p[1],p[0]) for p in pl] for pl in mls])
    elif qgsgeom.wkbType() == QgsWkbTypes.Polygon:
        pl = qgsgeom.asPolygon()
        qgsgeom = QgsGeometry.fromPolygonXY([[QgsPointXY(p[1],p[0]) for p in r] for r in pl])
    elif qgsgeom.wkbType() == QgsWkbTypes.MultiPolygon:
        mp = qgsgeom.asMultiPolygon()
        qgsgeom = QgsGeometry.fromMultiPolygonXY([[[QgsPointXY(p[1],p[0]) for p in r] for r in pl] for pl in mp])
    return qgsgeom

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolylineXY [as 别名]
    def canvasPressEvent(self, e):
        # find the side of the rectangle closest to the click and some data
        # necessary to compute the new cneter and scale
        topLeft, topRight, bottomRight, bottomLeft = \
            self.layer.cornerCoordinates()
        top = [topLeft, topRight]
        right = [bottomRight, topRight]
        bottom = [bottomRight, bottomLeft]
        left = [bottomLeft, topLeft]

        click = QgsGeometry.fromPointXY(self.toMapCoordinates(e.pos()))

        # order is important (for referenceSide)
        sides = [top, right, bottom, left]
        distances = [click.distance(
            QgsGeometry.fromPolylineXY(side)) for side in sides]
        self.indexSide = self.minDistance(distances)
        self.side = sides[self.indexSide]
        self.sidePoint = self.center(self.side)
        self.vector = self.directionVector(self.side)
        # side that does not move (opposite of indexSide)
        self.referenceSide = sides[(self.indexSide + 2) % 4]
        self.referencePoint = self.center(self.referenceSide)
        self.referenceDistance = self.distance(
            self.sidePoint, self.referencePoint)
        self.isXScale = self.indexSide % 2 == 1

        self.startPoint = click.asPoint()
        self.endPoint = self.startPoint
        self.isEmittingPoint = True

        self.isLayerVisible = isLayerVisible(self.iface,
                                             self.layer)
        setLayerVisible(self.iface, self.layer, False)

        adjustment = self.computeAdjustment()
        self.showAdjustment(*adjustment)
        self.layer.history.append(
            {"action": "adjust", "center": self.layer.center, "xScale": self.layer.xScale, "yScale": self.layer.yScale})

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolylineXY [as 别名]
    def processAlgorithm(self, parameters, context, feedback):
        """
        Here is where the processing itself takes place.
        """

        # Retrieve the feature source and sink. The 'dest_id' variable is used
        # to uniquely identify the feature sink, and must be included in the
        # dictionary returned by the processAlgorithm function.
        arrets = self.parameterAsSource(parameters, self.STOPS, context)
        stop_id=self.parameterAsFields(parameters,self.STOP_ID,context)[0]
        noeuds = self.parameterAsSource(parameters, self.NOEUDS, context)
        node_id=self.parameterAsFields(parameters,self.NODE_ID,context)[0]
        mode_i=self.parameterAsString(parameters,self.MODE_ORI,context)
        mode_j=self.parameterAsString(parameters,self.MODE_DES,context)
        texte_i=self.parameterAsString(parameters,self.TEXTE_ORI,context)
        texte_j=self.parameterAsString(parameters,self.TEXTE_DES,context)
        rayon=self.parameterAsDouble(parameters,self.RAYON,context)
        vitesse=self.parameterAsDouble(parameters,self.VITESSE,context)
        nb_max=self.parameterAsInt(parameters,self.MAX_NB,context)

        # Compute the number of steps to display within the progress bar and
        # get features from source
        ##a=fenetre.split(",")
        ##fenetre2=QgsRectangle(float(a[0]),float(a[2]),float(a[1]),float(a[3]))
        arr=[a for a in arrets.getFeatures()]
        nb=len(arr)
        
        index=QgsSpatialIndex(noeuds.getFeatures())
        champs=QgsFields()
        champs.append(QgsField('i',QVariant.String,len=15))
        champs.append(QgsField('j',QVariant.String,len=15))
        champs.append(QgsField(self.tr('length'),QVariant.Double))
        champs.append(QgsField(self.tr('time'),QVariant.Double))
        champs.append(QgsField(self.tr('mode'),QVariant.String,len=10))

        (table_connecteurs,dest_id) = self.parameterAsSink(parameters, self.CONNECTEURS,context,champs, QgsWkbTypes.LineString, noeuds.sourceCrs())
        nom_fichier=dest_id
        fichier_connecteurs=os.path.splitext(nom_fichier)[0]+".txt"
        sortie=codecs.open(fichier_connecteurs,"w",encoding="utf-8")
        nbc=0
        for i,n in enumerate(arr):
            near=index.nearestNeighbor(n.geometry().centroid().asPoint(),nb_max)
            feedback.setProgress(i*100/nb)
            if len(near)>0:
                for k,nearest in enumerate(near):
                    if k<nb_max:
                        f=noeuds.getFeatures(request=QgsFeatureRequest(nearest))
                        for j, g in enumerate(f):
                            if j==0:
                                l=n.geometry().distance(g.geometry())
                                id_node=unicode(g.attribute(node_id))
                                id_stop=unicode(n.attribute(stop_id))
                                if l<rayon:
                                    nbc+=1
                                    gline=QgsGeometry.fromPolylineXY([QgsPointXY(n.geometry().centroid().asPoint()),QgsPointXY(g.geometry().centroid().asPoint())])
                                    hline=QgsGeometry.fromPolylineXY([QgsPointXY(g.geometry().centroid().asPoint()),QgsPointXY(n.geometry().centroid().asPoint())])

                                    fline=QgsFeature()
                                    fline.setGeometry(gline)
                                    ll=gline.length()
                                    moda=unicode(mode_i)+unicode(mode_j)
                                    if vitesse<=0:
                                        fline.setAttributes([id_stop,id_node, ll/1000,0.0,moda])
                                    else:
                                        fline.setAttributes([id_stop,id_node, ll/1000,ll*60/(vitesse*1000),moda])
                                    fline2=QgsFeature()
                                    fline2.setGeometry(hline)
                                    modb=unicode(mode_j)+unicode(mode_i)
                                    if vitesse<=0:
                                        fline2.setAttributes([id_node,id_stop, ll/1000,0,modb])
                                    else:
                                        fline2.setAttributes([id_node,id_stop, ll/1000,ll*60/(vitesse*1000),modb])
                                    table_connecteurs.addFeature(fline)
                                    table_connecteurs.addFeature(fline2)
                                    if vitesse>0:
                                        sortie.write(id_node+';'+id_stop+';'+str((60/vitesse)*(ll/1000.0))+';'+str(ll/1000.0)+';-1;-1;-1;-1;-1;'+modb+';'+modb+'\n')
                                        sortie.write(id_stop+';'+id_node+';'+str((60/vitesse)*(ll/1000.0))+';'+str(ll/1000.0)+';-1;-1;-1;-1;-1;'+moda+';'+moda+'\n')
                                    else:
                                        sortie.write(id_node+';'+id_stop+';'+str(0.0)+';'+str(ll/1000.0)+';-1;-1;-1;-1;-1;'+modb +';'+modb+'\n')
                                        sortie.write(id_stop+';'+id_node+';'+str(0.0)+';'+str(ll/1000.0)+';-1;-1;-1;-1;-1;'+moda+';'+moda+'\n')
        feedback.setProgressText(unicode(nbc)+"/"+unicode(nb)+self.tr(" connected nodes"))
        sortie.close()
        return {self.OUTPUT: dest_id}

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

#.........这里部分代码省略.........
                            # QgsAbstractGeometry - QgsLineString
                            partgeom = QgsGeometry.fromPolyline(part)
                            inputlines.append(partgeom)  # QgsGeometry
                    else:
                        inputlines.append(geom)
                # There are only two possibilites for geometry type, so
                # this elif: could be replaced with an else:
                elif geometryType == QgsWkbTypes.PolygonGeometry:
                    # Polygons!
                    # We use a list of polygon geometries to be able to
                    # handle MultiPolygons
                    inputpolygons = []
                    if geom.isMultipart():
                        # Multi polygon
                        multipoly = geom.asMultiPolygon()
                        for geompoly in multipoly:
                            # list of list of QgsPointXY
                            # abstract geometry -> QgsGeometry polygon
                            polygeometry = QgsGeometry.fromPolygonXY(geompoly)
                            inputpolygons.append(polygeometry)
                    else:
                        # Non-multi polygon
                        # Make sure it is a QgsGeometry polygon
                        singlegeom = geom.asPolygon()
                        polygeometry = QgsGeometry.fromPolygonXY(singlegeom)
                        inputpolygons.append(polygeometry)  # QgsGeometry
                    # Add the polygon rings
                    for polygon in inputpolygons:
                        # create a list of list of QgsPointXY
                        poly = polygon.asPolygon()
                        for ring in poly:
                            # list of QgsPointXY
                            # Create a QgsGeometry line
                            geometryring = QgsGeometry.fromPolylineXY(ring)
                            inputlines.append(geometryring)  # QgsGeometry
                else:
                    # We should never end up here
                    self.status.emit("Unexpected geometry type!")
                # We introduce a list of line geometries for the tiling
                tilelinecoll = [None] * (len(tilegeoms) + 1)
                # Use the first element to store all the input lines
                # (for the over all histogram)
                tilelinecoll[0] = inputlines
                # Clip the lines based on the tile layer
                if self.tilelayer is not None:
                    i = 1  # The first one is used for the complete dataset
                    for tile in tilegeoms:  # Go through the tiles
                        # Create a list for the lines in the tile
                        newlines = []
                        for linegeom in inputlines:
                            # QgsGeometry
                            # Clip
                            clipres = linegeom.intersection(tile)
                            if clipres.isEmpty():
                                continue
                            if clipres.isMultipart():
                                # MultiLineString
                                clipresparts = clipres.constParts()
                                for clipline in clipresparts:
                                  # Create a QgsGeometry line
                                  linegeom = QgsGeometry.fromPolyline(clipline)
                                  newlines.append(linegeom)  # QgsGeometry
                            else:
                                # ?
                                newlines.append(clipres)
                        tilelinecoll[i] = newlines

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

#.........这里部分代码省略.........
                    if elements[istop] in arrets and trips[elements[iid]][1] in routes:
                        id_stop2=elements[istop]
                        id_trip2=elements[iid]
                        ligne=trips[elements[iid]][1]
                        num_ligne=routes[ligne][1].strip()
                        descr=routes[ligne][2].strip()
                        hi1=QTime(int(elements[ihdep][0:2]),int(elements[ihdep][3:5]),int(elements[ihdep][6:8]))
                        hj=QTime(int(elements[iharr][0:2]),int(elements[iharr][3:5]),int(elements[iharr][6:8]))
                        if (id_trip2==id_trip):
                            nbservices=0
                            nbs1=0
                            nbs2=0
                            if ("calendar.txt" in  os.listdir(nom_rep)):
                                if trips[elements[iid]][2] in calendar:
                                    dp=calendar[trips[elements[iid]][2]][1]
                                    fp=calendar[trips[elements[iid]][2]][2]
                                    nb_jours=(fin_periode-debut_periode).days
                                    for k in range(nb_jours+1):
                                        date_offre=debut_periode+datetime.timedelta(days=k)
                                        if dp<=date_offre<=fp:
                                            jour=date_offre.isoweekday()
                                            if int(calendar[trips[id_trip][2]][2+jour])==1:
                                                nbservices+=1
                                            if (trips[id_trip][2],date_offre,'1') in calendar_dates:
                                                    nbservices+=1
                                            if (trips[id_trip][2],date_offre,'2') in calendar_dates:
                                                    nbservices+=-1
                                    
                            elif trips[elements[iid]][2] in calendar_dates2:
                                for k in calendar_dates2[trips[elements[iid]][2]]:
                                    nbservices+=1
                            segment_id=(num_ligne, id_stop,id_stop2)
                            if (t1<=hi2<=t2):
                                nbs1=nbservices
                            if (t1<=hj<=t2):
                                nbs2=nbservices
                            if (id_stop,id_stop2) not in links:
                                links[(id_stop,id_stop2)]={}
                            if num_ligne not in links[(id_stop,id_stop2)]:
                                links[(id_stop,id_stop2)][num_ligne]=(1,nbs1,descr)
                            else:
                                seg= links[(id_stop,id_stop2)][num_ligne]
                                links[(id_stop,id_stop2)][num_ligne]=(1,seg[1]+nbs1,descr)
                                
                            arrets[id_stop][5]+=nbs1
                            arrets[id_stop2][4]+=nbs2
                        hi2=hi1
                        id_stop=id_stop2
                        id_trip=id_trip2
            feedback.setProgressText(self.tr("Generating arcs and lines..."))
            for i,s in enumerate(links):
                i1=0
                i2=0
                g_links=QgsFeature()
                g_arcs=QgsFeature()
                #print([unicode(s[0]),unicode(s[1]),unicode(s[0])+"-"+unicode(s[1])])
                g_links.setGeometry(QgsGeometry.fromPolylineXY([(xtr.transform(QgsPointXY(float(arrets[s[0]][2]),float(arrets[s[0]][3])))),xtr.transform(QgsPointXY(float(arrets[s[1]][2]),float(arrets[s[1]][3])))]))
                g_arcs.setAttributes([unicode(s[0]),unicode(s[1]),unicode(s[0])+"-"+unicode(s[1])])
                g_arcs.setGeometry(g_links.geometry())
                
                if g_arcs.geometry().length()<1600000:
                    l_arcs.addFeature(g_arcs)
                for t in links[s]:

                    if t=="" or t==None:
                        tt= " "
                    else:
                        tt=t
                    #print([tt.decode("cp1252"),links[s][t][2].decode("cp1252"),unicode(s[0]),unicode(s[1]),links[s][t][0],links[s][t][1],i1,i2])
                    try:
                        g_links.setAttributes([unicode(t),unicode(links[s][t][2]),unicode(s[0]),unicode(s[1]),links[s][t][0],links[s][t][1],i1,i2])
                    except:
                        print(t,links[s][t][2])
                    
                    i1+=1
                    i2+=links[s][t][1]
                    if g_links.geometry().length()<1600000:
                        l_links.addFeature(g_links)
            del(stop_times)
            del(trips)
            del(routes)
            del(calendar)
            del(calendar_dates)

        if (isnodes):

            for s in arrets:
                g_noeuds=QgsFeature()
                g_noeuds.setGeometry(QgsGeometry.fromPointXY(xtr.transform(QgsPointXY(float(arrets[s][2]),float(arrets[s][3])))))
                #print([unicode(arrets[s][0]),arrets[s][1].decode('cp1252'),arrets[s][4],arrets[s][5]])
                try:
                    g_noeuds.setAttributes([unicode(arrets[s][0]),unicode(arrets[s][1]),arrets[s][4],arrets[s][5]])
                except:
                    print(arrets[s][1])
                l_noeuds.addFeature(g_noeuds)
        del(arrets)
        del(l_noeuds)
        del(l_links)
        del(l_arcs)
        return {self.REP_GTFS: self.REP_GTFS}

# 需要导入模块: from qgis.core import QgsGeometry [as 别名]
# 或者: from qgis.core.QgsGeometry import fromPolylineXY [as 别名]
def run(bar,layer1_path,layer2_path,obstacles_path,research_ray):

    output = {}
    #layer1 receiver
    layer1 = QgsVectorLayer(layer1_path,"layer1","ogr")
    #layer 2 source
    layer2 = QgsVectorLayer(layer2_path,"layer2","ogr")
    layer2_feat_all_dict = {}
    layer2_feat_all = layer2.dataProvider().getFeatures()
    layer2_spIndex = QgsSpatialIndex()
    for layer2_feat in layer2_feat_all:
        layer2_spIndex.insertFeature(layer2_feat)
        layer2_feat_all_dict[layer2_feat.id()] = layer2_feat


    if obstacles_path is not None:
        obstacles_layer = QgsVectorLayer(obstacles_path,"obstacles","ogr")
        obstacles_feat_all = obstacles_layer.dataProvider().getFeatures()
        obstacles_spIndex = QgsSpatialIndex()
        obstacles_feat_all_dict = {}
        for obstacles_feat in obstacles_feat_all:
            obstacles_spIndex.insertFeature(obstacles_feat)
            obstacles_feat_all_dict[obstacles_feat.id()] = obstacles_feat


    layer1_feat_all = layer1.dataProvider().getFeatures()
    layer1_feat_total = layer1.dataProvider().featureCount()
    layer1_feat_number = 0

    for layer1_feat in layer1_feat_all:

        layer1_feat_number = layer1_feat_number + 1
        barValue = layer1_feat_number/float(layer1_feat_total)*100
        bar.setValue(barValue)

        # researches the layer2 points in a rectangle created by the research_ray
        # creates the search rectangle
        rect = QgsRectangle()
        rect.setXMinimum( layer1_feat.geometry().asPoint().x() - research_ray )
        rect.setXMaximum( layer1_feat.geometry().asPoint().x() + research_ray )
        rect.setYMinimum( layer1_feat.geometry().asPoint().y() - research_ray )
        rect.setYMaximum( layer1_feat.geometry().asPoint().y() + research_ray )

        layer2_request = layer2_spIndex.intersects(rect)

        layer2_points = []

        for layer2_id in layer2_request:

            layer2_feat = layer2_feat_all_dict[layer2_id]

            ray_to_test_length = compute_distance(layer1_feat.geometry().asPoint(),layer2_feat.geometry().asPoint())

            if ray_to_test_length <= research_ray:

                ray_to_test = QgsGeometry.fromPolylineXY( [ layer1_feat.geometry().asPoint() , layer2_feat.geometry().asPoint() ] )

                intersect = 0

                if obstacles_path is not None:
                    obstacles_request = obstacles_spIndex.intersects(ray_to_test.boundingBox())
                    for obstacles_id in obstacles_request:
                        if obstacles_feat_all_dict[obstacles_id].geometry().crosses(ray_to_test) == 1:
                            intersect = 1
                            break

                if intersect == 0:

                    layer2_points.append(layer2_feat.id())

                    output[layer1_feat.id()] = layer2_points

    return output