def test_write_to_rootgrp(self): crs = CoordinateReferenceSystem(epsg=4326, name='hello_world') path = os.path.join(self.current_dir_output, 'foo.nc') with nc_scope(path, 'w') as ds: variable = crs.write_to_rootgrp(ds) self.assertIsInstance(variable, nc.Variable) with self.assertRaises(AttributeError): variable.proj4
def test_ne(self): crs1 = CoordinateReferenceSystem(epsg=4326) crs2 = CoordinateReferenceSystem(epsg=2136) self.assertNotEqual(crs1, crs2) self.assertNotEqual(crs2, crs1) self.assertNotEqual(crs1, None) self.assertNotEqual(None, crs1) self.assertNotEqual(None, crs1) self.assertNotEqual('input', crs1)
def get_crs(self, group_metadata): crs = group_metadata['crs'] if len(crs) == 0: ret = None else: ret = CoordinateReferenceSystem(value=crs) return ret
def test_system_process_geometries(self): """Test multiple geometries with coordinate system update.""" a = 'POLYGON((-105.21347987288135073 40.21514830508475313,-104.39928495762711691 40.21514830508475313,-104.3192002118643984 39.5677966101694949,-102.37047139830508513 39.61451271186440692,-102.12354343220337682 37.51896186440677639,-105.16009004237288593 37.51896186440677639,-105.21347987288135073 40.21514830508475313))' b = 'POLYGON((-104.15235699152542281 39.02722457627118757,-103.71189088983049942 39.44099576271186436,-102.71750529661017026 39.28082627118644155,-102.35712394067796538 37.63908898305084705,-104.13900953389830306 37.63241525423728717,-104.15235699152542281 39.02722457627118757))' geom = [{'geom': wkt.loads(xx), 'properties': {'UGID': ugid}} for ugid, xx in enumerate([a, b])] grid_value = [ [[37.0, 37.0, 37.0, 37.0], [38.0, 38.0, 38.0, 38.0], [39.0, 39.0, 39.0, 39.0], [40.0, 40.0, 40.0, 40.0]], [[-105.0, -104.0, -103.0, -102.0], [-105.0, -104.0, -103.0, -102.0], [-105.0, -104.0, -103.0, -102.0], [-105.0, -104.0, -103.0, -102.0]]] output_crs = CoordinateReferenceSystem( value={'a': 6370997, 'lon_0': -100, 'y_0': 0, 'no_defs': True, 'proj': 'laea', 'x_0': 0, 'units': 'm', 'b': 6370997, 'lat_0': 45}) x = Variable('x', grid_value[1], dimensions=['lat', 'lon']) y = Variable('y', grid_value[0], dimensions=['lat', 'lon']) grid = Grid(x, y) field = Field(grid=grid, crs=Spherical()) ops = OcgOperations(dataset=field, geom=geom, output_crs=output_crs) ret = ops.execute() expected = {0: -502052.79407259845, 1: -510391.37909706926} for field, container in ret.iter_fields(yield_container=True): self.assertAlmostEqual(field.grid.get_value_stacked().mean(), expected[container.geom.ugid.get_value()[0]])
def test_update_crs(self): # Test copying allows the CRS to be updated on the copy w/out changing the source CRS. desired = Spherical() gvar = GeometryVariable(value=[Point(1, 2)], name='geom', dimensions='geom') field = Field(crs=desired, geom=gvar) cfield = field.copy() self.assertEqual(cfield.crs, desired) new_crs = CoordinateReferenceSystem(name='i_am_new', epsg=4326) cfield.update_crs(new_crs) self.assertEqual(field.crs, desired) # Test geometry crs update is called. mfield = Mock(Field) mfield.is_empty = False mfield.dimension_map = Mock(DimensionMap) mfield.grid = Mock(Grid) mfield.geom = Mock(GeometryVariable) mcrs = Mock(Spherical) Field.update_crs(mfield, mcrs) mfield.grid.update_crs.assert_called_once_with(mcrs, from_crs=mfield.crs) mfield.geom.update_crs.assert_called_once_with(mcrs, from_crs=mfield.crs) from_crs = Mock(WGS84) mfield.grid.update_crs.reset_mock() mfield.geom.update_crs.reset_mock() Field.update_crs(mfield, mcrs, from_crs=from_crs) mfield.grid.update_crs.assert_called_once_with(mcrs, from_crs=from_crs) mfield.geom.update_crs.assert_called_once_with(mcrs, from_crs=from_crs)
def test_eq(self): value_lhs = { 'a': 6370997, 'b': 6370997, 'no_defs': True, 'proj': 'longlat', 'wktext': True, 'towgs84': '0,0,0,0,0,0,0' } lhs = CoordinateReferenceSystem(value=value_lhs) value_rhs = value_lhs.copy() value_rhs.pop('wktext') rhs = CoordinateReferenceSystem(value=value_rhs) self.assertEqual(lhs, rhs)
def test_system_properties(self): """Test field properties.""" time = TemporalVariable(value=[20, 30, 40], dimensions=['the_time'], dtype=float, name='time') time_bounds = TemporalVariable(value=[[15, 25], [25, 35], [35, 45]], dimensions=['times', 'bounds'], dtype=float, name='time_bounds') other = Variable(value=[44, 55, 66], name='other', dimensions=['times_again']) x = Variable(value=[1, 2, 3], name='xc', dimensions=['x']) y = Variable(value=[10, 20, 30, 40], name='yc', dimensions=['y']) crs = CoordinateReferenceSystem(epsg=2136) f = self.get_ocgfield(variables=[time, time_bounds, other, x, y]) f2 = deepcopy(f) self.assertIsNone(f.realization) self.assertIsNone(f.time) f.dimension_map.set_variable('time', time.name) self.assertNumpyAll(f.time.get_value(), time.get_value()) self.assertEqual(f.time.attrs['axis'], 'T') self.assertIsNone(f.time.bounds) f.dimension_map.set_variable('time', 'time', bounds=time_bounds.name) self.assertNumpyAll(f.time.bounds.get_value(), time_bounds.get_value()) self.assertIn('other', f.time.parent) dims = f.dimension_map.get_dimension('time') dims += ['times', 'times_again', 'the_time'] sub = f.get_field_slice({'time': slice(1, 2)}) desired = OrderedDict([('time', (1,)), ('time_bounds', (1, 2)), ('other', (1,)), ('xc', (3,)), ('yc', (4,))]) self.assertEqual(sub.shapes, desired) self.assertIsNone(sub.grid) sub.dimension_map.set_variable('x', 'xc') sub.dimension_map.set_variable('y', 'yc') # Test writing to netCDF will load attributes. path = self.get_temporary_file_path('foo.nc') sub.write(path) with self.nc_scope(path) as ds: self.assertEqual(ds.variables[x.name].axis, 'X') self.assertEqual(ds.variables[y.name].axis, 'Y') self.assertEqual(sub.x.attrs['axis'], 'X') self.assertEqual(sub.y.attrs['axis'], 'Y') self.assertIsInstance(sub.grid, Grid) desired = OrderedDict([('time', (1,)), ('time_bounds', (1, 2)), ('other', (1,)), ('xc', (3,)), ('yc', (4,))]) self.assertEqual(sub.shapes, desired) # Test a subset. bbox = [1.5, 15, 2.5, 35] data = Variable(name='data', value=np.random.rand(3, 4), dimensions=['x', 'y']) f2.add_variable(data) f2.dimension_map.set_variable('x', 'xc') f2.dimension_map.set_variable('y', 'yc') bbox = box(*bbox) spatial_sub = f2.grid.get_intersects(bbox).parent desired = OrderedDict([('time', (3,)), ('time_bounds', (3, 2)), ('other', (3,)), ('xc', (1,)), ('yc', (2,)), ('data', (1, 2)), ]) self.assertEqual(spatial_sub.shapes, desired)
def test_crs(self): rd = self.get_request_dataset_netcdf(crs=None) self.assertIsNone(rd.crs) self.assertTrue(rd._has_assigned_coordinate_system) self.assertIsNone(rd.get().crs) crs = CoordinateReferenceSystem(epsg=2136) rd = self.get_request_dataset_netcdf(crs=crs) self.assertEqual(rd.crs, crs)
def test_regrid_field_differing_crs(self): """Test exception raised when source and destination CRS values are not equal.""" source = self.get_ofield() destination = deepcopy(source) source.set_crs(CoordinateReferenceSystem(epsg=2136)) with self.assertRaises(RegriddingError): from ocgis.regrid.base import regrid_field regrid_field(source, destination)
def test_system_spatial_wrapping_and_reorder(self): if sys.version_info.major == 3 and sys.version_info.minor == 5: raise SkipTest('undefined behavior with Python 3.5') keywords = {'spatial_wrapping': list(SpatialWrapping.iter_possible()), 'crs': [None, Spherical(), CoordinateReferenceSystem(epsg=2136)], 'unwrapped': [True, False], 'spatial_reorder': [False, True]} for ctr, k in enumerate(self.iter_product_keywords(keywords)): field = self.get_wrap_field(crs=k.crs, unwrapped=k.unwrapped) ops = OcgOperations(dataset=field, spatial_wrapping=k.spatial_wrapping, spatial_reorder=k.spatial_reorder) ret = ops.execute() actual_field = ret.get_element() with vm.scoped_by_emptyable('wrapped state', actual_field): if not vm.is_null: actual = actual_field.wrapped_state else: actual = None actual_x = actual_field.grid.x.get_value() if not actual_field.is_empty: self.assertLessEqual(actual_x.max(), 360.) if k.spatial_reorder and k.unwrapped and k.spatial_wrapping == 'wrap' and k.crs == Spherical(): actual_data_value = actual_field.data_variables[0].get_value() desired_reordered = [None] * actual_data_value.shape[1] for idx in range(actual_data_value.shape[1]): desired_reordered[idx] = [3.0, 4.0, 0.0, 1.0, 2.0] for tidx in range(actual_data_value.shape[0]): time_data_value = actual_data_value[tidx] self.assertEqual(time_data_value.tolist(), desired_reordered) if k.spatial_reorder and not k.unwrapped and not k.spatial_wrapping: self.assertTrue(actual_x[0] < actual_x[-1]) if actual is None or k.crs != Spherical(): desired = None else: p = k.spatial_wrapping if p is None: if k.unwrapped: desired = WrappedState.UNWRAPPED else: desired = WrappedState.WRAPPED elif p == 'wrap': desired = WrappedState.WRAPPED else: desired = WrappedState.UNWRAPPED self.assertEqual(actual, desired)
def test_update_crs(self): # Test copying allows the CRS to be updated on the copy w/out changing the source CRS. desired = Spherical() gvar = GeometryVariable(value=[Point(1, 2)], name='geom', dimensions='geom') field = Field(crs=desired, geom=gvar) cfield = field.copy() self.assertEqual(cfield.crs, desired) new_crs = CoordinateReferenceSystem(name='i_am_new', epsg=4326) cfield.update_crs(new_crs) self.assertEqual(field.crs, desired)
def test_system_crs_and_grid_abstraction(self): f = Field(grid_abstraction='point') grid = self.get_gridxy(with_xy_bounds=True) f.add_variable(grid.x) crs = CoordinateReferenceSystem(epsg=2136, name='location') f.add_variable(crs) self.assertIsNone(f.crs) f.dimension_map.set_crs(crs) f.dimension_map.set_variable('x', grid.x) f.dimension_map.set_variable('y', grid.y) self.assertEqual(f.grid.crs, crs) f.set_geom(f.grid.get_abstraction_geometry()) self.assertEqual(f.grid.abstraction, 'point') self.assertEqual(f.geom.geom_type, 'Point')
def test_get_ocgis_grid_from_esmf_grid(self): from ocgis.regrid.base import get_esmf_grid from ocgis.regrid.base import get_ocgis_grid_from_esmf_grid rd = RequestDataset(**self.get_dataset()) keywords = dict(has_corners=[True, False], has_mask=[True, False], crs=[None, CoordinateReferenceSystem(epsg=4326)]) for k in itr_products_keywords(keywords, as_namedtuple=True): field = rd.get() grid = field.grid if k.has_mask: gmask = grid.get_mask(create=True) gmask[1, :] = True grid.set_mask(gmask) if not k.has_corners: grid.x.set_bounds(None) grid.y.set_bounds(None) self.assertFalse(grid.has_bounds) egrid = get_esmf_grid(grid) ogrid = get_ocgis_grid_from_esmf_grid(egrid, crs=k.crs) if k.has_mask: actual_mask = ogrid.get_mask() self.assertEqual(actual_mask.sum(), 4) self.assertTrue(actual_mask[1, :].all()) self.assertEqual(ogrid.crs, k.crs) self.assertNumpyAll(grid.get_value_stacked(), ogrid.get_value_stacked()) if k.has_corners: desired = grid.x.bounds.get_value() actual = ogrid.x.bounds.get_value() self.assertNumpyAll(actual, desired) desired = grid.y.bounds.get_value() actual = ogrid.y.bounds.get_value() self.assertNumpyAll(actual, desired) else: self.assertFalse(ogrid.has_bounds)
def test_get_field(self): driver = self.get_drivernetcdf() field = driver.get_field(format_time=False) self.assertEqual(field.driver.key, driver.key) self.assertIsInstance(field.time, TemporalVariable) with self.assertRaises(CannotFormatTimeError): assert field.time.value_datetime self.assertIsInstance(field.crs, CoordinateReferenceSystem) # Test overloading the coordinate system. path = self.get_temporary_file_path('foo.nc') with self.nc_scope(path, 'w') as ds: v = ds.createVariable('latitude_longitude', np.int) v.grid_mapping_name = 'latitude_longitude' # First, test the default is found. rd = RequestDataset(uri=path) driver = DriverNetcdfCF(rd) self.assertEqual(driver.get_crs(driver.metadata_source), CFSpherical()) self.assertEqual(driver.get_field().crs, CFSpherical()) # Second, test the overloaded CRS is found. desired = CoordinateReferenceSystem(epsg=2136) rd = RequestDataset(uri=path, crs=desired) self.assertEqual(rd.crs, desired) driver = DriverNetcdfCF(rd) self.assertEqual(driver.get_crs(driver.metadata_source), CFSpherical()) field = driver.get_field() self.assertEqual(field.crs, desired) # Test file coordinate system variable is removed. self.assertNotIn('latitude_longitude', field) # Test the default coordinate system is used when nothing is in the file. path = self.get_temporary_file_path('foo.nc') with self.nc_scope(path, 'w') as ds: ds.createVariable('nothing', np.int) rd = RequestDataset(uri=path) driver = DriverNetcdfCF(rd) self.assertEqual(rd.crs, env.DEFAULT_COORDSYS) self.assertEqual(driver.get_crs(driver.rd.metadata), env.DEFAULT_COORDSYS) self.assertEqual(driver.get_field().crs, env.DEFAULT_COORDSYS)
def test_update_crs(self): grid = self.get_gridxy(crs=Spherical()) targets = [grid.x, grid.y] for target in targets: self.assertIn('units', target.attrs) self.assertIn('standard_name', target.attrs) grid.set_extrapolated_bounds('xbounds', 'ybounds', 'bounds') self.assertIsNotNone(grid.y.bounds) self.assertIsNotNone(grid.x.bounds) to_crs = CoordinateReferenceSystem(epsg=3395) grid.update_crs(to_crs) targets = [grid.x, grid.y] for target in targets: self.assertNotIn('units', target.attrs) self.assertNotIn('standard_name', target.attrs) self.assertEqual(grid.crs, to_crs) for element in [grid.x, grid.y]: for target in [element.get_value(), element.bounds.get_value()]: self.assertTrue(np.all(target > 10000))
def test_dimensions(self): crs = CoordinateReferenceSystem(epsg=2136) field = Field(variables=[crs]) self.assertEqual(len(field.dimensions), 0)
def _parse_string_(self, value): return CoordinateReferenceSystem(epsg=int(value))
def write(self): SEED = 1 #: random number seeding for missing data RES = 1 #: resolution of the grid ORIGIN = Point(-105, 40) #: center coordinate of upper left cell from_sr = CoordinateReferenceSystem(epsg=4326).sr to_sr = CoordinateReferenceSystem(epsg=2163).sr ORIGIN = project_shapely_geometry(ORIGIN, from_sr, to_sr) DIM = [4, 4] #: number of cells [dimx,dimy] VAR = 'foo' #: name of the data variable ## any relevant variables for the time construction TIME = {'origin': datetime.datetime(2000, 3, 1, 12, 0, 0), 'end': datetime.datetime(2000, 4, 30, 12, 0, 0), 'calendar': 'proleptic_gregorian', 'units': 'days since 2000-01-01 00:00:00', 'name': 'time'} ## any relevant variables for the spatial construction SPACE = {'row_bnds': 'bounds_latitude', 'col_bnds': 'bounds_longitude'} ## any relevant variables for the level construction LEVEL = {'name': 'level', 'n': 2} ## variables for masked data MASK = {'n': 0, 'value': float(1e20)} ## MANUAL VALUE SETTING ######################################################## d1l1 = [[1, 1, 2, 2], [1, 1, 2, 2], [3, 3, 4, 4], [3, 3, 4, 4]] VAL = np.array(d1l1).reshape(1, 1, 4, 4) VAL_MAN = None ################################################################################ ## GENERATE BASE ARRAYS ## ## make time vector delta = datetime.timedelta(1) start = TIME['origin'] timevec = [] while start <= TIME['end']: timevec.append(start) start += delta timevec = np.array(timevec) ## make vector time bounds timevec_bnds = np.empty((len(timevec), 2), dtype=object) delta = datetime.timedelta(hours=12) for idx, tv in iter_array(timevec, return_value=True): timevec_bnds[idx, 0] = tv - delta timevec_bnds[idx, 1] = tv + delta ## make the level vector levelvec = np.array([50, 150]) levelvec_bounds = np.array([[0, 100], [100, 200]]) ## make centroids col_coords = -np.arange(abs(ORIGIN.x) - RES * (DIM[0] - 1), abs(ORIGIN.x) + RES, RES) col_coords = col_coords[::-1] row_coords = np.arange(ORIGIN.y - RES * (DIM[1] - 1), ORIGIN.y + RES, RES) # row_coords = row_coords[::-1] # col,row = np.meshgrid(col_coords,row_coords) ## create bounds arrays col_bnds = self.make_bounds(col_coords, RES) row_bnds = self.make_bounds(row_coords, RES) ## make value array if VAL is not None: val = np.ones((len(timevec), LEVEL['n'], DIM[0], DIM[1]), dtype=float) * VAL else: val = VAL_MAN ## set up the mask if requested mask = np.zeros(val.shape, dtype=bool) np.random.seed(SEED) # set the random masked cells to None for ii in range(0, MASK['n']): rx = np.random.randint(0, DIM[0]) ry = np.random.randint(0, DIM[1]) mask[:, :, rx, ry] = True val = np.ma.array(val, dtype=float, mask=mask, fill_value=MASK['value']) ## WRITE THE NC FILE ########################################################### ## initialize the output file rootgrp = nc.Dataset(os.path.join(self.outdir, self.filename), 'w', format='NETCDF4') ## create the dimensions level = rootgrp.createDimension(LEVEL['name'], size=LEVEL['n']) time = rootgrp.createDimension(TIME['name'], size=len(timevec)) lat = rootgrp.createDimension('lat', size=len(row_coords)) lon = rootgrp.createDimension('lon', size=len(col_coords)) bound = rootgrp.createDimension('bound', size=2) ## create the variables times = rootgrp.createVariable(TIME['name'], 'f8', ('time',)) times.axis = 'T' bounds_times = rootgrp.createVariable('time_bnds', 'f8', ('time', 'bound')) levels = rootgrp.createVariable(LEVEL['name'], 'i4', ('level',)) levels.axis = 'Z' bounds_levels = rootgrp.createVariable('level_bnds', 'i4', ('level', 'bound')) cols = rootgrp.createVariable('longitude', 'f8', ('lon',)) cols.axis = 'X' cols.standard_name = 'projection_x_coordinate' rows = rootgrp.createVariable('latitude', 'f8', ('lat',)) rows.axis = 'Y' rows.standard_name = 'projection_y_coordinate' bounds_col = rootgrp.createVariable(SPACE['col_bnds'], 'f8', ('lon', 'bound')) bounds_row = rootgrp.createVariable(SPACE['row_bnds'], 'f8', ('lat', 'bound')) value = rootgrp.createVariable(VAR, 'f8', ('time', 'level', 'lat', 'lon'), fill_value=1e20) ## fill variables times.units = TIME['units'] times.calendar = TIME['calendar'] times[:] = nc.date2num(timevec, units=times.units, calendar=times.calendar) bounds_times[:] = nc.date2num(timevec_bnds, units=times.units, calendar=times.calendar) levels[:] = levelvec bounds_levels[:] = levelvec_bounds cols[:] = col_coords rows[:] = row_coords bounds_col[:, :] = col_bnds bounds_row[:, :] = row_bnds value[:, :, :, :] = val value.missing_value = MASK['value'] value.standard_name = 'foo' value.long_name = 'foo_foo' value.units = 'huge' value.grid_mapping = 'crs' grid_mapping = rootgrp.createVariable('crs', 'c') grid_mapping.grid_mapping_name = "lambert_conformal_conic" grid_mapping.standard_parallel = [30., 60.] grid_mapping.longitude_of_central_meridian = -97. grid_mapping.latitude_of_projection_origin = 47.5 grid_mapping.false_easting = 3325000. grid_mapping.false_northing = 2700000. # add bounds attributes times.bounds = bounds_times._name rows.bounds = bounds_row._name cols.bounds = bounds_col._name levels.bounds = bounds_levels._name rootgrp.close()
def from_records(cls, records, schema=None, crs=UNINITIALIZED, uid=None, union=False, data_model=None): """ Create a :class:`~ocgis.Field` from Fiona-like records. :param records: A sequence of records returned from an Fiona file object. :type records: `sequence` of :class:`dict` :param schema: A Fiona-like schema dictionary. If ``None`` and any records properties are ``None``, then this must be provided. :type schema: dict >>> schema = {'geometry': 'Point', 'properties': {'UGID': 'int', 'NAME', 'str:4'}} :param crs: If :attr:`ocgis.constants.UNINITIALIZED`, default to :attr:`ocgis.env.DEFAULT_COORDSYS`. :type crs: :class:`dict` | :class:`~ocgis.variable.crs.AbstractCoordinateReferenceSystem` :param str uid: If provided, use this attribute name as the unique identifier. Otherwise search for :attr:`env.DEFAULT_GEOM_UID` and, if not present, construct a 1-based identifier with this name. :param bool union: If ``True``, union the geometries from records yielding a single geometry with a unique identifier value of ``1``. :param str data_model: See :meth:`~ocgis.driver.nc.create_typed_variable_from_data_model`. :returns: Field object constructed from records. :rtype: :class:`~ocgis.Field` """ if uid is None: uid = env.DEFAULT_GEOM_UID if isinstance(crs, dict): crs = CoordinateReferenceSystem(value=crs) elif crs == UNINITIALIZED: crs = env.DEFAULT_COORDSYS if union: deque_geoms = None deque_uid = [1] else: # Holds geometry objects. deque_geoms = deque() # Holds unique identifiers. deque_uid = deque() build = True for ctr, record in enumerate(records, start=1): # Get the geometry from a keyword present on the input dictionary or construct from the coordinates # sequence. try: current_geom = record['geom'] except KeyError: current_geom = shape(record['geometry']) if union: if build: deque_geoms = current_geom else: deque_geoms = deque_geoms.union(current_geom) else: deque_geoms.append(current_geom) # Set up the properties array if build: build = False if uid in record['properties']: has_uid = True else: has_uid = False # The geometry unique identifier may be present as a property. Otherwise the enumeration counter is used for # the identifier. if not union: if has_uid: to_append = int(record['properties'][uid]) else: to_append = ctr deque_uid.append(to_append) # If we are unioning, the target geometry is not yet a sequence. if union: deque_geoms = [deque_geoms] # Dimension for the outgoing field. if union: size = 1 else: size = ctr dim = Dimension(name=DimensionName.GEOMETRY_DIMENSION, size=size) # Set default geometry type if no schema is provided. if schema is None: geom_type = 'auto' else: geom_type = schema['geometry'] geom = GeometryVariable(value=deque_geoms, geom_type=geom_type, dimensions=dim) uid = create_typed_variable_from_data_model('int', data_model=data_model, name=uid, value=deque_uid, dimensions=dim) geom.set_ugid(uid) field = Field(geom=geom, crs=crs) # All records from a unioned geometry are not relevant. if not union: from ocgis.driver.vector import get_dtype_from_fiona_type, get_fiona_type_from_pydata if schema is None: has_schema = False else: has_schema = True for idx, record in enumerate(records): if idx == 0 and not has_schema: schema = {'properties': OrderedDict()} for k, v in list(record['properties'].items()): schema['properties'][k] = get_fiona_type_from_pydata(v) if idx == 0: for k, v in list(schema['properties'].items()): if k == uid.name: continue dtype = get_dtype_from_fiona_type(v, data_model=data_model) var = Variable(name=k, dtype=dtype, dimensions=dim) if v.startswith('str:'): var.set_string_max_length_global(value=int(v.split(':')[1])) field.add_variable(var) for k, v in list(record['properties'].items()): if k == uid.name: continue if v is None: # Mask the value if it is None. NULLs are allowed in OGR Vector files, but they do not translate # well to Python. Strings are generally okay but floats/ints case problems. field[k].get_mask(create=True)[idx] = v else: # Set the associated field value. field[k].get_value()[idx] = v data_variables = [uid.name] if not union: data_variables += [k for k in list(schema['properties'].keys()) if k != uid.name] field.append_to_tags(TagName.DATA_VARIABLES, data_variables, create=True) return field
def crs(self): return CoordinateReferenceSystem(epsg=2136)
def test_init(self): keywords = dict( value=[ None, { 'no_defs': True, 'ellps': 'WGS84', 'proj': 'longlat', 'towgs84': '0,0,0,0,0,0,0' } ], epsg=[None, 4326], proj4=[ None, '+proj=longlat +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +no_defs ' ]) prev_crs = None for k in itr_products_keywords(keywords): if k['epsg'] is not None and k['value'] is None and k[ 'proj4'] is None: epsg_only = True prev_crs = None else: epsg_only = False try: crs = CoordinateReferenceSystem(**k) except ValueError: if all([ii is None for ii in list(k.values())]): continue else: raise self.assertEqual( crs.proj4, '+proj=longlat +ellps=WGS84 +towgs84=0,0,0,0,0,0,0 +no_defs ') try: self.assertDictEqual( crs.value, { 'no_defs': True, 'ellps': 'WGS84', 'proj': 'longlat', 'towgs84': '0,0,0,0,0,0,0' }) except AssertionError: self.assertDictEqual( crs.value, { 'no_defs': True, 'datum': 'WGS84', 'proj': 'longlat', 'towgs84': '0,0,0,0,0,0,0' }) if prev_crs is not None: self.assertEqual(crs, prev_crs) if not epsg_only: prev_crs = deepcopy(crs) # test with a name parameter crs = CoordinateReferenceSystem(epsg=4326) self.assertEqual(crs.name, constants.OcgisConvention.Name.COORDSYS) crs = CoordinateReferenceSystem(epsg=4326, name='foo') self.assertEqual(crs.name, 'foo') # test using the init parameter value = {'init': 'epsg:4326'} self.assertEqual(CoordinateReferenceSystem(value=value), WGS84())
def _run_(arr, actual_wrapped_state): ret = CoordinateReferenceSystem._get_wrapped_state_from_array_(arr) self.assertEqual(ret, actual_wrapped_state)
def test_add_shapefile_unique_identifier(self): in_path = os.path.join(self.current_dir_output, 'foo_in.shp') # create a shapefile without a ugid and another integer attribute data = [{ 'geom': Point(1, 2), 'fid': 6 }, { 'geom': Point(2, 3), 'fid': 60 }] crs = Spherical() driver = 'ESRI Shapefile' schema = {'properties': {'fid': 'int'}, 'geometry': 'Point'} with fiona.open(in_path, 'w', driver=driver, crs=crs.value, schema=schema) as source: for xx in data: record = { 'properties': { 'fid': xx['fid'] }, 'geometry': mapping(xx['geom']) } source.write(record) out_path = os.path.join(self.current_dir_output, 'foo_out.shp') add_shapefile_unique_identifier(in_path, out_path) sci = GeomCabinetIterator(path=out_path) records = list(sci) self.assertAsSetEqual([1, 2], [ xx['properties'][OCGIS_UNIQUE_GEOMETRY_IDENTIFIER] for xx in records ]) self.assertAsSetEqual([6, 60], [xx['properties']['fid'] for xx in records]) self.assertEqual(CoordinateReferenceSystem(records[0]['meta']['crs']), crs) # test it works for the current working directory cwd = os.getcwd() os.chdir(self.current_dir_output) try: add_shapefile_unique_identifier(in_path, 'foo3.shp') self.assertTrue( os.path.exists( os.path.join(self.current_dir_output, 'foo3.shp'))) finally: os.chdir(cwd) # test using a template attribute out_path = os.path.join(self.current_dir_output, 'template.shp') add_shapefile_unique_identifier(in_path, out_path, template='fid') sci = GeomCabinetIterator(path=out_path) records = list(sci) self.assertAsSetEqual([6, 60], [ xx['properties'][OCGIS_UNIQUE_GEOMETRY_IDENTIFIER] for xx in records ]) # test with a different name attribute out_path = os.path.join(self.current_dir_output, 'name.shp') add_shapefile_unique_identifier(in_path, out_path, template='fid', name='new_id') with fiona.open(out_path) as sci: records = list(sci) self.assertAsSetEqual([6, 60], [xx['properties']['new_id'] for xx in records])
def test_write_to_rootgrp(self): crs = CoordinateReferenceSystem(epsg=4326, name='hello_world') path = os.path.join(self.current_dir_output, 'foo.nc') with nc_scope(path, 'w') as ds: variable = crs.write_to_rootgrp(ds) self.assertIsInstance(variable, nc.Variable)