def snapGeometry(self, geometry, snapTolerance, mode=PreferNodes):
"""
Snaps a QgsGeometry in the reference layer
:param geometry: QgsGeometry
:param snapTolerance: float
:param mode: DsgGeometrySnapper.PreferNodes or DsgGeometrySnapper.PreferClosest
:return:
"""
center = QgsPointV2(geometry.boundingBox().center())
# Get potential reference features and construct snap index
refGeometries = []
searchBounds = geometry.boundingBox()
searchBounds.grow(snapTolerance)
# filter by bounding box to get candidates
refFeatureIds = self.index.intersects(searchBounds)
# End here in case we don't find candidates
if len(refFeatureIds) == 0:
return geometry
# speeding up the process to consider only intersecting geometries
refFeatureRequest = QgsFeatureRequest().setFilterFids(refFeatureIds)
for refFeature in self.referenceLayer.getFeatures(refFeatureRequest):
refGeometry = refFeature.geometry()
segments = self.breakQgsGeometryIntoSegments(refGeometry)
# testing intersection
for segment in segments:
if segment.intersects(searchBounds):
refGeometries.append(segment)
# End here in case we don't find geometries
if len(refGeometries) == 0:
return geometry
# building geometry index
refDict, index = self.buildReferenceIndex(refGeometries)
refSnapIndex = DsgSnapIndex(center, 10*snapTolerance)
for geom in refGeometries:
refSnapIndex.addGeometry(geom.geometry())
# Snap geometries
subjGeom = geometry.geometry().clone()
subjPointFlags = []
# Pass 1: snap vertices of subject geometry to reference vertices
for iPart in xrange(subjGeom.partCount()):
subjPointFlags.append([])
for iRing in xrange(subjGeom.ringCount(iPart)):
subjPointFlags[iPart].append([])
for iVert in xrange(self.polyLineSize(subjGeom, iPart, iRing)):
vidx = QgsVertexId(iPart, iRing, iVert, QgsVertexId.SegmentVertex)
p = QgsPointV2(subjGeom.vertexAt(vidx))
pF = QgsPoint(p.toQPointF())
snapPoint, snapSegment = refSnapIndex.getSnapItem(p, snapTolerance)
success = snapPoint or snapSegment
if not success:
subjPointFlags[iPart][iRing].append(DsgGeometrySnapper.Unsnapped )
else:
if mode == DsgGeometrySnapper.PreferNodes:
# Prefer snapping to point
if snapPoint:
subjGeom.moveVertex(vidx, snapPoint.getSnapPoint(p))
subjPointFlags[iPart][iRing].append(DsgGeometrySnapper.SnappedToRefNode)
elif snapSegment:
subjGeom.moveVertex( vidx, snapSegment.getSnapPoint(p))
subjPointFlags[iPart][iRing].append(DsgGeometrySnapper.SnappedToRefSegment)
elif mode == DsgGeometrySnapper.PreferClosest:
nodeSnap = None
segmentSnap = None
distanceNode = sys.float_info.max
distanceSegment = sys.float_info.max
if snapPoint:
nodeSnap = snapPoint.getSnapPoint(p)
nodeSnapF = QgsPoint(nodeSnap.toQPointF())
distanceNode = nodeSnapF.sqrDist(pF)
if snapSegment:
segmentSnap = snapSegment.getSnapPoint(p)
segmentSnapF = QgsPoint(segmentSnap.toQPointF())
distanceSegment = segmentSnapF.sqrDist(pF)
if snapPoint and (distanceNode < distanceSegment):
subjGeom.moveVertex( vidx, nodeSnap )
subjPointFlags[iPart][iRing].append(DsgGeometrySnapper.SnappedToRefNode)
elif snapSegment:
subjGeom.moveVertex(vidx, segmentSnap)
subjPointFlags[iPart][iRing].append(DsgGeometrySnapper.SnappedToRefSegment)
#nothing more to do for points
if isinstance(subjGeom, QgsPointV2):
return QgsGeometry(subjGeom)
# SnapIndex for subject feature
subjSnapIndex = DsgSnapIndex(center, 10*snapTolerance)
subjSnapIndex.addGeometry(subjGeom)
origSubjGeom = subjGeom.clone()
origSubjSnapIndex = DsgSnapIndex(center, 10*snapTolerance)
origSubjSnapIndex.addGeometry(origSubjGeom)
# Pass 2: add missing vertices to subject geometry
for refGeom in refGeometries:
for iPart in xrange(refGeom.geometry().partCount()):
for iRing in xrange(refGeom.geometry().ringCount(iPart)):
for iVert in xrange(self.polyLineSize(refGeom.geometry(), iPart, iRing)):
point = refGeom.geometry().vertexAt(QgsVertexId(iPart, iRing, iVert, QgsVertexId.SegmentVertex))
# QgsPoint used to calculate squared distance
pointF = QgsPoint(point.toQPointF())
snapPoint, snapSegment = subjSnapIndex.getSnapItem(point, snapTolerance)
success = snapPoint or snapSegment
if success:
# Snap to segment, unless a subject point was already snapped to the reference point
if snapPoint and (QgsPoint(snapPoint.getSnapPoint(point).toQPointF()).sqrDist(pointF) < 1E-16):
continue
elif snapSegment:
# Look if there is a closer reference segment, if so, ignore this point
pProj = snapSegment.getSnapPoint(point)
pProjF = QgsPoint(pProj.toQPointF())
closest = refSnapIndex.getClosestSnapToPoint(point, pProj)
closestF = QgsPoint(closest.toQPointF())
if pProjF.sqrDist(pointF) > pProjF.sqrDist(closestF):
continue
# If we are too far away from the original geometry, do nothing
if not origSubjSnapIndex.getSnapItem(point, snapTolerance):
continue
idx = snapSegment.idxFrom
subjGeom.insertVertex(QgsVertexId(idx.vidx.part, idx.vidx.ring, idx.vidx.vertex + 1, QgsVertexId.SegmentVertex), point)
subjPointFlags[idx.vidx.part][idx.vidx.ring].insert(idx.vidx.vertex + 1, DsgGeometrySnapper.SnappedToRefNode )
subjSnapIndex = DsgSnapIndex(center, 10*snapTolerance)
subjSnapIndex.addGeometry(subjGeom)
# Pass 3: remove superfluous vertices: all vertices which are snapped to a segment and not preceded or succeeded by an unsnapped vertex
for iPart in xrange(subjGeom.partCount()):
for iRing in xrange(subjGeom.ringCount(iPart)):
ringIsClosed = subjGeom.vertexAt(QgsVertexId(iPart, iRing, 0, QgsVertexId.SegmentVertex)) == subjGeom.vertexAt(QgsVertexId(iPart, iRing, subjGeom.vertexCount( iPart, iRing ) - 1, QgsVertexId.SegmentVertex))
nVerts = self.polyLineSize(subjGeom, iPart, iRing)
iVert = 0
while iVert < nVerts:
iPrev = ( iVert - 1 + nVerts ) % nVerts
iNext = ( iVert + 1 ) % nVerts
pMid = subjGeom.vertexAt(QgsVertexId( iPart, iRing, iVert, QgsVertexId.SegmentVertex))
pPrev = subjGeom.vertexAt(QgsVertexId( iPart, iRing, iPrev, QgsVertexId.SegmentVertex))
pNext = subjGeom.vertexAt(QgsVertexId( iPart, iRing, iNext, QgsVertexId.SegmentVertex))
pointOnSeg = self.projPointOnSegment( pMid, pPrev, pNext)
pointOnSegF = QgsPoint(pointOnSeg.toQPointF())
pMidF = QgsPoint(pMid.toQPointF())
dist = pointOnSegF.sqrDist(pMidF)
if subjPointFlags[iPart][iRing][iVert] == DsgGeometrySnapper.SnappedToRefSegment \
and subjPointFlags[iPart][iRing][iPrev] != DsgGeometrySnapper.Unsnapped \
and subjPointFlags[iPart][iRing][iNext] != DsgGeometrySnapper.Unsnapped \
and dist < 1E-12:
if (ringIsClosed and nVerts > 3 ) or ( not ringIsClosed and nVerts > 2 ):
subjGeom.deleteVertex(QgsVertexId(iPart, iRing, iVert, QgsVertexId.SegmentVertex))
del subjPointFlags[iPart][iRing][iVert]
iVert -= 1
nVerts -= 1
else:
# Don't delete vertices if this would result in a degenerate geometry
break
iVert += 1
return QgsGeometry(subjGeom)
def run(self):
"""Run method that performs all the real work"""
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
GTFSDir = self.dlg.GTFSLocation.text()
StopsFile = self.dlg.StopsFile.text()
stopID = self.dlg.stopID.text()
###StopsShapefileName = self.dlg.StopsShapefileName.text()
StopsShapefileName = "stops"
AddToMapCanvas = False
##GenerateTransitServiceData = True
SkipCalculationServiceData = False
TrailheadData_shp = self.dlg.TrailheadData.text()
BufferDistance = self.dlg.BufferDistance.text()
th_id_field = self.dlg.th_id_field.text()
th_name_field = self.dlg.th_name_field.text()
outputGeoJSON = self.dlg.outputGeoJSON.text()
PostGISExpr = self.dlg.tbPostGISExpr.text()
AddToMapCanvas = self.dlg.cbAddToMapCanvas.isChecked() # returns True if checked
SkipCalculationServiceData = self.dlg.SkipCalculationServiceData.isChecked() # returns True if checked
###trailBufferShpName = self.dlg.trailBufferShpName.text()
#in_format = []
#in_format.append("Shapefile")
#in_format.append("PostGIS")
#self.dlg.comboBox.addItems(in_format)
trailBufferShpName = "trailBuff"
working_dir_name = self.dlg.working_dir.text()
#
##shapefile_th = self.dlg.checkBoxShapefile.isChecked() # returns True if checked
##postGIS_th = self.dlg.checkBoxPostGIS.isChecked()
#
shapefile_th = self.dlg.radioButtonShapefile.isChecked() # returns True if checked
postGIS_th = self.dlg.radioButtonPostGIS.isChecked()
#
host_name = self.dlg.host_name.text()
port = self.dlg.port.text()
database_name = self.dlg.database_name.text()
uname = self.dlg.uname.text()
password = self.dlg.password.text()
postGIS_table_name = self.dlg.postGIS_table_name.text()
#
InputDataSpecified = False
if shapefile_th:
InputDataSpecified = True
if postGIS_th:
InputDataSpecified = True
#postGIS_th = True
#shapefile_th = True
working_dir = os.path.join(GTFSDir, working_dir_name)
#if working_dir doesn't exist, create it
if not os.path.exists(working_dir):
os.makedirs(working_dir)
TATShp = os.path.join(working_dir, "TAToutput.shp")
TATdShp = os.path.join(working_dir, "TATdoutput.shp")
THShp = os.path.join(working_dir, "TH.shp")
#
DList_TrailsStops = defaultdict(list)
#
#####output_shp =
##output_file = open(filename, 'w')
# See if OK was pressed
if result:
if InputDataSpecified:
start_time = datetime.datetime.now().replace(microsecond=0)
stop_id = "UNK"
stop_name = "UNK"
stop_lat = "UNK"
stop_lon = "UNK"
c_stop_id = 0
c_stop_name = 0
c_stop_lat = 0
c_stop_lon = 0
counter = 0
text_file = os.path.join(GTFSDir, StopsFile)
#text_file = 'C:/UWGIS/Geog569/Data/Test/stops.txt'
##
EPSG_code = 4326
EPSG_code_WM = 3857
crsSrc = QgsCoordinateReferenceSystem(4326) # WGS 84
crsDest = QgsCoordinateReferenceSystem(3857) # WGS 84 / Web Mercator
xform = QgsCoordinateTransform(crsSrc, crsDest)
rev_xform = QgsCoordinateTransform(crsDest, crsSrc)
##
#StopsShapefilePath = os.path.join(GTFSDir, StopsShapefileName + ".shp")
#StopsShapefileBufferPath = os.path.join(GTFSDir, StopsShapefileName + "BUFF.shp")
#StopsShapefilePathWM = os.path.join(GTFSDir, StopsShapefileName + "WM.shp")
StopsShapefilePath = os.path.join(working_dir, StopsShapefileName + ".shp")
StopsShapefileBufferPath = os.path.join(working_dir, StopsShapefileName + "BUFF.shp")
StopsShapefilePathWM = os.path.join(working_dir, StopsShapefileName + "WM.shp")
##
spatialReference = osgeo.osr.SpatialReference() #will create a spatial reference locally to tell the system what the reference will be
spatialReference.ImportFromEPSG(int(EPSG_code)) #here we define this reference to be the EPSG code
driver = osgeo.ogr.GetDriverByName('ESRI Shapefile') # will select the driver for our shp-file creation.
##
index = 0
spatialReferenceWM = osgeo.osr.SpatialReference() #will create a spatial reference locally to tell the system what the reference will be
spatialReferenceWM.ImportFromEPSG(int(EPSG_code_WM)) #here we define this reference to be the EPSG code
driver = osgeo.ogr.GetDriverByName('ESRI Shapefile') # will select the driver for our shp-file creation.
# create layer
#if shapefile_th_rb:
# print "USING Shapefiles!"
#if postGIS_th_rb:
# print "USING PostGIS!"
##vl = QgsVectorLayer("Point", "stop_points", "memory")
vl = QgsVectorLayer("Point?crs=EPSG:3857", "stop_points", "memory")
##vl.spatialReference
pr = vl.dataProvider()
#
# changes are only possible when editing the layer
vl.startEditing()
# add fields
pr.addAttributes([QgsField("stop_id", QVariant.String),QgsField("stop_name", QVariant.Int),QgsField("stop_lat", QVariant.Double),QgsField("stop_lon", QVariant.Double)])
index = 0
###print "two"
fieldnames = []
stop_lat = 0
stop_lon = 0
c_stop_id = 0
c_stop_name = 0
c_stop_lat = 0
c_stop_lon = 0
with open(text_file, 'r') as f:
first_line = f.readline()
fl = first_line.split(",")
counter = 0
for f in fl:
fieldnames.append(f)
#for f in fl:
#print f
if f == "stop_id":
c_stop_id = counter
if f == "stop_name":
c_stop_name = counter
if f == "stop_lat":
c_stop_lat = counter
#print "stop_lat is in column ", c_stop_lat
#print c_stop_lat
if f == "stop_lon":
c_stop_lon = counter
#print "stop_lon is in column ", c_stop_lon
##print c_stop_lon
##print "three"
counter = counter + 1
#
with open(text_file, 'r') as f:
lines = f.readlines()
for line in lines:
h = '"'
if h in line:
count = line.count(h)
print "Removed quote from line" + str(count)
while count > 0:
#print [pos for pos, char in enumerate(line) if char == c]
cc = [pos for pos, char in enumerate(line) if char == h]
d = ','
#print [pos for pos, char in enumerate(line) if char == d]
dd = [pos for pos, char in enumerate(line) if char == d]
startP = cc[0]
endP = cc[1]
for ddd in dd:
if (ddd > startP) and (ddd < endP):
extraCommaPos = ddd
line1 = line[0:startP]
line2 = line[(startP + 1):extraCommaPos]
line3 = line[(extraCommaPos + 1):(endP)]
line4 = line[(endP + 1):-1]
lineMod = line1 + line2 + line3 + line4
#print line
#print "Comma removed"
#print lineMod
line = lineMod
count = line.count(h)
l = str(line).split(",")
if l[c_stop_id] != "stop_id":
stop_id = l[c_stop_id]
if l[c_stop_name] != "stop_name":
stop_name = l[c_stop_name]
if l[c_stop_lat] != "stop_lat":
stop_lat = float(l[c_stop_lat])
if l[c_stop_lon] != "stop_lon":
stop_lon = float(l[c_stop_lon])
if type(stop_lat) == float:
if type (stop_lon) == float:
fet = QgsFeature()
stop_pt_WM = xform.transform(QgsPoint(stop_lon,stop_lat))
###print "Transformed point:", stop_pt_WM
#fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(stop_lon, stop_lat)))
fet.setGeometry(QgsGeometry.fromPoint(stop_pt_WM))
fet.setAttributes([stop_id, stop_name, stop_lat, stop_lon])
pr.addFeatures([fet])
vl.commitChanges()
#
# add layer to the legend
stops_extent = vl.extent()
xmin = stops_extent.xMinimum()
ymin = stops_extent.yMinimum()
xmax = stops_extent.xMaximum()
ymax = stops_extent.yMaximum()
##QgsMapLayerRegistry.instance().addMapLayer(vl)
#
# Add trailheads from postGIS if postGIS_th = True
#
if postGIS_th:
uri = QgsDataSourceURI()
# set host name, port, database name, username and password
#uri.setConnection("localhost", "5432", "dbname", "johny", "xxx")
uri.setConnection(host_name, port, database_name, uname, password)
print "made PostGIS connection successfully"
# set database schema, table name, geometry column and optionally
# subset (WHERE clause)
#uri.setDataSource("public", "roads", "the_geom", "cityid = 2643")
#uri.setDataSource("public", postGIS_table_name, "geom", PostGISExpr)
uri.setDataSource("public", postGIS_table_name, "geom", PostGISExpr)
#
#vlayer = QgsVectorLayer(uri.uri(), "layer name you like", "postgres")
DB_TH_layer = QgsVectorLayer(uri.uri(), "DB_TH_layer", "postgres")
if AddToMapCanvas:
QgsMapLayerRegistry.instance().addMapLayer(DB_TH_layer)
#
stop_extent = QgsVectorLayer("Polygon?crs=EPSG:4326", "stop_extent", "memory")
pr = stop_extent.dataProvider()
stop_extent.startEditing()
#
fet = QgsFeature()
#fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(stop_lon, stop_lat)))
#
stop_ex_SW = rev_xform.transform(QgsPoint(xmin, ymin))
stop_ex_NW = rev_xform.transform(QgsPoint(xmin, ymax))
stop_ex_NE = rev_xform.transform(QgsPoint(xmax, ymax))
stop_ex_SE = rev_xform.transform(QgsPoint(xmax, ymin))
print "Stops layer extent (lower):", stop_ex_SW
print "Stops layer extent (upper):", stop_ex_NE
##fet.setGeometry(QgsGeometry.fromPolygon([[QgsPoint(xmin,ymin),QgsPoint(xmin,ymax), QgsPoint(xmax,ymax), QgsPoint(xmax,ymin), QgsPoint(xmin,ymin)]]))
fet.setGeometry(QgsGeometry.fromPolygon([[stop_ex_SW, stop_ex_NW, stop_ex_NE, stop_ex_SE, stop_ex_SW]]))
pr.addFeatures([fet])
stop_extent.commitChanges()
if AddToMapCanvas:
QgsMapLayerRegistry.instance().addMapLayer(stop_extent)
#
print "overlay points! - using extent from stops"
overlayAnalyzer = QgsOverlayAnalyzer()
overlayAnalyzer.intersection(DB_TH_layer, stop_extent, THShp)
TH_layer = QgsVectorLayer(THShp, "TH_layer", "ogr")
if not TH_layer.isValid():
print "TH.shp layer failed to load!"
########## this adds trailheads to the map canvas ########QgsMapLayerRegistry.instance().addMapLayer(TH_layer)
iter = TH_layer.getFeatures()
#for feature in iter:
# geomIn = feature.geometry()
# #print geom.vectorType()
# featgeom = geomIn.exportToWkt()
# print featgeom
# geom = QgsGeometry.fromWkt(featgeom)
# #print geom2 #= QgsGeometry.fromWkt(featgeom)
# #if geom.isMultipart:
# # print "multi"
# feature_name = feature['name']
# feature_id = feature['FEAT_ID']
# print "geom.asPoint()"
# print geom.asPoint()
#
# add trailhead layer from shapefile if selected (assumes it is stored in WGS 84)
#
if shapefile_th:
trailhead_layer = QgsVectorLayer(TrailheadData_shp, "trailhead_layer", "ogr")
######### this adds trailsheads to map canvas############QgsMapLayerRegistry.instance().addMapLayer(trailhead_layer)
if not trailhead_layer.isValid():
print "trailhead layer failed to load!"
#
# create trailhead layer in Web Mercator
#
vltWM = QgsVectorLayer("Point?crs=EPSG:3857", "trailhead_points_WM", "memory")
prtWM = vltWM.dataProvider()
#
# changes - including adding fields - are only possible when editing the layer
vltWM.startEditing()
prtWM.addAttributes([QgsField("name", QVariant.String),QgsField("FEAT_ID", QVariant.Int)])
#
# Get the features from the trailhead layer that is loaded, from shp or db
# and convert to a WM dataset
#
if shapefile_th:
iter = trailhead_layer.getFeatures()
print "using shape"
for feature in iter:
geom = feature.geometry()
feature_name = feature['name']
feature_id = feature['FEAT_ID']
th_x = geom.asPoint().x()
th_y = geom.asPoint().y()
print th_x, th_y
trailhead_pt_WM = xform.transform(QgsPoint(geom.asPoint()))
fet = QgsFeature()
fet.setGeometry(QgsGeometry.fromPoint(trailhead_pt_WM))
fet.setAttributes([feature_name, feature_id])
prtWM.addFeatures([fet])
vltWM.commitChanges()
if postGIS_th:
trailhead_layer = QgsVectorLayer(THShp, "trailhead_layer", "ogr")
iter = trailhead_layer.getFeatures()
print "using postGIS"
for feature in iter:
geomIn = feature.geometry()
featgeom = geomIn.exportToWkt()
#featgeom = featgeom.replace("MultiPoint", "POINT")
#featgeom = featgeom.replace("((", "(")
#featgeom = featgeom.replace("))", ")")
#featgeom = '"' + str(featgeom) + '"'
geoString1 = featgeom.split('((')
geoString2 = geoString1[1].split('))')
#geoString22 = geoString2[0]
geoString = geoString2[0].split(' ')
ptX = float(geoString[0])
ptY = float(geoString[1])
#ptX = geoString[0]
#ptY = geoString[1]
#geomString = '"POINT (' + str(ptX) + " " + str(ptY) + ')"'
geomString = '"POINT (' + str(ptX) + " " + str(ptY) + ')"'
#print geomString
#geom = QgsGeometry.fromWkt(geomString)
geom = QgsGeometry.fromPoint(QgsPoint(ptX, ptY))
#geom = QgsGeometry.fromWkt("POINT (-122.24501049999997804 47.86390650000004143)")
###geom = feature.geometry()
###feature_name = feature['name']
###feature_id = feature['FEAT_ID']
feature_name = feature[th_name_field]
feature_id = feature[th_id_field]
trailhead_pt_WM = xform.transform(QgsPoint(geom.asPoint()))
fet = QgsFeature()
fet.setGeometry(QgsGeometry.fromPoint(trailhead_pt_WM))
fet.setAttributes([feature_name, feature_id])
prtWM.addFeatures([fet])
vltWM.commitChanges()
###fet = QgsFeature()
#####feature.asPoint()
####print feature
###fet.setGeometry(QgsGeometry.fromPoint(trailhead_pt_WM))
###fet.setAttributes([feature_name, feature_id])
###prtWM.addFeatures([fet])
###vltWM.commitChanges()
###fet.setGeometry(QgsGeometry.fromPoint(trailhead_pt_WM))
###fet.setGeometry(geom)
###fet.setAttributes([feature_name, feature_id])
####print "geom"
####print geom
###trailhead_pt_WM = xform.transform(QgsPoint(geom.asPoint()))
###prtWM.addFeatures([fet])
###vltWM.commitChanges()
#
# Add WM trailheads to the map canvas
#
#print "PostGISExpr"
#print PostGISExpr
#if PostGISExpr == "":
# print "NO EXPR!"
if AddToMapCanvas:
QgsMapLayerRegistry.instance().addMapLayer(vltWM)
#QgsMapLayerRegistry.instance().addMapLayer(vltWM)
# Buffer stops
vltb = QgsVectorLayer("Point?crs=EPSG:3857", "trailhead_buffer_dissolved", "memory")
#
#QgsGeometryAnalyzer().dissolve(vlt, vltb, onlySelectedFeatures=False, uniqueIdField=-1, p=None)
# Buffer stops
geometryanalyzer = QgsGeometryAnalyzer()
geometryanalyzer.buffer(vltWM, StopsShapefileBufferPath + ".shp", int(BufferDistance), False, False, -1)
trailheadBuffer_layer = QgsVectorLayer(StopsShapefileBufferPath + ".shp", "trailhead_buffer_layer", "ogr")
if AddToMapCanvas:
QgsMapLayerRegistry.instance().addMapLayer(trailheadBuffer_layer)
#
geometryanalyzer.buffer(vltWM, StopsShapefileBufferPath + "d.shp", int(BufferDistance), False, True, -1)
#trailheadBufferd_layer = QgsVectorLayer(StopsShapefileBufferPath + "d.shp", "trailhead_buffer_d", "ogr")
trailheadBufferd_layer = QgsVectorLayer(StopsShapefileBufferPath + "d.shp", "trailhead_buffer_d", "ogr")
if AddToMapCanvas:
QgsMapLayerRegistry.instance().addMapLayer(trailheadBufferd_layer)
#
# overlay - using dissolved buffer
#
print "overlay points! - using dissolved buffers"
overlayAnalyzer = QgsOverlayAnalyzer()
#overlayAnalyzer.intersection(vl, vlt, "C:/UWGIS/Geog569/Data/Test/TAToutput.shp")
overlayAnalyzer.intersection(vl, trailheadBufferd_layer, TATdShp)
TATd_layer = QgsVectorLayer(TATdShp, "TransitStops_diss_layer", "ogr")
###TATd_layer = QgsVectorLayer(TATdShp, "TrAccTrailheads_diss_layer", "ogr")
if not TATd_layer.isValid():
print "TATd layer failed to load!"
if AddToMapCanvas:
QgsMapLayerRegistry.instance().addMapLayer(TATd_layer)
iter = TATd_layer.getFeatures()
stopList = []
for feature in iter:
# retrieve every feature with its geometry and attributes
feature_id = feature[stopID]
stopList.append(feature_id)
#feature_id = feature['FEAT_ID']
#for s in stopList:
# print s
#
# overlay - using the indivdual buffered points
# this can be used to compute distance between trailhaeds and each stop in its buffer
#
print "overlay points! - using dissolved buffers"
overlayAnalyzer = QgsOverlayAnalyzer()
#overlayAnalyzer.intersection(vl, vlt, "C:/UWGIS/Geog569/Data/Test/TAToutput.shp")
overlayAnalyzer.intersection(vl, trailheadBuffer_layer, TATShp)
TAT_layer = QgsVectorLayer(TATShp, "TransitStops_NonDissolved_layer", "ogr")
#TAT_layer = QgsVectorLayer(TATShp, "TrAccTrailheads_layer", "ogr")
if not TAT_layer.isValid():
print "TAT layer failed to load!"
if AddToMapCanvas:
QgsMapLayerRegistry.instance().addMapLayer(TAT_layer)
iter = TAT_layer.getFeatures()
THstopList = []
for feature in iter:
# retrieve every feature with its geometry and attributes
###trailhead_name = feature['name']
trailhead_id = feature[th_id_field]
feature_id = feature[th_id_field]
TH_Stop = str(trailhead_id) + ":" + str(feature_id)
#print feature['stop_id']
THstopList.append(TH_Stop)
DList_TrailsStops[trailhead_id].append(feature_id)
#feature_id = feature['FEAT_ID']
#for s in THstopList:
# print s
#for s in DList_TrailsStops:
# print s, DList_TrailsStops[s]
# #print DList_TrailsStops[s]
print xmin, ymin, xmax, ymax
fet = QgsFeature()
stop_pt_WM = rev_xform.transform(QgsPoint(xmin, ymin))
print "Stops layer extent (lower):", stop_pt_WM
#fet.setGeometry(QgsGeometry.fromPoint(QgsPoint(stop_lon, stop_lat)))
stop_pt_WM = rev_xform.transform(QgsPoint(xmax, ymax))
print "Stops layer extent (upper):", stop_pt_WM
print self.plugin_dir
sys.argv = [GTFSDir, stopList]
missing_files = []
all_files_present = True
fn_stop_times = "stop_times.txt"
f_stop_times = os.path.join(GTFSDir, fn_stop_times)
if not os.path.exists(f_stop_times):
all_files_present = False
missing_files.append(fn_stop_times)
fn_stops = "stops.txt"
f_stops = os.path.join(GTFSDir, fn_stops)
if not os.path.exists(f_stops):
all_files_present = False
missing_files.append(fn_stops)
fn_trips = "trips.txt"
f_trips = os.path.join(GTFSDir, fn_trips)
if not os.path.exists(f_trips):
all_files_present = False
missing_files.append(fn_trips)
fn_routes = "routes.txt"
f_routes = os.path.join(GTFSDir, fn_routes)
if not os.path.exists(f_routes):
all_files_present = False
missing_files.append(fn_routes)
fn_agency = "agency.txt"
f_agency = os.path.join(GTFSDir, fn_agency)
if not os.path.exists(f_agency):
all_files_present = False
missing_files.append(fn_agency)
#if working_dir doesn't exist, create it
###if os.path.exists(f_stop_times):
if all_files_present:
if not SkipCalculationServiceData:
print "starting service analysis...this might take some time"
SummarizeTransitService = os.path.join(self.plugin_dir, "SummarizeTransitService.py")
execfile(SummarizeTransitService)
else:
print "The GTFS appears to be incomplete. The following files seem to be missing."
#print "The GTFS appears to be incomplete. Check that all parts are present and try again."
for f in missing_files:
print f
##create empty dictionary
## BEGIN DISTANCE CODE!
distance_dictionary = {}
DList_TH_stops = defaultdict(list)
### (temporarily) set ref to TAT in case
##Enter data into Dictionary
iter = vltWM.getFeatures()
#iter = TAToutput.getFeatures()
##THstopList = []
for feature in iter:
##identifies attributes for future use
#print "Feature ID %d: " % feature.id()
trailhead_id = feature[str('FEAT_ID')]
#print trailhead_id
geom = feature.geometry()
th_x = geom.asPoint().x()
th_y = geom.asPoint().y()
th_point = QgsPoint(th_x,th_y)
#transit_stop_id = feature['stop_id']
iter_stops = TAT_layer.getFeatures() ###[new layer here?]
for stop_feature in iter_stops:
stop_id = stop_feature[str('stop_id')]
th_id = stop_feature[str('FEAT_ID')]
if th_id == trailhead_id:
stop_geom = stop_feature.geometry()
stop_id = stop_feature['stop_id']
DList_TH_stops[th_id].append(stop_id)
stop_x = stop_geom.asPoint().x()
stop_y = stop_geom.asPoint().y()
s_point = QgsPoint(stop_x,stop_y)
stop_distance = 0
a = numpy.array(th_point)
b = numpy.array(s_point)
##stop_distance = numpy.sqrt(numpy.sum(a-b)**2)
stop_distance = math.sqrt(th_point.sqrDist(s_point))
#print th_id
#print stop_id
#print stop_distance
####print math.sqrt(th_point.sqrDist(s_point))
th_stop = str(trailhead_id) + ":" + str(stop_id)
distance_dictionary[th_stop] = stop_distance
#if stop_distance < BufferDistance:
# distance_dictionary[th_stop] = stop_distance
##outputGeoJSON
vl_outTH = QgsVectorLayer("Point?crs=EPSG:4326", "stop_points", "memory")
pr_outTH = vl_outTH.dataProvider()
#
# changes are only possible when editing the layer
vl_outTH.startEditing()
# add fields
##pr_outTH.addAttributes([QgsField(th_id_field, QVariant.Int),QgsField(th_name_field, QVariant.String),QgsField("number_stops_nearby", QVariant.Int),QgsField("stops_near", QVariant.String),QgsField("stops_near_dist", QVariant.String)])
pr_outTH.addAttributes([QgsField(th_id_field, QVariant.Int),QgsField(th_name_field, QVariant.String),QgsField("number_stops_nearby", QVariant.Int),QgsField("stops_near", QVariant.String),QgsField("stops_distances", QVariant.String)])
index = 0
iter = trailhead_layer.getFeatures()
for feature in iter:
geom = feature.geometry()
feature_id = feature[th_id_field]
feature_name = feature[th_name_field]
#stops_near = str(DList_TH_stops[feature_id])
num_stops_near = 0
stops_near_in = DList_TH_stops[feature_id]
stops_near = []
for t in stops_near_in:
#print t
if not t in stops_near:
stops_near.append(t)
stops_near.sort()
num_stops_near = len(stops_near)
stops_near = str(stops_near)
stops_near = stops_near.replace("u'", "")
stops_near = stops_near.replace("'", "")
stops_near = stops_near.replace("[", "")
stops_near = stops_near.replace("]", "")
#print stops_near
dist_list = []
stop_list = []
stop_dist_list = []
stops_near_L = DList_TH_stops[feature_id]
stops_near_L.sort()
for s in stops_near_L:
#print s
k = str(feature_id) + ":" + str(s)
dist = distance_dictionary[k]
dist = int(dist)
#stop_list_data = str(s) + ', '
#dist_list_data = str(dist) + ', '
dist_list_data = '{stop_id: ' + str(s) + ', distance ' + str(dist) + '}'
if not dist_list_data in dist_list:
dist_list.append(dist_list_data)
stop_list.append(s)
stop_dist_list.append(dist)
#dist_list.sort()
#trailhead_pt_WM = xform.transform(QgsPoint(geom.asPoint()))
#print "dist_list"
#print dist_list
#dist_list = dist_list.replace("u'", "")
#dist_list = dist_list.replace("'", "")
dist_list = str(dist_list)
dist_list = dist_list.replace("[", "")
dist_list = dist_list.replace("]", "")
dist_list = dist_list.replace("'", "")
fet = QgsFeature()
fet.setGeometry(geom)
stop_list = str(stop_list)
stop_list = stop_list.replace("u'", "'")
stop_dist_list = str(stop_dist_list)
#fet.setGeometry(QgsGeometry.fromPoint(geom))
#fet.setAttributes([feature_id, feature_name, num_stops_near, stops_near, dist_list])
fet.setAttributes([feature_id, feature_name, num_stops_near, stop_list, stop_dist_list])
pr_outTH.addFeatures([fet])
vl_outTH.commitChanges()
GeoJSONfile = os.path.join(GTFSDir, outputGeoJSON)
writeString = ""
QgsVectorFileWriter.writeAsVectorFormat(vl_outTH, GeoJSONfile, "utf-8", None, "GeoJSON")
#file = open(GeoJSONfile, "w")
##file.write(fieldnames + "\n")
#iter = vltWM.getFeatures()
#for feature in iter:
# ##identifies attributes for future use
# #print "Feature ID %d: " % feature.id()
# trailhead_id = feature[str('FEAT_ID')]
# #trailhead_id = feature['FEAT_ID']
# geom = feature.geometry()
# th_x = geom.asPoint().x()
# th_y = geom.asPoint().y()
# writeLine = ''
# writeLine = '{ "type": "Feature", "properties": { "FEAT_ID": ' + str(trailhead_id) # + '\n'
# #writeLine = writeLine + ' "STOPS_NEARBY": ' + str(DList_TH_stops[trailhead_id]) ###'\n'
# writeLine = writeLine + ' "STOPS_NEARBY": ' + DList_TH_stops[trailhead_id] ###'\n'
# writeLine = writeLine + ' }, "geometry": { "type": "Point", "coordinates": [ '
# writeLine = writeLine + str(th_x) + ' ' + str(th_x) + ' ] } }'
# writeLine = writeLine + ', \n'
# writeString = writeString + writeLine
#file.write(writeString)
#file.close()
end_time = datetime.datetime.now().replace(microsecond=0)
print(end_time-start_time)
print "done"
else:
print "Input trailhead data was not specified"
