def extent_polygon(file,out):
fgc_shp = ogr.Open(file)
lyr = fgc_shp.GetLayer()
extent = lyr.GetExtent()
ring = ogr.Geometry(ogr.wkbLinearRing)
ring.AddPoint(extent[0], extent[2])
ring.AddPoint(extent[1], extent[2])
ring.AddPoint(extent[1], extent[3])
ring.AddPoint(extent[0], extent[3])
ring.AddPoint(extent[0], extent[2])
poly = ogr.Geometry(ogr.wkbPolygon)
poly.AddGeometry(ring)
driver=ogr.GetDriverByName('ESRI Shapefile')
ds=driver.CreateDataSource(out)
extent_lyr = ds.CreateLayer('temp', lyr.GetSpatialRef(), ogr.wkbMultiPolygon )
new_feat = ogr.Feature(extent_lyr.GetLayerDefn())
new_feat.SetGeometry(poly)
extent_lyr.CreateFeature(new_feat)
extent_lyr = None
ds = None
driver = None
new_feat = None
lyr = None
fgc_shp = None
def get_interesecting_vdatum_regions(datafilepath):
"""
Find the vdatum regions that intersect the given data.
"""
dataset = gdal.Open(datafilepath)
is_raster = dataset.RasterCount > 0
if is_raster:
# get raster bounds
crs = pyproj.CRS.from_wkt(dataset.GetProjectionRef())
transform = dataset.GetGeoTransform()
pixelWidth = transform[1]
pixelHeight = transform[5]
cols = dataset.RasterXSize
rows = dataset.RasterYSize
x0 = transform[0]
y1 = transform[3]
x1 = x0+cols*pixelWidth
y0 = y1-rows*pixelHeight
if crs.is_projected:
unproject = pyproj.Proj(proj='utm', zone = 19, ellps = 'WGS84')
ul = unproject(x0,x1, inverse = True)
ur = unproject(x1, y1, inverse = True)
lr = unproject(x1, y0, inverse = True)
ll = unproject(x0, y0, inverse = True)
else:
ul = (x0, y1)
ur = (x1, y1)
lr = (x1, y0)
ll = (x0, y0)
# build polygon from raster
ring = ogr.Geometry(ogr.wkbLinearRing)
ring.AddPoint(ul[0], ul[1])
ring.AddPoint(ur[0], ur[1])
ring.AddPoint(lr[0], lr[1])
ring.AddPoint(ll[0], ll[1])
ring.AddPoint(ul[0], ul[1])
dataGeometry = ogr.Geometry(ogr.wkbPolygon)
dataGeometry.AddGeometry(ring)
else:
raise NotImplementedError('Not handling XYZ data yet')
dataset = None
# get all the regions represented by geometry files
geom_list = get_vdatum_region_polygons()
# see if the regions intersect with the provided geometries
intersecting_regions = []
for region in geom_list:
vector = ogr.Open(geom_list[region])
layer_count = vector.GetLayerCount()
for m in range(layer_count):
layer = vector.GetLayerByIndex(m)
feature_count = layer.GetFeatureCount()
for n in range(feature_count):
feature = layer.GetFeature(n)
feature_name = feature.GetField(0)
if feature_name[:15] == 'valid-transform':
valid_vdatum_poly = feature.GetGeometryRef()
if dataGeometry.Intersect(valid_vdatum_poly):
intersecting_regions.append(region)
vector = None
return intersecting_regions
def create_polygon(self, coords):
ring = ogr.Geometry(ogr.wkbLinearRing)
for coord in coords:
ring.AddPoint(coord[0], coord[1])
# Create polygon
poly = ogr.Geometry(ogr.wkbPolygon)
poly.AddGeometry(ring)
return poly.ExportToWkt()
def merge_files(f1, f2, out):
print("Merging files...")
try:
fgc_shp = ogr.Open(f1)
lyr1 = fgc_shp.GetLayer()
fgc_shp2 = ogr.Open(f2)
lyr2 = fgc_shp2.GetLayer()
driver=ogr.GetDriverByName('ESRI Shapefile')
ds=driver.CreateDataSource(out)
merge_lyr = ds.CreateLayer('temp', lyr2.GetSpatialRef(), ogr.wkbMultiPolygon )
# diff_lyr = createFieldsFrom(lyr2, diff_lyr)
print(" First file uninon..")
union1 = ogr.Geometry(ogr.wkbMultiPolygon)
for feat1 in lyr1:
geom1 = feat1.GetGeometryRef()
if geom1 != None:
union1 = union1.Union(geom1)
geom1 = None
print(" Second file uninon..")
union2 = ogr.Geometry(ogr.wkbMultiPolygon)
for feat2 in lyr2:
geom2 = feat2.GetGeometryRef()
if geom2 != None:
union2 = union2.Union(geom2)
geom2 = None
union1 = union1.Buffer(0)
union2 = union2.Buffer(0)
print(" Final uninon..")
merge = union1.Union(union2)
new_feat = ogr.Feature(merge_lyr.GetLayerDefn())
new_feat.SetGeometry(merge)
merge_lyr.CreateFeature(new_feat)
except:
print("exception thrown!")
traceback.print_exc()
new_feat= None
union1 = None
union2 = None
diff_lyr = None
fgc_shp = None
fgc_shp2 = None
ds = None
lyr1 = None
lyr2 = None
def extract(parentOutputDirectory, outputbasename, inputscene):
# import raster(s), get projection, prepare transform projections and find current extent
src_ds, srcband, prj, epsg_prj = clip.import_raster_bands(inputscene)
src1 = srcband[0]
src2 = srcband[1]
src3 = srcband[2]
if epsg_prj == 'nothing':
print 'projection not in current list of projections handled by this code'
sys.exit(1)
pproj = pyproj.Proj(init='epsg:%s' % epsg_prj)
praw = pyproj.Proj(init='epsg:4326')
print pproj, praw
[minx, miny, maxx, maxy] = clip.find_raster_extent(src_ds)
print[minx, miny, maxx, maxy]
sitecoord_nonextent = randomize(minx, miny, maxx, maxy)
sitecoord_extent = remove_outofbounds_points(sitecoord_nonextent, src_ds,
[], praw, pproj)
# create point geometry and add all points to it
multipoint = ogr.Geometry(ogr.wkbMultiPoint)
for tup in sitecoord_extent:
x = tup[0]
y = tup[1]
point = ogr.Geometry(ogr.wkbPoint)
point.AddPoint(x, y)
multipoint.AddGeometry(point)
# make_site_raster(multipoint, src_ds)
siteArrayList, lonlist, latlist = clip.make_site_array(
multipoint, src_ds, src1, src2, src3)
"""for site in siteArrayList:
#print'site'
for l in site:
print l"""
sitesfor_sqldb = []
namenums = len(siteArrayList)
for i in range(namenums):
newRasterindex = i
array = siteArrayList[i]
lon = lonlist[i]
lat = latlist[i]
sitename = array2raster(pproj, praw, array, lon, lat, src_ds,
newRasterindex, parentOutputDirectory,
outputbasename)
sitesfor_sqldb.append([sitename, newRasterindex])
#TODO: check that latlist, lonlist, arraylist, and namenums iteration indexing works properly
return sitesfor_sqldb #returns a list of all the full file names of each site processed
def test_concav(file,out):
points_by_id = get_points_from_geomety(file)
fgc_shp = ogr.Open(file)
lyr = fgc_shp.GetLayer()
driver=ogr.GetDriverByName('ESRI Shapefile')
ds1=driver.CreateDataSource(out)
concave_lyr=ds1.CreateLayer('temp', lyr.GetSpatialRef(), ogr.wkbPolygon)
concave_lyr = createFieldsFrom(lyr,concave_lyr)
print("starting concave")
ps = np.array([ ( points_by_id.iloc[xi,0] , np.array(points_by_id.iloc[xi,1]) ) for xi in range(0,points_by_id.shape[0]) ], dtype=object)
#Processar em várias threads
pool = multiprocessing.Pool(processes=multiprocessing.cpu_count())
res = pool.map( temp,ps )
print("End of concave calculations.")
print("Saving to file")
res = np.asarray(res,dtype=object)
for i in range(0, res.shape[0]):
try:
fgc_id = res[i][0]
hull = res[i][1]
new_ring = ogr.Geometry(ogr.wkbLinearRing)
hull = np.asarray(hull)
for i in range(0, hull.shape[0]):
new_ring.AddPoint(hull[i,0], hull[i,1])
poly = ogr.Geometry(ogr.wkbPolygon)
poly.AddGeometry(new_ring)
new_feat = ogr.Feature(concave_lyr.GetLayerDefn())
new_feat.SetField("ID_SEQ",fgc_id)
new_feat.SetGeometry(poly)
concave_lyr.CreateFeature(new_feat)
new_feat = None
except:
print("exception thrown!")
traceback.print_exc()
break
def crs_conversion(crs_from: str, crs_to: str,
coordinate: tuple) -> Tuple[float, float]:
# https://gis.stackexchange.com/questions/78838/converting-projected-coordinates-to-lat-lon-using-python
assert len(coordinate) == 2, (
"Expected 'point' in format '(X, Y)'"
"got %s",
(coordinate, ),
)
crs_from = int(crs_from.split(":")[-1])
crs_to = int(crs_to.split(":")[-1])
point = ogr.Geometry(ogr.wkbPoint)
point.AddPoint(coordinate[0], coordinate[1])
in_spatial_ref = osr.SpatialReference()
in_spatial_ref.ImportFromEPSG(crs_from)
out_spatial_ref = osr.SpatialReference()
out_spatial_ref.ImportFromEPSG(crs_to)
coordinate_transform = osr.CoordinateTransformation(
in_spatial_ref, out_spatial_ref)
point.Transform(coordinate_transform)
return point.GetX(), point.GetY()
def transform_as_geom(self, target_crs_code: str) -> ogr.Geometry:
if self.crs_code == target_crs_code:
return ogr.CreateGeometryFromWkt(self.get_wkt())
srs_in = osr.SpatialReference()
srs_in.SetFromUserInput(self.crs_code)
srs_out = osr.SpatialReference()
srs_out.SetFromUserInput(target_crs_code)
bbox_geom = ogr.CreateGeometryFromWkt(self.get_wkt(), srs_in)
bbox_coords = json.loads(bbox_geom.ExportToJson())
bbox_coords_transformed = list()
for bbox_point_pair in bbox_coords["coordinates"][0]:
point = ogr.Geometry(ogr.wkbPoint)
point.AssignSpatialReference(srs_in)
if srs_in.EPSGTreatsAsLatLong() == srs_out.EPSGTreatsAsLatLong():
point.AddPoint(bbox_point_pair[0], bbox_point_pair[1])
else:
point.AddPoint(bbox_point_pair[1], bbox_point_pair[0])
point.TransformTo(srs_out)
x, y, _ = point.GetPoint()
bbox_coords_transformed.append([x, y])
bbox_coords["coordinates"][0] = bbox_coords_transformed
bbox_transformed_geom = ogr.CreateGeometryFromJson(json.dumps(bbox_coords))
bbox_transformed_geom.AssignSpatialReference(srs_out)
return bbox_transformed_geom
def extract(parentOutputDirectory, outputbasename, inputscene):
# set up init fields
trainingsites_csv = 'U:/Fracking Pads/trainingSites_touse.csv'
sitecoords_nonextent = []
sitecoord_extent = []
# import raster(s), get projection, prepare transform projections and find current extent
src_ds, srcband, prj, epsg_prj = import_raster_bands(inputscene)
src1 = srcband[0]
src2 = srcband[1]
src3 = srcband[2]
if epsg_prj == 'nothing':
print 'projection not in current list of projections handled by this code'
sys.exit(1)
# epsg is 8901 for projected, 4326 for decimal lat/lon
pproj = pyproj.Proj(init='epsg:%s' % epsg_prj)
praw = pyproj.Proj(init='epsg:4326')
# run through trainingsites_csv and pick up all the sites coords to sitecoords_nonextent
with open(trainingsites_csv, 'rb') as csvfile:
reader = csv.reader(csvfile)
for row in reader:
x = float(row[0])
y = float(row[1])
sitecoords_nonextent.append([x, y])
# transform all site coords from decimal lat/lon to current proj, check those that are present, store in tuple list
sitecoord_extent = remove_outofbounds_points(sitecoords_nonextent,
src_ds,
sitecoord_extent,
praw,
pproj)
# TODO: export sampled raster data to georaster database
# creeate point geometry and add all points to it
multipoint = ogr.Geometry(ogr.wkbMultiPoint)
for tup in sitecoord_extent:
x = tup[0]
y = tup[1]
point = ogr.Geometry(ogr.wkbPoint)
point.AddPoint(x, y)
multipoint.AddGeometry(point)
# make_site_raster(multipoint, src_ds)
siteArrayList, lonlist, latlist = make_site_array(multipoint, src_ds, src1, src2, src3)
"""for site in siteArrayList:
#print'site'
for l in site:
print l"""
sitesfor_sqldb = []
namenums = len(siteArrayList)
for i in range(namenums):
newRasterindex = i
array = siteArrayList[i]
lon = lonlist[i]
lat = latlist[i]
sitename = array2raster(pproj,
praw,
array,
lon,
lat,
src_ds,
newRasterindex,
parentOutputDirectory,
outputbasename)
sitesfor_sqldb.append([sitename, newRasterindex])
#TODO: check that latlist, lonlist, arraylist, and namenums iteration indexing works properly
return sitesfor_sqldb #returns a list of all the full file names of each site processed
def generate_latlon_footprint(camera, boundary, dem=0.0, radii=None, **kwargs):
'''
Generates a latlon footprint from a csmapi generated camera model
Parameters
----------
camera : object
csmapi generated camera model
Returns
-------
: object
ogr multipolygon containing between one and two polygons
'''
if radii is None:
semi_major, semi_minor = get_radii(camera)
else:
semi_major, semi_minor = radii
lons, lats, _ = generate_latlon_boundary(camera,
boundary,
dem=dem,
radii=radii,
**kwargs)
# Transform coords from -180, 180 to 0, 360
# Makes crossing the meridian easier to identify
ll_coords = [*zip(((lons + 180) % 360), lats)]
ring = ogr.Geometry(ogr.wkbLinearRing)
wrap_ring = ogr.Geometry(ogr.wkbLinearRing)
poly = ogr.Geometry(ogr.wkbPolygon)
wrap_poly = ogr.Geometry(ogr.wkbPolygon)
multipoly = ogr.Geometry(ogr.wkbMultiPolygon)
current_ring = ring
switch_point = (None, None)
previous_point = ll_coords[0]
for coord in ll_coords:
coord_diff = previous_point[0] - coord[0]
if coord_diff > 0 and np.isclose(previous_point[0], 360, rtol = 1e-03) and \
np.isclose(coord[0], 0, atol=1e0, rtol=1e-01):
regression = scipy.stats.linregress([previous_point[0], coord[0]],
[previous_point[1], coord[1]])
slope, b = regression.slope, regression.intercept
current_ring.AddPoint(360 - 180, (slope * 360 + b))
current_ring = wrap_ring
switch_point = 0 - 180, (slope * 0 + b)
current_ring.AddPoint(*switch_point)
elif coord_diff < 0 and np.isclose(previous_point[0], 0, atol=1e0, rtol=1e-01) and \
np.isclose(coord[0], 360, rtol = 1e-03):
regression = scipy.stats.linregress([previous_point[0], coord[0]],
[previous_point[1], coord[1]])
slope, b = regression.slope, regression.intercept
current_ring.AddPoint(0 - 180, (slope * 0 + b))
current_ring.AddPoint(*switch_point)
current_ring = ring
current_ring.AddPoint(360 - 180, (slope * 360 + b))
lat, lon = coord
current_ring.AddPoint(lat - 180, lon)
previous_point = coord
poly.AddGeometry(ring)
wrap_poly.AddGeometry(wrap_ring)
if not wrap_poly.IsEmpty():
multipoly.AddGeometry(wrap_poly)
if not poly.IsEmpty():
multipoly.AddGeometry(poly)
return multipoly
def _tiger_to_tract(self, infile):
""" Converts collection of Census Tiger files into a geopandas.GeoDataFrame of census tracts
Modified from original at
https://svn.osgeo.org/gdal/tags/1.4.3/gdal/pymod/samples/tigerpoly.py
"""
class Module(object):
def __init__(mod):
mod.lines = {}
mod.poly_line_links = {}
outfile = 'tracts.shp'
# Open the datasource to operate on.
ds = ogr.Open(infile, update=0)
poly_layer = ds.GetLayerByName('Polygon')
# Create output file for the composed polygons.
nad83 = osr.SpatialReference()
nad83.SetFromUserInput('NAD83')
shp_driver = ogr.GetDriverByName('ESRI Shapefile')
shp_driver.DeleteDataSource(outfile)
shp_ds = shp_driver.CreateDataSource(outfile)
shp_layer = shp_ds.CreateLayer(
'out', geom_type=ogr.wkbPolygon, srs=nad83)
src_defn = poly_layer.GetLayerDefn()
poly_field_count = src_defn.GetFieldCount()
for fld_index in range(poly_field_count):
src_fd = src_defn.GetFieldDefn(fld_index)
fd = ogr.FieldDefn(src_fd.GetName(), src_fd.GetType())
fd.SetWidth(src_fd.GetWidth())
fd.SetPrecision(src_fd.GetPrecision())
shp_layer.CreateField(fd)
# Read all features in the line layer, holding just the geometry in a hash
# for fast lookup by TLID.
line_layer = ds.GetLayerByName('CompleteChain')
line_count = 0
modules_hash = {}
feat = line_layer.GetNextFeature()
geom_id_field = feat.GetFieldIndex('TLID')
tile_ref_field = feat.GetFieldIndex('MODULE')
while feat is not None:
geom_id = feat.GetField(geom_id_field)
tile_ref = feat.GetField(tile_ref_field)
try:
module = modules_hash[tile_ref]
except:
module = Module()
modules_hash[tile_ref] = module
module.lines[geom_id] = feat.GetGeometryRef().Clone()
line_count = line_count + 1
feat.Destroy()
feat = line_layer.GetNextFeature()
# Read all polygon/chain links and build a hash keyed by POLY_ID listing
# the chains (by TLID) attached to it.
link_layer = ds.GetLayerByName('PolyChainLink')
feat = link_layer.GetNextFeature()
geom_id_field = feat.GetFieldIndex('TLID')
tile_ref_field = feat.GetFieldIndex('MODULE')
lpoly_field = feat.GetFieldIndex('POLYIDL')
rpoly_field = feat.GetFieldIndex('POLYIDR')
link_count = 0
while feat is not None:
module = modules_hash[feat.GetField(tile_ref_field)]
tlid = feat.GetField(geom_id_field)
lpoly_id = feat.GetField(lpoly_field)
rpoly_id = feat.GetField(rpoly_field)
if lpoly_id == rpoly_id:
feat.Destroy()
feat = link_layer.GetNextFeature()
continue
try:
module.poly_line_links[lpoly_id].append(tlid)
except:
module.poly_line_links[lpoly_id] = [tlid]
try:
module.poly_line_links[rpoly_id].append(tlid)
except:
module.poly_line_links[rpoly_id] = [tlid]
link_count = link_count + 1
feat.Destroy()
feat = link_layer.GetNextFeature()
# Process all polygon features.
feat = poly_layer.GetNextFeature()
tile_ref_field = feat.GetFieldIndex('MODULE')
polyid_field = feat.GetFieldIndex('POLYID')
degenerate_count = 0
while feat is not None:
module = modules_hash[feat.GetField(tile_ref_field)]
polyid = feat.GetField(polyid_field)
tlid_list = module.poly_line_links[polyid]
link_coll = ogr.Geometry(type=ogr.wkbGeometryCollection)
for tlid in tlid_list:
geom = module.lines[tlid]
link_coll.AddGeometry(geom)
try:
poly = ogr.BuildPolygonFromEdges(link_coll)
if poly.GetGeometryRef(0).GetPointCount() < 4:
degenerate_count = degenerate_count + 1
poly.Destroy()
feat.Destroy()
feat = poly_layer.GetNextFeature()
continue
feat2 = ogr.Feature(feature_def=shp_layer.GetLayerDefn())
for fld_index in range(poly_field_count):
feat2.SetField(fld_index, feat.GetField(fld_index))
feat2.SetGeometryDirectly(poly)
shp_layer.CreateFeature(feat2)
feat2.Destroy()
except:
warn('BuildPolygonFromEdges failed.')
feat.Destroy()
feat = poly_layer.GetNextFeature()
if degenerate_count:
warn('Discarded %d degenerate polygons.' % degenerate_count)
# Cleanup
shp_ds.Destroy()
shp_ds = None
ds.Destroy()
ds = None
# build a fully-qualified fips code and dissolve on it to create tract geographies
gdf = gpd.read_file(outfile)
if "CTBNA90" in gdf.columns:
gdf = gdf.rename(columns={"CTBNA90": 'TRACT', "BLK90": "BLOCK"})
gdf['STATE'] = gdf['STATE'].astype(str).str.rjust(2, "0")
gdf['COUNTY'] = gdf['COUNTY'].astype(str).str.rjust(3, "0")
gdf['TRACT'] = gdf['TRACT'].astype(str).str.rjust(6, "0")
gdf['BLOCK'] = gdf['BLOCK'].astype(str).str.rjust(4, "0")
gdf['fips'] = gdf.STATE + gdf.COUNTY + gdf.TRACT
if self.geom == 'block':
gdf['fips'] += gdf.BLOCK
gdf = gdf.dropna(subset=['fips'])
gdf.geometry = gdf.buffer(0)
gdf = gdf.dissolve(by='fips')
gdf.reset_index(inplace=True)
shp_driver.DeleteDataSource(outfile)
return gdf
def difference(f1, f2, out):
try:
print("Difference between:")
print(" ",f1)
print(" ",f2)
fgc_shp = ogr.Open(f1)
lyr1 = fgc_shp.GetLayer()
fgc_shp2 = ogr.Open(f2)
lyr2 = fgc_shp2.GetLayer()
driver=ogr.GetDriverByName('ESRI Shapefile')
ds=driver.CreateDataSource(out)
diff_lyr = ds.CreateLayer('temp', lyr2.GetSpatialRef(), ogr.wkbMultiPolygon )
# diff_lyr = createFieldsFrom(lyr2, diff_lyr)
union1 = ogr.Geometry(ogr.wkbMultiPolygon)
for feat1 in lyr1:
geom1 = feat1.GetGeometryRef()
if geom1 != None:
union1 = union1.Union(geom1)
geom1 = None
union2 = ogr.Geometry(ogr.wkbMultiPolygon)
for feat2 in lyr2:
geom2 = feat2.GetGeometryRef()
if geom2 != None:
union2 = union2.Union(geom2)
geom2 = None
union1 = union1.Buffer(0)
union2 = union2.Buffer(0)
print(union1.GetGeometryCount())
diff = union1.Difference(union2)
new_feat = ogr.Feature(diff_lyr.GetLayerDefn())
new_feat.SetGeometry(diff)
diff_lyr.CreateFeature(new_feat)
# union1 = ogr.Geometry(ogr.wkbMultiPolygon)
# for feat1 in lyr1:
# geom1 = feat1.GetGeometryRef()
# fgc_shp2 = ogr.Open(f2)
# lyr2 = fgc_shp2.GetLayer()
# for feat2 in lyr2:
# geom2 = feat2.GetGeometryRef()
# if geom1 != None and geom2 != None:
## if geom2.Intersects(geom1) or geom2.Within(geom1) or geom2.Overlaps(geom1) or geom2.Crosses(geom1):
# diff = geom1.SymmetricDifference(geom2)
# if diff != None:
# union1.AddGeometry(diff)
## new_feat = ogr.Feature(diff_lyr.GetLayerDefn())
## new_feat.SetGeometry(diff)
## diff_lyr.CreateFeature(new_feat)
#
# geom2 = None
# new_feat = None
# diff=None
#
# geom1 = None
# new_feat = ogr.Feature(diff_lyr.GetLayerDefn())
# new_feat.SetGeometry(union1)
# diff_lyr.CreateFeature(new_feat)
except:
print("exception thrown!")
traceback.print_exc()
new_feat= None
union1 = None
union2 = None
diff_lyr = None
fgc_shp = None
fgc_shp2 = None
ds = None
lyr1 = None
lyr2 = None
def generate_latlon_footprint(camera,
nnodes=5,
semi_major=3396190,
semi_minor=3376200,
n_points=10):
'''
Generates a latlon footprint from a csmapi generated camera model
Parameters
----------
camera : object
csmapi generated camera model
nnodes : int
Not sure
semi_major : int
Semimajor axis of the target body
semi_minor : int
Semiminor axis of the target body
n_points : int
Number of points to generate between the corners of the bounding
box per side.
Returns
-------
: object
ogr multipolygon containing between one and two polygons
'''
lons, lats, _ = generate_latlon_boundary(camera,
nnodes=nnodes,
semi_major=semi_major,
semi_minor=semi_minor,
n_points=n_points)
# Transform coords from -180, 180 to 0, 360
# Makes crossing the maridian easier to identify
ll_coords = [*zip(((lons + 180) % 360), lats)]
ring = ogr.Geometry(ogr.wkbLinearRing)
wrap_ring = ogr.Geometry(ogr.wkbLinearRing)
poly = ogr.Geometry(ogr.wkbPolygon)
wrap_poly = ogr.Geometry(ogr.wkbPolygon)
multipoly = ogr.Geometry(ogr.wkbMultiPolygon)
current_ring = ring
switch_point = None
previous_point = ll_coords[0]
for coord in ll_coords:
coord_diff = previous_point[0] - coord[0]
if coord_diff > 0 and np.isclose(previous_point[0], 360, rtol = 1e-03) and \
np.isclose(coord[0], 0, atol=1e0, rtol=1e-01):
regression = scipy.stats.linregress([previous_point[0], coord[0]],
[previous_point[1], coord[1]])
slope, b = regression.slope, regression.intercept
current_ring.AddPoint(360 - 180, (slope * 360 + b))
current_ring = wrap_ring
switch_point = 0 - 180, (slope * 0 + b)
current_ring.AddPoint(*switch_point)
elif coord_diff < 0 and np.isclose(previous_point[0], 0, atol=1e0, rtol=1e-01) and \
np.isclose(coord[0], 360, rtol = 1e-03):
regression = scipy.stats.linregress([previous_point[0], coord[0]],
[previous_point[1], coord[1]])
slope, b = regression.slope, regression.intercept
current_ring.AddPoint(0 - 180, (slope * 0 + b))
current_ring.AddPoint(*switch_point)
current_ring = ring
current_ring.AddPoint(360 - 180, (slope * 360 + b))
lat, lon = coord
current_ring.AddPoint(lat - 180, lon)
previous_point = coord
poly.AddGeometry(ring)
wrap_poly.AddGeometry(wrap_ring)
if not wrap_poly.IsEmpty():
multipoly.AddGeometry(wrap_poly)
if not poly.IsEmpty():
multipoly.AddGeometry(poly)
return multipoly
def project(transform, p):
q = ogr.Geometry(ogr.wkbPoint)
q.AddPoint(p[0], p[1])
q.Transform(transform)
return (q.GetX(), q.GetY())