def __init__(self, src):
"""
initialize shapefile reader
"""
if isinstance(src, unicode):
src = src.encode('ascii', 'ignore')
src = self.find_source(src)
self.shpSrc = src
self.sr = shapefile.Reader(src)
self.recs = []
self.shapes = {}
self.load_records()
self.proj = None
# Check if there's a spatial reference
prj_src = src[:-4] + '.prj'
if exists(prj_src):
prj_text = open(prj_src).read()
srs = SpatialReference()
if srs.ImportFromWkt(prj_text):
raise ValueError("Error importing PRJ information from: %s" %
prj_file)
if srs.IsProjected():
try:
self.proj = pyproj.Proj(srs.ExportToProj4())
except: # e.g. ERROR 6: No translation for Lambert_Conformal_Conic to PROJ.4 format is known.
srs.MorphFromESRI()
self.proj = pyproj.Proj(srs.ExportToProj4())
def load_data(self):
filename = self.path.split(os.sep)[-1]
# Check for VELMA filename matches
for pattern in [self.VELMA_FILENAME_BASIC_RE, self.VELMA_FILENAME_NO_LAYER_RE,
self.VELMA_FILENAME_SUBDAY_RE, self.VELMA_FILENAME_SUBDAY_NO_LAYER_RE]:
match = pattern.match(filename)
if match:
self._velma_pattern = pattern
self.data_name = match.group(1)
self._loop = match.group(2)
self._has_layer = pattern in [self.VELMA_FILENAME_BASIC_RE, self.VELMA_FILENAME_SUBDAY_RE]
if self._has_layer:
self._layer = match.group(3)
self._is_subday = pattern in [self.VELMA_FILENAME_SUBDAY_RE, self.VELMA_FILENAME_SUBDAY_NO_LAYER_RE]
self._is_velma = True
break
projection = None
prj_file = self.path.replace('.asc', '.prj')
if os.path.exists(prj_file):
with open(prj_file, 'r') as f:
ref = SpatialReference()
ref.ImportFromWkt(f.read())
projection = Proj(ref.ExportToProj4())
# Capture georeference
with rasterio.open(self.path) as src:
self.affine = src.transform
self.shape = src.shape
self.resolution = src.res[0] # Assumed to be square
self.extent = Extent(*list(src.bounds), projection=projection)
self._nodata_value = src.nodata
self.time_info = TemporalInfo()
if not self._is_velma:
self.data_name = self.path.split(os.sep)[-1].split('.')[0]
return
timestamps = []
for f in os.listdir(os.path.dirname(os.path.abspath(self.path))):
filename = f.split(os.sep)[-1]
match = self._velma_pattern.match(filename)
# Skip if match is None and if match name or loop is wrong
if match and match.group(1) == self.data_name and match.group(2) == self._loop:
# Skip if match layer is wrong, if applicable
if self._has_layer and match.group(3) != self._layer:
continue
years = int(match.group(4 if self._has_layer else 3))
days = int(match.group(5 if self._has_layer else 4))
hours = int(match.group(6 if self._has_layer else 5)) if self._is_subday else 0
minutes = int(match.group(7 if self._has_layer else 6)) if self._is_subday else 0
insort(timestamps, datetime.datetime(years, 1, 1, hours, minutes) + datetime.timedelta(days - 1))
self.time_info.timestamps = timestamps
def __init__(self,*args,**kwds):
self.ocgis = ocgis(self)
sr = kwds.pop('sr',None)
if sr is None:
sr = SpatialReference()
sr.ImportFromEPSG(4326)
self.ocgis._proj4_str = sr.ExportToProj4()
super(SelectionGeometry,self).__init__(*args,**kwds)
def get_proj4_string(wkt_proj):
if not wkt_proj:
return None
else:
a = SpatialReference(wkt_proj)
a.MorphFromESRI()
res = a.ExportToProj4()
return None if \
'+proj=longlat +ellps=WGS84 +no_defs' in res \
or '+proj=longlat +datum=WGS84 +no_defs' in res \
else res
def generate_postgis_spatial_ref_sys(cls, v2_obj):
"""
Generates the contents of the spatial_ref_sys table from the v2 object.
The result is a list containing a dict per table row.
Each dict has the format {column-name: value}.
"""
result = []
for crs_name, definition in v2_obj.crs_definitions().items():
spatial_ref = SpatialReference(definition)
auth_name = spatial_ref.GetAuthorityName(None) or "NONE"
crs_id = crs_util.get_identifier_int(spatial_ref)
result.append({
"srid": crs_id,
"auth_name": auth_name,
"auth_srid": crs_id,
"srtext": definition,
"proj4text": spatial_ref.ExportToProj4(),
})
return result
def __init__(self, src):
"""
initialize shapefile reader
"""
if isinstance(src, unicode):
src = src.encode('ascii', 'ignore')
src = self.find_source(src)
self.shpSrc = src
self.sr = shapefile.Reader(src)
self.recs = []
self.intersect_tol = .3
self.max_area_for_circle = .002
self.high_exp_factor = 1.75
self.shapes = {}
self.geoms = {}
self.load_records()
self.proj = None
# Check if there's a spatial reference
prj_src = src[:-4] + '.prj'
if exists(prj_src):
prj_text = open(prj_src).read()
srs = SpatialReference()
wkt_ret = srs.ImportFromWkt(prj_text)
# print 'prj_text={0}'.format(prj_text)
#print "srs={0}".format(srs)
if wkt_ret:
raise ValueError("Error importing PRJ information from: %s" %
prj_file)
if srs.IsProjected():
export_srs = srs.ExportToProj4()
# print 'srs.IsProjected'
#print "Groomp"
# self.proj=pyproj.Proj(proj='utm',zone=10,ellps='WGS84')
self.proj = pyproj.Proj(export_srs)
else:
self.proj = None
# print 'self.proj = None'
#export_srs=srs.ExportToProj4()
#self.proj=pyproj.Proj(init='epsg:26915')
#self.proj = pyproj.Proj(export_srs)
else:
print 'choo'
def get_srs_debug(spatial_ref: osr.SpatialReference) -> [str, str]:
"""useful method for printing spatial ref information to the log
Args:
spatial_ref (osr.SpatialReference): [description]
Returns:
[str, str]: [description]
"""
order = spatial_ref.GetAxisMappingStrategy()
order_str = str(order)
if order == 0:
order_str = 'OAMS_TRADITIONAL_GIS_ORDER'
elif order == 1:
order_str = 'OAMS_AUTHORITY_COMPLIANT'
elif order == 2:
order_str = 'OAMS_CUSTOM'
return [spatial_ref.ExportToProj4(), order_str]
class CRS(object):
def __init__(self,
init=None,
epsg=None,
proj4=None,
gdal=None,
pyproj=None,
wkt=None,
esri=None,
mapping=None,
**kwargs):
self._proj4 = None
self._gdal = None
if epsg is not None:
self._gdal = SpatialReference()
error = self._gdal.ImportFromEPSG(int(epsg))
if error != 0:
raise ValueError(
"unable to interpret EPSG code '{}'".format(epsg))
elif isinstance(init, CRS):
self._proj4 = init._proj4
self._gdal = init._gdal
elif isinstance(init, Proj):
self._proj4 = init.srs
elif isinstance(pyproj, Proj):
self._proj4 = pyproj.srs
elif isinstance(init, SpatialReference):
self._gdal = init
elif isinstance(gdal, SpatialReference):
self._gdal = gdal
elif isinstance(init, dict):
self._proj4 = mapping_to_proj4(init)
elif isinstance(mapping, dict):
self._proj4 = mapping_to_proj4(mapping)
elif isinstance(init, string_types):
projection_string = str(init)
self._gdal = SpatialReference()
error = -1
if error != 0:
try:
error = self._gdal.ImportFromProj4(projection_string)
except:
error = -1
if error != 0:
try:
error = self._gdal.ImportFromWkt(projection_string)
except:
error = -1
if error != 0:
try:
error = self._gdal.ImportFromESRI(projection_string)
except:
error = -1
if error != 0:
try:
error = self._gdal.ImportFromUrl(projection_string)
except:
error = -1
if error != 0:
try:
error = self._gdal.ImportFromXML(projection_string)
except:
error = -1
if error != 0:
try:
error = self._gdal.ImportFromEPSG(projection_string)
except:
error = -1
if error != 0:
try:
error = self._gdal.ImportFromEPSGA(projection_string)
except:
error = -1
if error != 0:
try:
error = self._gdal.ImportFromERM(projection_string)
except:
error = -1
if error != 0:
try:
error = self._gdal.ImportFromMICoordSys(projection_string)
except:
error = -1
if error != 0:
try:
error = self._gdal.ImportFromOzi(projection_string)
except:
error = -1
if error != 0:
try:
error = self._gdal.ImportFromPCI(projection_string)
except:
error = -1
if error != 0:
try:
error = self._gdal.ImportFromUSGS(projection_string)
except:
error = -1
if error != 0:
pyproj = Proj(projection_string)
self._proj4 = pyproj.srs
elif proj4 is not None:
self._proj4 = proj4
self._gdal = SpatialReference()
error = self._gdal.ImportFromProj4(proj4)
if error != 0:
raise ValueError(
"unable to interpret PROJ4 string '{}'".format(proj4))
elif wkt is not None:
self._gdal = SpatialReference()
error = self._gdal.ImportFromWkt(wkt)
if error != 0:
raise ValueError(
"unable to interpret WKT string '{}'".format(wkt))
elif esri is not None:
self._gdal = SpatialReference()
error = self._gdal.ImportFromESRI(esri)
if error != 0:
raise ValueError(
"unable to interpret ESRI string '{}'".format(esri))
@staticmethod
def from_epsg(epsg):
return CRS(epsg=epsg)
@staticmethod
def from_proj4(proj4):
return CRS(proj4=proj4)
@staticmethod
def from_wkt(wkt):
return CRS(wkt=wkt)
@staticmethod
def from_esri(esri):
return CRS(esri=esri)
@staticmethod
def from_pyproj(pyproj):
return CRS(pyproj=pyproj)
@staticmethod
def from_gdal(gdal):
return CRS(gdal=gdal)
@property
def proj4(self):
if self._proj4 is not None:
pass
elif self._gdal is not None:
self._proj4 = self._gdal.ExportToProj4()
else:
raise ValueError("unable to produce PROJ4 string")
return self._proj4
@property
def pyproj(self):
return Proj(self.proj4)
@property
def mapping(self):
return proj4_to_mapping(self.proj4)
@property
def gdal(self):
if self._gdal is not None:
pass
elif self._proj4 is not None:
self._gdal = SpatialReference()
self._gdal.ImportFromProj4(self._proj4)
return self._gdal
@property
def wkt(self):
return self.gdal.ExportToWkt()
@property
def pretty_wkt(self):
return self.gdal.ExportToPrettyWkt()
@property
def usgs(self):
return self.gdal.ExportToUSGS()
@property
def xml(self):
return self.gdal.ExportToXML()
@property
def pci(self):
return self.gdal.ExportToPCI()
@property
def mi(self):
return self.gdal.ExportToMICoordSys()
@property
def is_latlon(self):
return self.pyproj.is_latlong()
@property
def is_geocentric(self):
return self.pyproj.is_geocent()
@property
def _cstype(self):
return 'GEOGCS' if self.is_latlon else 'PROJCS'
@property
def authority(self):
return self.gdal.GetAuthorityName(self._cstype)
@property
def code(self):
return self.gdal.GetAuthorityCode(self._cstype)
def __repr__(self):
return "CRS('{}')".format(self.proj4)
