def __init__(self, name=None, workspace=None, source=None, schema=None):
if not workspace:
from geoscript.workspace import Memory
workspace = Memory()
name = name if name else schema.name if schema else Layer._newname()
if not source:
layer = None
try:
layer = workspace.get(name)
except KeyError:
pass
if not layer:
if schema:
layer = workspace.create(schema.name, schema.fields)
else:
layer = workspace.create(name)
source = layer._source
elif isinstance(source, FeatureCollection):
source = CollectionDelegatingFeatureSource(source)
self.workspace = workspace
self.schema = schema or feature.Schema(ft=source.schema)
self._source = source
# keep a crs local to allow the native crs to be overriden, or to
# provide a crs for layers that don't have one specified
self._proj = None
def __init__(self, name=None, workspace=None, fs=None, schema=None):
if not workspace:
from geoscript.workspace import Memory
workspace = Memory()
name = name or Layer._newname()
if not fs:
layer = None
try:
layer = workspace.get(name)
except KeyError:
pass
if not layer:
if schema:
layer = workspace.create(schema.name, schema.fields)
else:
layer = workspace.create(name)
fs = layer._source
self.workspace = workspace
self.schema = schema or feature.Schema(ft=fs.schema)
self._source = fs
# keep a crs local to allow the native crs to be overriden, or to
# provide a crs for layers that don't have one specified
self._proj = None
def testSchemaReproject(self):
prj1 = proj.Projection('epsg:4326')
prj2 = proj.Projection('epsg:3005')
s = feature.Schema('test', [('geom', geom.Point, 'epsg:4326')])
assert s.fields[0].proj == prj1
s = s.reproject(prj2, 'reprojected')
assert 'reprojected' == s.name
assert s.fields[0].proj == prj2
def create(self,
name=None,
fields=[('geom', geom.Geometry, 'epsg:4326')],
schema=None):
"""
Creates a new :class:`Layer geoscript.layer.layer.Layer` in the workspace.
*name* is the optional name to assign to the new layer.
*fields* is an optional ``list`` of ``str``/``type`` tuples which define th e schema of the new layer.
*schema* is the optional :class:`Schema <geoscript.feature.Schema>` of the new layer.
**Note**: When the *schema* argument is specified neither of *name* or *fields* should be specified.
>>> from geoscript import geom
>>> ws = Workspace()
>>> l1 = ws.create('foo', [('geom', geom.Point)])
>>> ws.layers()
['foo']
>>> from geoscript.feature import Schema
>>> l2 = ws.create(schema=Schema('bar', [('geom', geom.Point)]))
>>> ws.layers()
['bar', 'foo']
"""
if not name:
name = schema.name if schema else Layer._newname()
if schema:
schema = feature.Schema(name, schema.fields)
try:
self.get(name)
raise Exception('Layer %s already exists.' % (name))
except KeyError:
pass
schema = schema or feature.Schema(name, fields)
self._store.createSchema(schema._type)
return self.get(name)
def testSchemaBasic(self):
atts = [('att1', str), ('att2', int), ('geom', geom.Point)]
s = feature.Schema('test', atts)
assert 'test' == s.name
n = 0
for att in s.fields:
assert atts[n][0] == att.name
assert atts[n][1] == att.typ
n = n + 1
assert len(atts) == n
assert atts[2][0] == s.geom.name
assert atts[2][1] == s.geom.typ
def filter(self, fil, name=None):
"""
Filters the layer.
*fil* is the :class:`Filter <geoscript.filter.Filter>` to apply.
*name* is the optional name to assign to the new filtered layer.
This method returns a newly filtered layer. The new layer is create within the containing workspace of the original layer.
>>> from geoscript.feature import Schema
>>> l = Layer(schema=Schema('original', [('name', str)]))
>>> l.add(['foo'])
>>> l.add(['bar'])
>>> l.add(['baz'])
>>>
>>> l2 = l.filter("name = 'foo'", "filtered")
>>> l2.count()
1
>>> l3 = l.filter("name LIKE 'b%'", "filtered2")
>>> l3.count()
2
"""
f = Filter(fil)
name = name or Layer._newname()
fschema = feature.Schema(name, self.schema.fields)
# create the filtered layer
flayer = self.workspace.create(schema=fschema)
q = DefaultQuery(self.name, f._filter)
# loop through features and add to new filtered layer
fit = self._source.getFeatures(q).features()
try:
while fit.hasNext():
f = feature.Feature(schema=fschema, f=fit.next())
flayer.add(f)
finally:
fit.close()
return flayer
def testSchemaAsContainer(self):
s = feature.Schema('test',[('att1',str),('att2',int),('geom', geom.Point,'epsg:3005')])
assert s['att1']
assert s['att1'].typ == str
expected = [f.name for f in s.fields]
assert [name for name in s] == expected
expected = [f for f in s.fields]
assert [f for name, f in s.iteritems()] == expected
try:
s['foo']
assert False
except KeyError:
pass
assert s.values() == s.fields
assert s.keys() == [f.name for f in s.fields]
def testSchemaEquals(self):
s1 = feature.Schema('test', [('att1', str), ('att2', int),
('geom', geom.Point, 'epsg:3005')])
s2 = feature.Schema('test', [('att1', str), ('att2', int),
('geom', geom.Point, 'epsg:3005')])
assert s1 == s2
def testSchemaGeomProj(self):
prj = proj.Projection('epsg:3005')
s = feature.Schema('test', [('att1', str), ('att2', int),
('geom', geom.Point, 'epsg:3005')])
assert s.geom.proj
assert prj == s.geom.proj
