Python osgeo.ogr.OFTReal() Examples
The following are 9
code examples of osgeo.ogr.OFTReal().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
osgeo.ogr
, or try the search function
.
.
Example #1
| Source File: slicing.py From lidar with MIT License | 6 votes |
|
def polygonize(img,shp_path):
# mapping between gdal type and ogr field type
type_mapping = {gdal.GDT_Byte: ogr.OFTInteger,
gdal.GDT_UInt16: ogr.OFTInteger,
gdal.GDT_Int16: ogr.OFTInteger,
gdal.GDT_UInt32: ogr.OFTInteger,
gdal.GDT_Int32: ogr.OFTInteger,
gdal.GDT_Float32: ogr.OFTReal,
gdal.GDT_Float64: ogr.OFTReal,
gdal.GDT_CInt16: ogr.OFTInteger,
gdal.GDT_CInt32: ogr.OFTInteger,
gdal.GDT_CFloat32: ogr.OFTReal,
gdal.GDT_CFloat64: ogr.OFTReal}
ds = gdal.Open(img)
prj = ds.GetProjection()
srcband = ds.GetRasterBand(1)
dst_layername = "Shape"
drv = ogr.GetDriverByName("ESRI Shapefile")
dst_ds = drv.CreateDataSource(shp_path)
srs = osr.SpatialReference(wkt=prj)
dst_layer = dst_ds.CreateLayer(dst_layername, srs=srs)
raster_field = ogr.FieldDefn('id', type_mapping[srcband.DataType])
dst_layer.CreateField(raster_field)
gdal.Polygonize(srcband, srcband, dst_layer, 0, [], callback=None)
del img, ds, srcband, dst_ds, dst_layer
# convert images in a selected folder to shapefiles
Example #2
| Source File: zonalstats.py From wradlib with MIT License | 6 votes |
|
def set_attribute(self, name, values):
"""Add/Set given Attribute with given values
Parameters
----------
name : string
Attribute Name
values : :class:`numpy:numpy.ndarray`
Values to fill in attributes
"""
lyr = self.ds.GetLayerByIndex(0)
lyr.ResetReading()
# todo: automatically check for value type
defn = lyr.GetLayerDefn()
if defn.GetFieldIndex(name) == -1:
lyr.CreateField(ogr.FieldDefn(name, ogr.OFTReal))
for i, item in enumerate(lyr):
item.SetField(name, values[i])
lyr.SetFeature(item)
Example #3
| Source File: filling.py From lidar with MIT License | 5 votes |
|
def polygonize(img,shp_path):
# mapping between gdal type and ogr field type
type_mapping = {gdal.GDT_Byte: ogr.OFTInteger,
gdal.GDT_UInt16: ogr.OFTInteger,
gdal.GDT_Int16: ogr.OFTInteger,
gdal.GDT_UInt32: ogr.OFTInteger,
gdal.GDT_Int32: ogr.OFTInteger,
gdal.GDT_Float32: ogr.OFTReal,
gdal.GDT_Float64: ogr.OFTReal,
gdal.GDT_CInt16: ogr.OFTInteger,
gdal.GDT_CInt32: ogr.OFTInteger,
gdal.GDT_CFloat32: ogr.OFTReal,
gdal.GDT_CFloat64: ogr.OFTReal}
ds = gdal.Open(img)
prj = ds.GetProjection()
srcband = ds.GetRasterBand(1)
dst_layername = "Shape"
drv = ogr.GetDriverByName("ESRI Shapefile")
dst_ds = drv.CreateDataSource(shp_path)
srs = osr.SpatialReference(wkt=prj)
dst_layer = dst_ds.CreateLayer(dst_layername, srs=srs)
# raster_field = ogr.FieldDefn('id', type_mapping[srcband.DataType])
raster_field = ogr.FieldDefn('id', type_mapping[gdal.GDT_Int32])
dst_layer.CreateField(raster_field)
gdal.Polygonize(srcband, srcband, dst_layer, 0, [], callback=None)
del img, ds, srcband, dst_ds, dst_layer
# extract sinks from dem
Example #4
| Source File: test_georef.py From wradlib with MIT License | 5 votes |
|
def test_ogr_create_layer(self):
ds = wradlib.io.gdal_create_dataset("Memory", "test", gdal_type=gdal.OF_VECTOR)
with pytest.raises(TypeError):
georef.ogr_create_layer(ds, "test")
lyr = georef.ogr_create_layer(
ds, "test", geom_type=ogr.wkbPoint, fields=[("test", ogr.OFTReal)]
)
assert isinstance(lyr, ogr.Layer)
Example #5
| Source File: test_georef.py From wradlib with MIT License | 5 votes |
|
def test_ogr_add_feature(self):
ds = wradlib.io.gdal_create_dataset("Memory", "test", gdal_type=gdal.OF_VECTOR)
georef.ogr_create_layer(
ds, "test", geom_type=ogr.wkbPoint, fields=[("index", ogr.OFTReal)]
)
point = np.array([1198054.34, 648493.09])
parr = np.array([point, point, point])
georef.ogr_add_feature(ds, parr)
georef.ogr_add_feature(ds, parr, name="test")
Example #6
| Source File: test_georef.py From wradlib with MIT License | 5 votes |
|
def test_ogr_add_geometry(self):
ds = wradlib.io.gdal_create_dataset("Memory", "test", gdal_type=gdal.OF_VECTOR)
lyr = georef.ogr_create_layer(
ds, "test", geom_type=ogr.wkbPoint, fields=[("test", ogr.OFTReal)]
)
point = ogr.Geometry(ogr.wkbPoint)
point.AddPoint(1198054.34, 648493.09)
georef.ogr_add_geometry(lyr, point, [42.42])
Example #7
| Source File: utils.py From Python-Geospatial-Development-Third-Edition with MIT License | 4 votes |
|
def get_ogr_feature_attribute(attr, feature):
attr_name = attr.name
if not feature.IsFieldSet(attr_name):
return (True, None)
if attr.type == ogr.OFTInteger:
value = str(feature.GetFieldAsInteger(attr_name))
elif attr.type == ogr.OFTIntegerList:
value = repr(feature.GetFieldAsIntegerList(attr_name))
elif attr.type == ogr.OFTReal:
value = feature.GetFieldAsDouble(attr_name)
value = "%*.*f" % (attr.width, attr.precision, value)
elif attr.type == ogr.OFTRealList:
values = feature.GetFieldAsDoubleList(attr_name)
str_values = []
for value in values:
str_values.append("%*.*f" % (attr.width,
attr.precision, value))
value = repr(str_values)
elif attr.type == ogr.OFTString:
value = feature.GetFieldAsString(attr_name)
elif attr.type == ogr.OFTStringList:
value = repr(feature.GetFieldAsStringList(attr_name))
elif attr.type == ogr.OFTDate:
parts = feature.GetFieldAsDateTime(attr_name)
year,month,day,hour,minute,second,tzone = parts
value = "%d,%d,%d,%d" % (year,month,day,tzone)
elif attr.type == ogr.OFTTime:
parts = feature.GetFieldAsDateTime(attr_name)
year,month,day,hour,minute,second,tzone = parts
value = "%d,%d,%d,%d" % (hour,minute,second,tzone)
elif attr.type == ogr.OFTDateTime:
parts = feature.GetFieldAsDateTime(attr_name)
year,month,day,hour,minute,second,tzone = parts
value = "%d,%d,%d,%d,%d,%d,%d,%d" % (year,month,day,
hour,minute,
second,tzone)
else:
return (False, "Unsupported attribute type: " +
str(attr.type))
return (True, value)
#############################################################################
Example #8
| Source File: utils.py From Python-Geospatial-Development-Third-Edition with MIT License | 4 votes |
|
def set_ogr_feature_attribute(attr, value, feature):
attr_name = attr.name
if value == None:
feature.UnsetField(attr_name)
return
if attr.type == ogr.OFTInteger:
feature.SetField(attr_name, int(value))
elif attr.type == ogr.OFTIntegerList:
integers = eval(value)
feature.SetFieldIntegerList(attr_name, integers)
elif attr.type == ogr.OFTReal:
feature.SetField(attr_name, float(value))
elif attr.type == ogr.OFTRealList:
floats = []
for s in eval(value):
floats.append(eval(s))
feature.SetFieldDoubleList(attr_name, floats)
elif attr.type == ogr.OFTString:
feature.SetField(attr_name, value)
elif attr.type == ogr.OFTStringList:
strings = []
for s in eval(value):
strings.append(s.encode(encoding))
feature.SetFieldStringList(attr_name, strings)
elif attr.type == ogr.OFTDate:
parts = value.split(",")
year = int(parts[0])
month = int(parts[1])
day = int(parts[2])
tzone = int(parts[3])
feature.SetField(attr_name, year, month, day,
0, 0, 0, tzone)
elif attr.type == ogr.OFTTime:
parts = value.split(",")
hour = int(parts[0])
minute = int(parts[1])
second = int(parts[2])
tzone = int(parts[3])
feature.SetField(attr_name, 0, 0, 0,
hour, minute, second, tzone)
elif attr.type == ogr.OFTDateTime:
parts = value.split(",")
year = int(parts[0])
month = int(parts[1])
day = int(parts[2])
hour = int(parts[3])
minute = int(parts[4])
second = int(parts[5])
tzone = int(parts[6])
feature.SetField(attr_mame, year, month, day,
hour, minute, second, tzone)
Example #9
| Source File: analysis.py From RHEAS with MIT License | 4 votes |
|
def cropYield(shapefile, name, startdate="", enddate="", crop="maize", dbname="rheas"):
"""Extract crop yield from a specified simulation *name* for dates ranging
from *startdate* to *enddate*, and saves them a *shapefile*."""
logging.basicConfig(level=logging.INFO, format='%(message)s')
log = logging.getLogger(__name__)
db = dbio.connect(dbname)
cur = db.cursor()
datesql = ""
if len(startdate) > 0:
try:
sdt = datetime.strptime(startdate, "%Y-%m-%d")
datesql = "and fdate>=date'{0}'".format(sdt.strftime("%Y-%m-%d"))
except ValueError:
log.warning("Start date is invalid and will be ignored.")
if len(enddate) > 0:
try:
edt = datetime.strptime(enddate, "%Y-%m-%d")
datesql += "and fdate<=date'{0}'".format(edt.strftime("%y-%m-%d"))
except ValueError:
log.warning("End date is invalid and will be ignored.")
fsql = "with f as (select gid,geom,gwad,ensemble,fdate from (select gid,geom,gwad,ensemble,fdate,row_number() over (partition by gid,ensemble order by gwad desc) as rn from {0}.dssat) gwadtable where rn=1 {1})".format(name, datesql)
sql = "{0} select gid,st_astext(geom),max(gwad) as max_yield,avg(gwad) as avg_yield,stddev(gwad) as std_yield,max(fdate) as fdate from f group by gid,geom".format(fsql)
cur.execute(sql)
if bool(cur.rowcount):
results = cur.fetchall()
drv = ogr.GetDriverByName("ESRI Shapefile")
ds = drv.CreateDataSource(shapefile)
lyr = ds.CreateLayer("yield", geom_type=ogr.wkbMultiPolygon)
lyr.CreateField(ogr.FieldDefn("gid", ogr.OFTInteger))
lyr.CreateField(ogr.FieldDefn("average", ogr.OFTReal))
lyr.CreateField(ogr.FieldDefn("maximum", ogr.OFTReal))
lyr.CreateField(ogr.FieldDefn("minimum", ogr.OFTReal))
for row in results:
feat = ogr.Feature(lyr.GetLayerDefn())
feat.SetField("gid", row[0])
feat.SetField("maximum", row[2])
feat.SetField("average", row[3])
feat.SetField("minimum", row[4])
feat.SetGeometry(ogr.CreateGeometryFromWkt(row[1]))
lyr.CreateFeature(feat)
feat.Destroy()
ds.Destroy()
