def DownloadOsTiles(tileCode1, tileCode2):

	tileCorner1 = osgb.os_streetview_tile_to_grid(tileCode1)
	print tileCorner1

	tileCorner2 = osgb.os_streetview_tile_to_grid(tileCode2)
	print tileCorner2

	er = range(int(tileCorner1[0]), int(tileCorner2[0]+5000), 5000)
	nr = range(int(tileCorner1[1]), int(tileCorner2[1]+5000), 5000)
	skipping = False
	
	for e in er:
		for n in nr:
			tileCode = osgb.grid_to_os_streetview_tile((e, n))[0]

			#if tileCode.upper() == "SO04SE": skipping = False
			if skipping is True: continue
			print e, n, tileCode 
			ProcessTile(tileCode, userpass, baseurl, "existing/su")
Exemple #2
0
def JsonToOsm(fina, finaOut, margin, tileCode):

	finaSplit = os.path.split(fina)
	tileCode = finaSplit[-1][:6]
	tileDirParts = finaSplit[0].split("/")[:-1]
	tileDir = ""
	for partNum, part in enumerate(tileDirParts):
		tileDir += part + "/"

	tileCorner = osgb.os_streetview_tile_to_grid(tileCode)
	print tileCorner
	
	#Load json tiles for surrounding areas
	jsonTiles = []
	tileCorners = []
	tileCodes = []
	for e in range(-5000, 10000, 5000):
		jsonTileRow = []
		cornerRow = []
		tileCodeRow = []
		for n in range(-5000, 10000, 5000):
			iterTileCode = osgb.grid_to_os_streetview_tile((tileCorner[0]+e, tileCorner[1]+n))[0]

			tileFina = tileDir+iterTileCode[:2].lower() + "/" + iterTileCode.lower() + ".json.bz2"
			print "Load", tileFina
			if os.path.exists(tileFina):
				try:
					contentJson = bz2.BZ2File(tileFina).read()
				except:
					print "Error decoding bz2 in file:", tileFina
					continue

				try:
					decodedContent = json.loads(contentJson)
				except ValueError as err:
					print "Error decoding json in file:", tileFina
					continue

				jsonTileRow.append(decodedContent)
				cornerRow.append((tileCorner[0]+e-margin, tileCorner[1]+n-margin))
				tileCodeRow.append(iterTileCode)
			else:
				print "Warning: tile not found", tileFina
				jsonTileRow.append(None)
				cornerRow.append(None)
				tileCodeRow.append(None)

		jsonTiles.append(jsonTileRow)
		tileCorners.append(cornerRow)
		tileCodes.append(tileCodeRow)

	#Convert to shapely tiles
	outerPolyTiles = []
	for jsonTileRow, cornerRow, tileCodeRow in zip(jsonTiles, tileCorners, tileCodes):
		outerPolyTilesRow = []
		for jsonTile, tileCorner, tc in zip(jsonTileRow, cornerRow, tileCodeRow):
			#print jsonTile, tileCorner, tc
			if tileCorner is not None:
				outerPolyTilesRow.append(GetShapelyPolygons(jsonTile, tileCorner[0], tileCorner[1], tc))
			else:
				outerPolyTilesRow.append(None)
		outerPolyTiles.append(outerPolyTilesRow)

	print "Num outerPolyTiles", len(outerPolyTiles)

	#Exhaustively check for overlaps
	currentLayer = []
	inRoi = []
	centreTile = outerPolyTiles[1][1]
	for rowNum, outerPolyTilesRow in enumerate(outerPolyTiles):
		for colNum, outerPolys in enumerate(outerPolyTilesRow):
			isCentreTile = (rowNum == 1 and colNum == 1)
			if outerPolys is None: continue
			for poly in outerPolys:
				currentLayer.append(copy.deepcopy(poly))
				inRoi.append(isCentreTile)

	for polyNum1 in range(len(currentLayer)):
		for polyNum2 in range(len(currentLayer)):
			if polyNum1 == polyNum2: continue
			poly1 = currentLayer[polyNum1]
			poly2 = currentLayer[polyNum2]
			if poly1 is None or poly2 is None: continue		

			try:
				inters = poly1.intersects(poly2)
			except PredicateError:
				print "Warning: shapely.geos.PredicateError occured"
				inters = 0
			if inters:
				print "Merging", polyNum1, "and", polyNum2
				currentLayer[polyNum1] = currentLayer[polyNum1].union(poly2)
				#print type(currentLayer[polyNum1])
				inRoi[polyNum1] = inRoi[polyNum1] or inRoi[polyNum2]
				currentLayer[polyNum2] = None
				inRoi[polyNum2] = False
	
	centreObjs = []
	for poly, roi in zip(currentLayer, inRoi):
		if not roi: continue
		if poly is None: continue
		centreObjs.append(poly)

	if 0:
		out = PolysToOsm(currentLayer)
		outFi = open("currentLayer","wt")
		outFi.write(out)
		outFi.flush()

	#Simplify polygons
	print "Simplifying"
	simplifiedCentreObjs = []
	for poly in centreObjs:
		tags = {}
		tags['natural'] = 'wood'
		
		simplifiedCentreObjs.append([poly.simplify(2.0, True), tags])

	#Flag small	polygons
	#for poly, tags in simplifiedCentreObjs:
	#	
	#	if isinstance(poly, MultiPolygon):
	#		for ply in poly.geoms:
	#			outerPolys.append(ply)
	#			innerPolys.extend(ply.interiors)
	#	else:
	#		outerPolys = [poly]
	#		innerPolys = poly.interiors

	#	allPolys = outerPolys
	#	allPolys.extend(innerPolys)

	#	hit = 0
	#	for basicPoly in allPolys:
	#		print "area", basicPoly.area
	#		if basicPoly.area < 5e-9:
	#			hit = 1

	#	if hit:
	#		tags["import_area"] = "warning: contains small polygon"

	out = PolysToOsm(simplifiedCentreObjs)
	outFi = open(finaOut,"wt")
	outFi.write(out)
	outFi.flush()
	print "Output written to",finaOut