def generateSegments(self, nodes, computeDistance, proj4):
'Generate segment candidates connecting nodes to the existing grid'
# Prepare
segmentFactory = network.SegmentFactory(nodes, computeDistance, proj4)
# Use more efficient CandidateManager for candidate segments
candidateManager = CandidateManager(segmentFactory.getNodes(), computeDistance)
net = network.Network(segmentFactory, useIndex=True)
networkRelativePath = self.get(ExistingNetworks)
# If we have existing networks,
if networkRelativePath:
# Reconstruct path
networkArchivePath = os.path.join(self.state[0].getBasePath(), networkRelativePath)
if not os.path.exists(networkArchivePath):
raise variable_store.VariableError('Expected ZIP archive containing shapefile for existing networks')
isValid, networkPath = store.unzip(networkArchivePath, 'shp')
if not isValid:
raise variable_store.VariableError('Could not find shapefile in ZIP archive for existing networks')
# Load network
networkProj4, networkGeometries = geometry_store.load(networkPath)[:2]
networkCoordinatePairs = network.yieldSimplifiedCoordinatePairs(networkGeometries)
# Prepare
transform_point = geometry_store.get_transform_point(networkProj4, proj4)
# Load existing network as a single subnet and allow overlapping segments
net.addSubnet(network.Subnet([segmentFactory.getSegment(transform_point(c1[0], c1[1]), transform_point(c2[0], c2[1]), is_existing=True) for c1, c2 in networkCoordinatePairs]))
# Add candidate segments that connect each node to its
# projection on the existing network
projectedTuples = net.projectEfficient(candidateManager.nodes)
candidateManager.extendNodeTuples(projectedTuples)
return candidateManager, net
def generateSegments(self, nodes, computeDistance, proj4):
'Generate segment candidates connecting nodes to the existing grid'
# Prepare
segmentFactory = network.SegmentFactory(nodes, computeDistance, proj4)
# Use more efficient CandidateManager for candidate segments
candidateManager = CandidateManager(segmentFactory.getNodes(),
computeDistance)
net = network.Network(segmentFactory, useIndex=True)
networkRelativePath = self.get(ExistingNetworks)
# If we have existing networks,
if networkRelativePath:
# Reconstruct path
networkArchivePath = os.path.join(self.state[0].getBasePath(),
networkRelativePath)
if not os.path.exists(networkArchivePath):
raise variable_store.VariableError(
'Expected ZIP archive containing shapefile for existing networks'
)
isValid, networkPath = store.unzip(networkArchivePath, 'shp')
if not isValid:
raise variable_store.VariableError(
'Could not find shapefile in ZIP archive for existing networks'
)
# Load network
networkProj4, networkGeometries = geometry_store.load(
networkPath)[:2]
networkCoordinatePairs = network.yieldSimplifiedCoordinatePairs(
networkGeometries)
# Prepare
transform_point = geometry_store.get_transform_point(
networkProj4, proj4)
# Load existing network as a single subnet and allow overlapping segments
net.addSubnet(
network.Subnet([
segmentFactory.getSegment(transform_point(c1[0], c1[1]),
transform_point(c2[0], c2[1]),
is_existing=True)
for c1, c2 in networkCoordinatePairs
]))
# Add candidate segments that connect each node to its
# projection on the existing network
projectedTuples = net.projectEfficient(candidateManager.nodes)
candidateManager.extendNodeTuples(projectedTuples)
return candidateManager, net
def generateSegments(self, nodes, computeDistance, proj4):
'Generate segment candidates connecting nodes to the existing grid'
# Prepare
segments = []
segmentFactory = network.SegmentFactory(nodes, computeDistance, proj4)
networkNodes = segmentFactory.getNodes()
net = network.Network(segmentFactory)
networkRelativePath = self.get(ExistingNetworks)
# If we have existing networks,
if networkRelativePath:
# Reconstruct path
networkArchivePath = os.path.join(self.state[0].getBasePath(), networkRelativePath)
if not os.path.exists(networkArchivePath):
raise variable_store.VariableError('Expected ZIP archive containing shapefile for existing networks')
isValid, networkPath = store.unzip(networkArchivePath, 'shp')
if not isValid:
raise variable_store.VariableError('Could not find shapefile in ZIP archive for existing networks')
# Load network
networkProj4, networkGeometries = geometry_store.load(networkPath)[:2]
networkCoordinatePairs = network.yieldSimplifiedCoordinatePairs(networkGeometries)
# Prepare
transform_point = geometry_store.get_transform_point(networkProj4, proj4)
# Load existing network as a single subnet and allow overlapping segments
net.subnets.append(network.Subnet([segmentFactory.getSegment(transform_point(c1[0], c1[1]), transform_point(c2[0], c2[1]), is_existing=True) for c1, c2 in networkCoordinatePairs]))
# Add candidate segments that connect each node to its projection on the existing network
segments.extend(net.project(networkNodes))
# Prepare matrix where the rows are nodes and the columns are node coordinates
networkNodeMatrix = np.array([node.getCoordinates() for node in networkNodes])
# Define get_nearestNeighbors()
if computeDistance == network.computeEuclideanDistance:
kdTree = KDTree(networkNodeMatrix)
else:
earthRadiusInMeters = 6371010
kdTree = Arc_KDTree(networkNodeMatrix, radius=earthRadiusInMeters)
get_nearestNeighbors = functools.partial(kdTree.query, k=self.get(MaximumNearestNeighborCount))
# For each node,
for node1 in networkNodes:
# Get its nearest neighbors
nodeIndices = get_nearestNeighbors(node1.getCoordinates())[1]
# Add candidate segments from the node to each of its nearest neighbors
for node2Coordinates in networkNodeMatrix[nodeIndices]:
# Let getSegment() compute segment weight in case we want to customize how we weight each segment
segments.append(segmentFactory.getSegment(node1.getCoordinates(), tuple(node2Coordinates)))
# Return
return segments, net
def test(self):
'Run tests'
print 'Save and load a SHP file without attributes'
path = self.getPath('.shp')
geometry_store.save(path, geometry_store.proj4LL, shapelyGeometries)
result = geometry_store.load(path)
result_proj = result[0].strip()
# In some environments, proj seems to drop the ellps param which seems redundant anyway
# self.assertEqual(result[0].strip(), geometry_store.proj4LL)
self.assertTrue ( result_proj == geometry_store.proj4LL
or result_proj == geometry_store.proj4LL.replace("+ellps=WGS84 ", "") )
self.assertEqual(len(result[1]), len(shapelyGeometries))
print 'Save and load a SHP file with attributes'
path = self.getPath('.shp')
geometry_store.save(path, geometry_store.proj4LL, shapelyGeometries, fieldPacks, fieldDefinitions)
result = geometry_store.load(path)
self.assertEqual(len(result[2]), len(fieldPacks))
for shapelyGeometry, fieldPack in itertools.izip(result[1], result[2]):
print
for fieldValue, (fieldName, fieldType) in itertools.izip(fieldPack, result[3]):
print '%s = %s' % (fieldName, fieldValue)
print shapelyGeometry
print 'Save a SHP file with attributes with different targetProj4'
path = self.getPath('.shp')
geometry_store.save(path, geometry_store.proj4LL, shapelyGeometries, fieldPacks, fieldDefinitions, targetProj4=geometry_store.proj4SM)
result = geometry_store.load(path)
self.assertNotEqual(result[0].strip(), geometry_store.proj4LL)
print 'Load a SHP file with attributes with different targetProj4'
path = self.getPath('.shp')
geometry_store.save(path, geometry_store.proj4LL, shapelyGeometries, fieldPacks, fieldDefinitions)
result = geometry_store.load(path, targetProj4=geometry_store.proj4SM)
self.assertNotEqual(result[0].strip(), geometry_store.proj4LL)
print 'Save and load a ZIP file without attributes using save'
path = self.getPath('.shp.zip')
geometry_store.save(path, geometry_store.proj4LL, shapelyGeometries)
result = geometry_store.load(path)
result_proj = result[0].strip()
self.assertTrue ( result_proj == geometry_store.proj4LL
or result_proj == geometry_store.proj4LL.replace("+ellps=WGS84 ", "") )
self.assertEqual(len(result[1]), len(shapelyGeometries))
print 'Save and load a ZIP file with attributes using save'
path = self.getPath('.shp.zip')
geometry_store.save(path, geometry_store.proj4LL, shapelyGeometries, fieldPacks, fieldDefinitions)
result = geometry_store.load(path)
self.assertEqual(len(result[2]), len(fieldPacks))
print 'Test saving and loading ZIP files of point coordinates'
path = self.getPath('.shp.zip')
geometry_store.save_points(path, geometry_store.proj4LL, [(0, 0)], fieldPacks, fieldDefinitions)
result = geometry_store.load_points(path)
self.assertEqual(result[1], [(0, 0)])
print 'Test get_transform_point'
transform_point0 = geometry_store.get_transform_point(geometry_store.proj4LL, geometry_store.proj4LL)
transform_point1 = geometry_store.get_transform_point(geometry_store.proj4LL, geometry_store.proj4SM)
self.assertNotEqual(transform_point0(0, 0), transform_point1(0, 0))
print 'Test get_transform_geometry'
transform_geometry = geometry_store.get_transform_geometry(geometry_store.proj4LL, geometry_store.proj4SM)
self.assertEqual(type(transform_geometry(geometry.Point(0, 0))), type(geometry.Point(0, 0)))
self.assertEqual(type(transform_geometry(ogr.CreateGeometryFromWkt('POINT (0 0)'))), type(ogr.CreateGeometryFromWkt('POINT (0 0)')))
print 'Test get_coordinateTransformation'
geometry_store.get_coordinateTransformation(geometry_store.proj4LL, geometry_store.proj4SM)
print 'Test get_spatialReference'
geometry_store.get_spatialReference(geometry_store.proj4LL)
with self.assertRaises(geometry_store.GeometryError):
geometry_store.get_spatialReference('')
print 'Test get_geometryType'
geometry_store.get_geometryType(shapelyGeometries)
print 'Test save() when a fieldPack has fewer fields than definitions'
with self.assertRaises(geometry_store.GeometryError):
path = self.getPath('.shp')
geometry_store.save(path, geometry_store.proj4LL, shapelyGeometries, [x[1:] for x in fieldPacks], fieldDefinitions)
print 'Test save() when a fieldPack has more fields than definitions'
with self.assertRaises(geometry_store.GeometryError):
path = self.getPath('.shp')
geometry_store.save(path, geometry_store.proj4LL, shapelyGeometries, [x * 2 for x in fieldPacks], fieldDefinitions)
print 'Test save() when the driverName is unrecognized'
with self.assertRaises(geometry_store.GeometryError):
path = self.getPath('.shp')
geometry_store.save(path, geometry_store.proj4LL, shapelyGeometries, driverName='')
print 'Test load() when format is unrecognized'
with self.assertRaises(geometry_store.GeometryError):
path = self.getPath('')
geometry_store.load(path)