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