def solve(f, R, t, r, g):
# make the circle
outerCircle = Point(0, 0).buffer(R, 1 << 12)
# make the ring
innerCircle = Point(0, 0).buffer(R - t - f, 1 << 12)
# make the bars
bars = []
leftMin = -r - (2 * r + g) * (int(R / (2 * r + g)) + 1)
left = leftMin
while left < R:
bars.append(box(left, -R, left + 2 * r + 2 * f, R))
left += 2 * r + g
bottom = leftMin
while bottom < R:
bars.append(box(-R, bottom, R, bottom + 2 * r + 2 * f))
bottom += 2 * r + g
# get the union
union = outerCircle.difference(innerCircle)
for bar in bars:
union = union.union(bar)
# intersection with prev shape
finalPattern = union.intersection(outerCircle)
# calc area ratio
result = finalPattern.area / outerCircle.area
return '%.6f' % result
def solve(f, R, t, r, g):
# make the circle
outerCircle = Point(0, 0).buffer(R, 1 << 12)
# make the ring
innerCircle = Point(0, 0).buffer(R - t - f, 1 << 12)
# make the bars
bars = []
leftMin = -r - (2 * r + g) * (int(R / (2 * r + g)) + 1)
left = leftMin
while left < R:
bars.append(box(left, -R, left + 2 * r + 2 * f, R))
left += 2 * r + g
bottom = leftMin
while bottom < R:
bars.append(box(-R, bottom, R, bottom + 2 * r + 2 * f))
bottom += 2 * r + g
# get the union
union = outerCircle.difference(innerCircle)
for bar in bars:
union = union.union(bar)
# intersection with prev shape
finalPattern = union.intersection(outerCircle)
# calc area ratio
result = finalPattern.area / outerCircle.area
return '%.6f' % result
def comparer():
'''
Create an image and compare the interpolation from different methods
'''
img_shape = (512, 512)
frame_bounds = [-256, 256, -256, 256]
my_sgeom = SGeom(box(-100, -50, 100, 50))
strat = lscad.MountainStrategy()
param_dict = {'hmax': 100., 'sigma': (0, 0)}
img = fk_img.img_from_sgeom(img_shape,
frame_bounds,
my_sgeom,
z_map_strategy=strat,
param_dict=param_dict)
x_s, y_s = img.arrf.sampling_vectors()
r, c = img.xy_to_rc(100, 50)
interp = interp2d(x_s, y_s, np.flipud(img.arr))
bivar1 = RectBivariateSpline(x=x_s, y=y_s, z=np.flipud(img.arr))
bivar2 = RectBivariateSpline(x=y_s, y=x_s, z=np.flipud(img.arr))
print interp(100, 50)
print img.arr[r, c]
print bivar1(50, 100), bivar1(100, 50)
print bivar2(50, 100), bivar2(100, 50)
img.plot()
plt.scatter(100, 50)
plt.show()
def tile_to_bbox(zoom, x, y):
"""
Transform a TMS/Slippy Map style tile protocol (z/x/y) to a web mercator
bounding box.
Ref:
https://github.com/IzAndCuddles/gdal2tiles/blob/structure/gdal2tiles.py#L120-L146 # noqa
Args:
zoom (int): Zoom level for the tile
x (int): x coordinate of tile origin
y (int): y coordinate of tile origin
Returns:
A Shapely geometry in EPSG:3857 defining the bounding box of the requested
tile
"""
mapSize = 20037508.34789244 * 2
origin_x = -20037508.34789244
origin_y = 20037508.34789244
size = mapSize / 2**zoom
min_x = origin_x + x * size
min_y = origin_y - (y + 1) * size
max_x = origin_x + (x + 1) * size
max_y = origin_y - y * size
return box(min_x, min_y, max_x, max_y, ccw=False)
def subdivide_polygon(geom, factor):
"""
Divide a geometry such that no piece is greater than the size of
`factor`, in units of the coordinate system.
Args:
geom: GeoJson-like polygon to subdivide
factor: The number of SRS units to divide the geom bounds by,
to provide subgeometries who's extent does not exceed that size.
Returns:
List of GeoJson-like polygons that `geom` is composed of
"""
bounds = np.asarray(geom.bounds)
xmin, ymin, xmax, ymax = np.floor_divide(bounds, factor).astype(int)
children = []
for i in range(xmin, xmax + 1):
for j in range(ymin, ymax + 1):
sub_poly = box(i * factor, j * factor, (i + 1) * factor,
(j + 1) * factor)
overlap_poly = geom.intersection(sub_poly)
if not overlap_poly.is_empty:
children.append(overlap_poly)
return children
def test_system_rotated_pole_spherical_subsetting(self):
"""Test rotated pole coordinates are left alone during a subset (no mask applied)."""
def _run_mask_test_(target):
for vn in ['rlat', 'rlon']:
self.assertIsNone(target[vn].get_mask())
rd = RequestDataset(metadata=self.fixture_rotated_spherical_metadata)
field = rd.create_field()
_run_mask_test_(field)
for ctr, vn in enumerate(['lat', 'lon', 'rlat', 'rlon']):
var = field[vn]
var.get_value()[:] = np.arange(var.size).reshape(var.shape) + (ctr * 10)
path = self.get_temporary_file_path('foo.nc')
field.write(path)
new_field = RequestDataset(path).create_field()
_run_mask_test_(new_field)
subset_geom = box(*new_field.grid.extent)
subset_field = new_field.grid.get_intersects(subset_geom, optimized_bbox_subset=True).parent
_run_mask_test_(subset_field)
path2 = self.get_temporary_file_path('foo2.nc')
subset_field.write(path2)
in_subset_field = RequestDataset(path2).create_field()
_run_mask_test_(in_subset_field)
def test_filtered_read_file_with_gdf_boundary(self):
full_df_shape = self.df.shape
nybb_filename = geopandas.datasets.get_path('nybb')
bbox = geopandas.GeoDataFrame(geometry=[
box(1031051.7879884212, 224272.49231459625, 1047224.3104931959,
244317.30894023244)
],
crs=self.crs)
filtered_df = read_file(nybb_filename, bbox=bbox)
filtered_df_shape = filtered_df.shape
assert full_df_shape != filtered_df_shape
assert filtered_df_shape == (2, 5)
def create_rect():
img_shape = (512, 512)
frame_bounds = [-256, 256, -256, 256]
my_sgeom = SGeom(box(-100, -50, 100, 50))
strat = lscad.MountainStrategy()
param_dict = {'hmax': 100., 'sigma': (0, 0)}
img = fk_img.img_from_sgeom(img_shape,
frame_bounds,
my_sgeom,
z_map_strategy=strat,
param_dict=param_dict)
img.plot()
plt.show()
def create_RGInterp():
img_shape = (512, 512)
frame_bounds = [-256, 256, -256, 256]
my_sgeom = SGeom(box(-100, -50, 100, 50))
strat = lscad.MountainStrategy()
param_dict = {'hmax': 100., 'sigma': (0, 0)}
img = fk_img.img_from_sgeom(img_shape,
frame_bounds,
my_sgeom,
z_map_strategy=strat,
param_dict=param_dict)
x, y = img.arrf.sampling_vectors()
img_xy = interpolate.RegularGridInterpolator((x, y), np.flipud(img.arr))
return img_xy
def interp_array():
img_shape = (512, 512)
frame_bounds = [-256, 256, -256, 256]
my_sgeom = SGeom(box(-100, -50, 100, 50))
strat = lscad.MountainStrategy()
param_dict = {'hmax': 100., 'sigma': (0, 0)}
img = fk_img.img_from_sgeom(img_shape,
frame_bounds,
my_sgeom,
z_map_strategy=strat,
param_dict=param_dict)
x_s, y_s = img.arrf.sampling_vectors()
bivar = RectBivariateSpline(x=x_s, y=y_s, z=np.flipud(img.arr))
x_n = np.linspace(0, 100, 10)
y_n = np.linspace(100, 200, 10)
print bivar(x_n, y_n, grid=False)
print bivar(0, y_n)
def regu_interp():
# Comparison between RegularGridInterpolator and RectBivariateSpline
img_shape = (512, 512)
frame_bounds = [-256, 256, -256, 256]
my_sgeom = SGeom(box(-100, -50, 100, 50))
strat = lscad.MountainStrategy()
param_dict = {'hmax': 100., 'sigma': (0, 0)}
img = fk_img.img_from_sgeom(img_shape,
frame_bounds,
my_sgeom,
z_map_strategy=strat,
param_dict=param_dict)
x_s, y_s = img.arrf.sampling_vectors()
reg = RegularGridInterpolator((x_s, y_s), np.flipud(img.arr))
bivar = RectBivariateSpline(x=x_s, y=y_s, z=np.flipud(img.arr))
spl = initialize(40)
pts = spl(np.linspace(0, 1, 10))
print pts[0]
print bivar(245, 244)
print reg([245, 244])
def create_2ob():
img_shape = (512, 512)
frame_bounds = [-256, 256, -256, 256]
R = 25
my_sgeom_1 = circle(R, -100, 0)
my_sgeom_2 = SGeom(box(0, 0, 100, 50))
my_geom = MultiPolygon([my_sgeom_1.geom, my_sgeom_2.geom])
my_sgeom = SGeom(my_geom, label='circle_square')
strat = lscad.MountainStrategy()
param_dict = {'hmax': 100., 'sigma': (0, 0)}
img = fk_img.img_from_sgeom(img_shape,
frame_bounds,
my_sgeom,
z_map_strategy=strat,
param_dict=param_dict)
gcoll = GeomCollection()
gcoll.set_geom(0, my_sgeom)
imsh = ImShape(image=img, geom_coll=gcoll)
imsh.plot()
plt.show()
def create_rect():
'''
Create a image in which the maximum pixels form a rectangular
'''
img_shape = (512, 512)
frame_bounds = [-256, 256, -256, 256]
my_sgeom = SGeom(box(-100, -50, 100, 50))
strat = lscad.MountainStrategy()
param_dict = {'hmax': 100., 'sigma': (0, 0)}
img = fk_img.img_from_sgeom(img_shape,
frame_bounds,
my_sgeom,
z_map_strategy=strat,
param_dict=param_dict)
x, y = img.arrf.sampling_vectors()
img_xy = interpolate.RectBivariateSpline(x, y, np.flipud(img.arr))
gcoll = GeomCollection()
gcoll.set_geom(0, my_sgeom)
imsh = ImShape(image=img, geom_coll=gcoll)
return img_xy, imsh
def create_2ob():
'''
Create a image in which the maximum pixels form 2 objects
'''
img_shape = (512, 512)
frame_bounds = [-256, 256, -256, 256]
R = 25
my_sgeom_1 = circle(R, -100, 0)
my_sgeom_2 = SGeom(box(0, 0, 100, 50))
my_geom = MultiPolygon([my_sgeom_1.geom, my_sgeom_2.geom])
my_sgeom = SGeom(my_geom, label='circle_square')
strat = lscad.MountainStrategy()
param_dict = {'hmax': 100., 'sigma': (0, 0)}
img = fk_img.img_from_sgeom(img_shape,
frame_bounds,
my_sgeom,
z_map_strategy=strat,
param_dict=param_dict)
x, y = img.arrf.sampling_vectors()
img_xy = interpolate.RectBivariateSpline(x, y, np.flipud(img.arr))
gcoll = GeomCollection()
gcoll.set_geom(0, my_sgeom)
imsh = ImShape(image=img, geom_coll=gcoll)
return img_xy, imsh
def process(vector_path, height, width, transform, NODATA=None):
# Spatial index to efficiently find triangles
p = index.Property()
idx = index.Index(properties=p, interleaved=True)
polys = []
def add_triangle(p1, p2, p3):
# create plane from points
# from http://kitchingroup.cheme.cmu.edu/blog/2015/01/18/Equation-of-a-plane-through-three-points/
# convert to numpy vectors
p1 = np.array([p1[0], p1[1], p1[2]])
p2 = np.array([p2[0], p2[1], p2[2]])
p3 = np.array([p3[0], p3[1], p3[2]])
v1 = p3 - p1
v2 = p2 - p1
cp = np.cross(v1, v2)
a, b, c = cp
d = np.dot(cp, p3)
# create 2d poly
poly = Polygon([(p1[0], p1[1]), (p2[0], p2[1]), (p3[0], p3[1])])
if poly.area >= 0:
pid = len(polys)
polys.append(poly)
idx.insert(pid, poly.bounds, obj=(poly, (a, b, c, d)))
# Read vector data only for selected rectangle
xmin, ymin = (0, 0) * transform
xmax, ymax = (width, height) * transform
ds = ogr.Open(vector_path)
layer = ds.GetLayer(0)
layer.SetSpatialFilterRect(xmin, ymin, xmax, ymax)
for feature in layer:
geom = feature.GetGeometryRef()
if geom.GetGeometryType() == ogr.wkbTINZ:
for triangle in geom:
for ring in triangle:
assert ring.GetPointCount() == 4
assert ring.GetPoint(0) == ring.GetPoint(3)
add_triangle(p1=ring.GetPoint(0),
p2=ring.GetPoint(1),
p3=ring.GetPoint(2))
elif geom.GetGeometryName() == "MULTIPOLYGON":
for poly in geom:
for ring in poly:
# Check assumptions: each polygon is a triangle
assert ring.GetPointCount() == 4
assert ring.GetPoint(0) == ring.GetPoint(3)
add_triangle(p1=ring.GetPoint(0),
p2=ring.GetPoint(1),
p3=ring.GetPoint(2))
else:
print("?", geom.GetGeometryName(),
feature.GetGeometryRef().ExportToWkt())
# Interpolate
res = np.zeros((width, height))
for h in range(height):
for w in range(width):
x, y = (h + 0.5, w + 0.5) * transform
_xmin, _ymin = (h, w) * transform
_xmax, _ymax = (h + 1, w + 1) * transform
_geom = box(_xmin, _ymin, _xmax, _ymax).centroid
hits = idx.intersection(_geom.bounds, objects=True)
z = float('-inf')
# We select the highest z value for each triangle x,y intersects
for hit in hits:
if hit.object[0].intersects(_geom):
a, b, c, d = hit.object[1]
if not c == 0.0:
_z = (d - a * x - b * y) / c
z = max(_z, z)
else:
print(hits)
if z == float('-inf'):
z = NODATA
res[w, h] = z
return res
def predict_patch(input_image,
model,
output_dir,
input_dir,
batch_size=2,
input_size=299,
threshold=0.5,
num_workers=1,
remove_tiles=False,
hist=False):
"""
Patch prediction function. Outputs shapefiles for counts and locations.
:param input_image: filename raster image from tile_raster
:param model: pytorch model
:param input_dir: directory with input tiles
:param output_dir: output directory name
:param batch_size: number of images per mini-batch
:param input_size: size of input images
:param threshold: threshold for occupancy
:param num_workers: number of workers on dataloader
:param remove_tiles: Remove the tiles folder from the filesystem.
:return:
"""
# crop and normalize images
data_transforms = transforms.Compose([
transforms.CenterCrop(input_size),
transforms.ToTensor(),
transforms.Normalize([0.485], [0.229])
])
# load dataset
dataset = ImageFolderTest(input_dir, data_transforms)
# separate into batches with dataloader
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=batch_size,
num_workers=num_workers)
# check for GPU support
use_gpu = torch.cuda.is_available()
# store predictions and filenames
predicted_cnts = []
predicted_locs = []
fnames = []
# set training flag to False
model.train(False)
# keep track of running time
since = time.time()
sigmoid = torch.nn.Sigmoid()
with torch.no_grad():
for data in dataloader:
# get the inputs
inputs, filenames = data
# gpu support
if use_gpu:
inputs = inputs.cuda()
# do a forward pass to get predictions
# detection models
out_dict = model(inputs)
# if statement prevents iterations over 0-d tensors
if out_dict['count'].dim() != 0:
locs = out_dict['heatmap'].cpu().detach()
counts = out_dict['count']
if 'occupancy' in out_dict:
counts = counts * torch.Tensor([
ele > threshold
for ele in sigmoid(out_dict['occupancy'])
]).cuda()
pred_cnt_batch = [
round(float(count.item())) for count in counts
]
# find predicted location
locs = [
get_xy_locs(loc, max(0, int(pred_cnt_batch[idx])))
for idx, loc in enumerate(locs.numpy())
]
# save batch predictions
predicted_cnts.extend(pred_cnt_batch)
predicted_locs.extend(locs)
# add filename
fnames.extend(filenames)
pred_locations = {'x': [], 'y': [], 'filenames': []}
for idx, batch in enumerate(predicted_locs):
for pnt in batch:
pred_locations['x'].append(pnt[0])
pred_locations['y'].append(pnt[1])
pred_locations['filenames'].append(fnames[idx])
pred_locations = pd.DataFrame(pred_locations)
pred_counts = pd.DataFrame({
'predictions': [ele for ele in predicted_cnts],
'filenames': [ele for ele in fnames]
})
time_elapsed = time.time() - since
print('Testing complete in %dh %dm %ds' %
(time_elapsed // 3600, time_elapsed // 60, time_elapsed % 60))
# save shapefile for counts / classes
shapefile_path = '%s/predicted_shapefiles/' % output_dir
os.makedirs(shapefile_path)
# load affine matrix
affine_matrix = rasterio.Affine(*[
ele for ele in pd.read_csv('%s/affine_matrix.csv' %
(input_dir))['transform']
])
# create geopandas DataFrames to store counts per patch and seal locations
output_shpfile = gpd.GeoDataFrame()
# setup projection for output
output_shpfile.crs = from_epsg(3031)
if hist:
# generate empty rows
for idx, fname in enumerate(fnames):
up, left, down, right = [
int(ele) for ele in fname.split('_')[-5:-1]
]
coords = [
point * affine_matrix
for point in [[down, left], [down, right], [up, left],
[up, right]]
]
output_shpfile = output_shpfile.append(
pd.Series(
{
'geometry':
box(minx=min([point[0] for point in coords]),
miny=min([point[1] for point in coords]),
maxx=max([point[0] for point in coords]),
maxy=max([point[1] for point in coords])),
'count':
0
},
name=fname))
# add predicted counts
for row in pred_counts.iterrows():
fname = row[1]['filenames']
output_shpfile.loc[fname, 'count'] += row[1]['predictions']
output_shpfile.to_file(shapefile_path + 'prediction.shp'.format())
print('Writing Prediction')
if len(pred_locations) > 0:
# create geopandas DataFrame to store classes and counts per patch
output_shpfile_locs = gpd.GeoDataFrame()
# setup projection for output
output_shpfile_locs.crs = from_epsg(3031)
# add locations
for row in pred_locations.iterrows():
fname = row[1]['filenames']
up, left, down, right = [
int(ele) for ele in fname.split('_')[-5:-1]
]
x, y = [up + row[1]['y'], left + row[1]['x']]
x_loc, y_loc = [x, y] * affine_matrix
output_shpfile_locs = output_shpfile_locs.append(pd.Series({
'geometry':
Point(x_loc, y_loc),
'x':
x,
'y':
y
}),
ignore_index=True)
# add scene name
output_shpfile_locs = output_shpfile_locs.join(
pd.DataFrame({'scene': [input_image] * len(output_shpfile_locs)}))
# save shapefile
output_shpfile_locs.to_file(
shapefile_path +
'locations.shp'.format(os.path.basename(output_dir)))
# remove tiles
if remove_tiles:
shutil.rmtree('{}/'.format(input_dir))
print('Total predicted in %s: ' % os.path.basename(input_dir),
sum(pred_counts['predictions']))
def main():
# unroll arguments
args = parser.parse_args()
input_image = args.input_image
output_folder = args.dest_folder
scales = [model_archs[args.class_architecture]['input_size']] * 3
output_folder = './{}/tiles/images/'.format(output_folder)
# check for pre-existing tiles and subties
if os.path.exists('./{}/tiles'.format(args.dest_folder)):
shutil.rmtree('./{}/tiles'.format(args.dest_folder))
if os.path.exists('./{}/sub-tiles'.format(args.dest_folder)):
shutil.rmtree('./{}/sub-tiles'.format(args.dest_folder))
# tile raster into patches
tile_raster(input_image, output_folder, scales)
print('\nPredicting with {}:'.format(os.path.basename(args.dest_folder)))
# create geopandas DataFrame for storing output
output_shpfile = gpd.GeoDataFrame()
# setup projection for output
output_shpfile.crs = from_epsg(3031)
# get affine matrix for raster file
with rasterio.open(input_image) as src:
affine_matrix = affine.Affine.from_gdal(*src.transform)
# generate empty rows
fnames = [
ele
for ele in os.listdir('./{}/tiles/images/'.format(args.dest_folder))
]
for fname in fnames:
up, left, down, right = [int(ele) for ele in fname.split('_')[-5:-1]]
coords = [
point * affine_matrix
for point in [[down, left], [down, right], [up, left], [up, right]]
]
output_shpfile = output_shpfile.append(
pd.Series(
{
'label':
'open-water',
'geometry':
box(minx=min([point[0] for point in coords]),
miny=min([point[1] for point in coords]),
maxx=max([point[0] for point in coords]),
maxy=max([point[1] for point in coords])),
'count':
0
},
name=fname))
# find class names
class_names = sorted([
subdir for subdir in os.listdir('./training_sets/{}/training'.format(
args.training_dir))
])
# treat all patches as positive if skipping classification
if args.skip_to_count == '1':
pos_patches = fnames
else:
# check if patches were already classified with class architecture
preds_path = './{}/ClassPredictions/{}/{}/class_predictions.csv'.format(
args.dest_folder.split('/')[0], args.class_architecture,
os.path.basename(args.input_image))
if os.path.exists(preds_path):
predictions = pd.read_csv(preds_path)
else:
# find patches with seals with classification CNN
num_classes = training_sets[args.training_dir]['num_classes']
model = model_defs['Pipeline1'][args.class_architecture](
num_classes)
use_gpu = torch.cuda.is_available()
if use_gpu:
model.cuda()
model.eval()
# load saved model weights from pt_train.py
model.load_state_dict(
torch.load("./saved_models_stable/Pipeline1/{}/{}.tar".format(
args.class_architecture, args.class_architecture)))
# classify patches
predictions = predict_patch(
model=model,
input_size=model_archs[args.class_architecture]['input_size'],
pipeline='Pipeline1',
batch_size=hyperparameters[
args.hyperparameter_set_class]['batch_size_test'],
test_dir='./' + args.dest_folder,
out_file='{}_class'.format(os.path.basename(input_image)[:-4]),
dest_folder='./' + args.dest_folder,
num_workers=hyperparameters[
args.hyperparameter_set_class]['num_workers_train'],
class_names=class_names)
os.makedirs('/'.join(preds_path.split('/')[:-1]))
predictions.to_csv(preds_path)
# add entries for predictions in GeoDataFrame
for row in predictions.iterrows():
fname = row[1]['filenames']
output_shpfile.loc[fname, 'label'] = row[1]['predictions']
# get the subset of positive patches filenames
positive_classes = args.pos_classes.split('_')
pos_patches = predictions.loc[
predictions['predictions'].isin(positive_classes), 'filenames']
if not os.path.exists('./{}/sub-tiles/images'.format(args.dest_folder)):
os.makedirs('./{}/sub-tiles/images'.format(args.dest_folder))
# loop over positive patches creating subpatches
for fname in pos_patches:
subpatches = get_subpatches(
patch=np.array(
Image.open('./{}/tiles/images/{}'.format(
args.dest_folder, fname))),
count_size=model_archs[args.count_architecture]['input_size'])
for idx, patch in enumerate(subpatches):
if np.min(patch) > 200 or np.max(patch) < 55:
continue
cv2.imwrite(
'./{}/sub-tiles/images/{}-{}'.format(args.dest_folder, idx,
fname), patch)
# remove tiles to count only sub-tiles
shutil.rmtree('./{}/tiles'.format(args.dest_folder))
# count inside subpatches with counting CNN
model = model_defs['Pipeline1.1'][args.count_architecture]
use_gpu = torch.cuda.is_available()
if use_gpu:
model.cuda()
model.eval()
# load saved model weights from pt_train.py
model.load_state_dict(
torch.load("./saved_models_stable/Pipeline1.1/{}/{}.tar".format(
args.count_architecture, args.count_architecture)))
counts = predict_patch(
model=model,
input_size=model_archs[args.count_architecture]['input_size'],
pipeline='Pipeline1.1',
batch_size=hyperparameters[
args.hyperparameter_set_count]['batch_size_test'],
test_dir='./' + args.dest_folder,
out_file='{}_count'.format(os.path.basename(input_image)[:-4]),
dest_folder='./' + args.dest_folder,
num_workers=hyperparameters[
args.hyperparameter_set_count]['num_workers_train'],
class_names=class_names)
print(' Total predicted in {}: '.format(os.path.basename(input_image)),
sum(counts['predictions']))
for row in counts.iterrows():
fname = row[1]['filenames'].split('-')[1]
output_shpfile.loc[fname, 'count'] += row[1]['predictions']
# save shapefile
shapefile_path = './{}/predicted_shapefiles/{}/'.format(
args.dest_folder,
os.path.basename(input_image)[:-4])
os.makedirs(shapefile_path)
output_shpfile.to_file(
shapefile_path +
'{}_prediction.shp'.format(os.path.basename(args.dest_folder)))
def main(input_df: gpd.GeoDataFrame, column=None, debug=False):
if input_df.crs is None: # assume 4326, WGS
input_df.crs = crs.WGS
original_crs = input_df.crs
input_df = input_df.to_crs(crs.GOOGLE)
input_df['x'] = input_df.geometry.apply(lambda g: g.x)
input_df['y'] = input_df.geometry.apply(lambda g: g.y)
input_df = input_df[input_df.x.notnull() & input_df.y.notnull()].copy(
).reset_index() # there are files with x/y == nan
points = input_df[['x', 'y']].as_matrix()
group_values = input_df[
column] if column is not None else input_df.index.tolist()
vor = scipy.spatial.Voronoi(points)
b = input_df.total_bounds
box_width = min(b[2] - b[0], b[3] - b[1])
polylines = []
ids = []
center = points.mean(axis=0)
for pointidx1, simplex in tqdm(zip(vor.ridge_points, vor.ridge_vertices),
desc='Processing Voronoi diagram'):
pointidx = pointidx1.tolist()
categories = [group_values[pointidx[0]], group_values[pointidx[1]]]
if categories[0] != categories[1]:
if -1 in simplex:
smp = np.asarray(simplex)
i = smp[smp >= 0][0]
t = points[pointidx[1]] - points[pointidx[0]] # tangent
t = t / np.linalg.norm(t)
n = np.array([-t[1], t[0]])
start = vor.vertices[i]
if np.linalg.norm(start - center) > 1000000:
continue
far_point = vor.vertices[i] + np.sign(np.dot(
start - center, n)) * n * 100000
n2 = np.linalg.norm(far_point - start)
if n2 > 1000000.0:
far_point = start + (far_point - start) / n2 * 100000
vertices = [start, far_point]
else:
vertices = [vor.vertices[simplex[0]], vor.vertices[simplex[1]]]
ids.append(categories)
polylines.append(LineString(vertices))
bbox = geo.box(*input_df.total_bounds).buffer(box_width * .1,
0,
join_style=2)
if debug:
write(gpd.GeoDataFrame({'geometry': polylines}),
'/tmp/debug-polylines.csv')
polylines.append(bbox.boundary)
polygons = list(polygonize(unary_union(polylines)))
result = gpd.GeoDataFrame({'geometry': polygons}, crs=crs.GOOGLE)
categories = []
subset = ['geometry']
if column is not None:
subset.append(column)
joined = gpd.sjoin(result, input_df[subset]).drop('index_right', axis=1)
if column is not None:
joined = joined.dissolve(column).reset_index()
return joined.to_crs(original_crs)
def get_stops_within_bounds(bounds):
# Returns a FeatureCollection with all public transport stops
bbox = geo.box(bounds['minx'], bounds['miny'], bounds['maxx'],
bounds['maxy'])
return db.session.query(PublicTransport).filter(
func.ST_Within(PublicTransport.geometry, dumps(bbox))).all()
def box_intersects(one, two):
"""Return true if two boxes (as vectors of xmin, ymin, xmax, ymax) intersect."""
return geo.box(*one).intersects(geo.box(*two))
def get_world_extent_native(self): # type: (...) -> Polygon
lon_ul, lat_ul = self._pixel_x_y_alt_to_lon_lat_native(0, 0)
lon_br, lat_br = self._pixel_x_y_alt_to_lon_lat_native(
self._npix_x, self._npix_y)
world_poly = box(lon_ul, lat_br, lon_br, lat_ul)
return world_poly
def create_patch_overlap_coord():
'''This part of the code creates the path image with overlapping coordinates'''
# img = openslide.OpenSlide(arg.svs_file)
# img_dim = img.level_dimensions[0]
# patch_size=10000
# """
# Determine what the patch size should be, and how many iterations it will take to get through the WSI
# """
# #num_x_patches = int(math.floor(img_dim[0]/patch_size))
# #num_y_patches = int(math.floor(img_dim[1]/patch_size))
# #print(str(num_x_patches)+" "+str(num_y_patches))
# print(len(regions))
# coords1=regions[8]
# min=np.argmin(coords1, axis = 0)
# #print(coords1[min[0]][0])
# #print(coords1[min[1]][1])
# #coords2=np.sort(coords1, axis = 0)
# #print(coords2)
# #sys.exit(1)
# x1=int(coords1[min[0]][0])-10
# y1=int(coords1[min[1]][1])-10
# level=0
# img_data = img.read_region((x1,y1),level, (patch_size, patch_size))
# img_data_np = np.array(img_data)
# img_name="sample.png"
# im = Image.fromarray(img_data_np)
# im.save(img_name)
# # Create figure and axes
# #fig,ax = plt.subplots(1)
# fig,ax = plt.subplots()
# # Display the image
# ax.imshow(img_data_np)
# #imgdata = plt.imread("sample.png")
# #ax.imshow(imgdata)
# # Add the patch to the Axes
# #points = [[2, 1], [8, 1], [8, 4],[50,50],[100,100],[200,200]]
# #plt.Polygon(points)
# #poly = Polygon(verts, facecolor='0.9', edgecolor='0.5')
# coords1_list=[]
# for i in range(0,len(coords1)):
# x_cor=int(coords1[i][0])-x1
# y_cor=int(coords1[i][1])-y1
# if x_cor >=0 and x_cor <= patch_size and y_cor >=0 and y_cor <=patch_size:
# tmp=(x_cor,y_cor)
# coords1_list.append(tmp)
# #coords1_list.append((100,300))
# #coords1_list.append((200,200))
# #coords1_list.append((400,200))
# #coords1_list.append((500,300))
# #coords1_list.append((400,400))
# #coords1_list.append((200,400))
# print(coords1_list)
# polygon = Polygon(coords1_list)
# patch = PolygonPatch(polygon, facecolor=[0,0,0], edgecolor=[0,0.5,0], alpha=0.7, zorder=2)
# ax.add_patch(patch)
# plt.savefig('sample_overlay.png', alpha=True, dpi=300)
# plt.show()
patch_size = 2000
OSobj = openslide.OpenSlide(arg.svs_file)
x1 = 40000
y1 = 37000
img_patch = OSobj.read_region((x1, y1), 0, (patch_size, patch_size))
img_data_np = np.array(img_patch)
#img_name="sample3.png"
#im = Image.fromarray(img_data_np)
#im.save(img_name)
# coords1_list=[]
# # #for j in range(0,len(regions)):
# for j in range(0,1):
# coords1=regions[j]
# for i in range(0,len(coords1)):
# x_cor=int(coords1[i][0])-x1
# y_cor=int(coords1[i][1])-y1
# # # #print(str(x_cor)+" "+str(y_cor))
# if x_cor >=0 and x_cor <= patch_size and y_cor >=0 and y_cor <=patch_size:
# tmp=(x_cor,y_cor)
# coords1_list.append(tmp)
# # # print(coords1_list)
# polygon = Polygon(coords1_list)
# # print(polygon)
# # # # Create figure and axes
# fig,ax = plt.subplots()
# # # # Display the image
# ax.imshow(img_data_np)
# # # # Add the patch to the Axes
# patch = PolygonPatch(polygon, facecolor=[0,0,0], edgecolor=[0,0.5,0], alpha=0.7, zorder=2)
# ax.add_patch(patch)
# plt.savefig('sample_overlay.png', alpha=True, dpi=300)
# plt.show()
# #ploting Steve's way
# #plt.style.use('dark_background')
# f, ax = plt.subplots(frameon=False)
# #f.set_facecolor('#eafff5')
# #ax.set_facecolor('#eafff5')
# f.tight_layout(pad=0, h_pad=0, w_pad=0)
# ax.set_xlim(0, patch_size)
# ax.set_ylim(0, patch_size)
# #img_data_np[np.where((img_data_np != [0,0,0]).all(axis = 2))] = [0,0,0]
# #ax.imshow(img_data_np)
# #mask1 = np.zeros(img_data_np.shape, dtype = "uint8")
# #mask1.fill(0)
# mask1 = Image.new('RGBA', (patch_size, patch_size), "black")
# ax.imshow(mask1)
# #ax.set_axis_bgcolor("black")
# #patch = PolygonPatch(polygon, facecolor=[0,0,0], edgecolor=[0,0.5,0], alpha=0.7, zorder=2)
# #patch = PolygonPatch(polygon, facecolor='#FFFFFF', edgecolor='#FFFFFF', alpha=0.7, zorder=2)
# patch = PolygonPatch(polygon, facecolor='white')
# ax.add_patch(patch)
# ax.set_axis_off()
# DPI = f.get_dpi()
# plt.subplots_adjust(left=0, bottom=0, right=1, top=1,wspace=0, hspace=0)
# f.set_size_inches(patch_size / DPI, patch_size / DPI)
# f.savefig("Mask_tmp.png", pad_inches='tight')
#create a binary mask
#mask = np.zeros(img_data_np, dtype = "uint8")
#cv2.rectangle(mask, (x1, y1), (x1+patch_size, y1+patch_size), (255, 255, 255), -1)
#print(img_data_np)
# flag = np.array([37500,38000, 0,0])
# #flag = np.array([36000,27000])
# #img_data_np=img_data_np+flag
# #mask = np.zeros((700,700))
# #print(regions[0])
# a=finalcoords
# a=np.int64(a)-flag
# a = a[~np.all(a < 0, axis=1)]
# a = a[~np.all(a > 10000, axis=1)]
# #print("sucess")
# #a2=a1[np.logical_and(a1>=0,a1<700)]
# print(a)
# sys.exit(1)
# poly = Polygon(regions[0])
# #img = Image.new('L', (700,700), 0)
# #ImageDraw.Draw(img).polygon(poly, outline=1, fill=1)
# mask = np.array((700,700))
# # Create vertex coordinates for each grid cell...
# # (<0,0> is at the top left of the grid in this system)
# #x, y = np.meshgrid(np.arange(700), np.arange(700))
# #x, y = x.flatten(), y.flatten()
# #points = np.vstack((x,y)).T
# #grid = points_inside_poly(points, poly)
# #grid = grid.reshape((ny,nx))
# print(poly)
# cv2.fillPoly(mask, poly, 1)
# mask = mask.astype(bool)
# plt.imshow(mask)
#print(Polygon(img_data_np).contains(poly_regions[0]))
#xmax, ymax = a.max(axis=0)
#print(img_data_np.shape)
#a = Polygon(np.array([(0, 0), (1, 1), (1,2), (2,2)]))
#b = Polygon(np.array([(0, 0), (1, 1), (2,1), (2,2)]))
# patch_list=[]
# x_n=300
# y_n=300
# size=x_n+y_n+x_n-2+y_n-2
# list1=[]
# n=0
# for x in range(0,x_n):
# tlist=[0+39000,x+34000]
# list1.append(tlist)
# for x in range(0,x_n):
# tlist=[x_n-1+39000,x+34000]
# list1.append(tlist)
# for x in range(1,y_n-1):
# tlist=[x+39000,0+34000]
# list1.append(tlist)
# for x in range(1,y_n-1):
# tlist=[x+39000,y_n-1+34000]
# list1.append(tlist)
path_poly = geo.box(x1, y1, x1 + patch_size, y1 + patch_size, ccw=True)
# # path_poly=Polygon(np.array(list1))
# # #path_poly=Polygon(np.array([[0, 0], [1, 0], [1, 1], [0, 1]]))
# # print(path_poly)
# # print(path_poly.is_valid)
# # print(path_poly.length)
# #print(poly_regions[0].is_valid)
#print(len(poly_regions))
poly_all = []
for j in range(0, len(poly_regions)):
#print(j)
poly1 = path_poly.intersection(poly_regions[j])
poly1_temp = []
if poly1.length > 0:
for x, y in poly1.exterior.coords:
x = int(x) - x1
y = int(y) - y1
tmp = (x, y)
poly1_temp.append(tmp)
poly1 = Polygon(poly1_temp)
poly_all.append(poly1)
#multi_poly = MultiPolygon(poly_all)
#print(len(poly_all))
#sys.exit(1)
#ploting Steve's way
#plt.style.use('dark_background')
f, ax = plt.subplots(frameon=False)
#ax.set_facecolor('#eafff5')
f.tight_layout(pad=0, h_pad=0, w_pad=0)
ax.set_xlim(0, patch_size)
ax.set_ylim(0, patch_size)
mask1 = Image.new('RGBA', (patch_size, patch_size), "black")
ax.imshow(mask1)
#patch1 = PolygonPatch(poly1, facecolor="white", edgecolor="white", alpha=0.7, zorder=2)
for j in range(0, len(poly_all)):
patch1 = PolygonPatch(poly_all[j], facecolor="white")
ax.add_patch(patch1)
ax.set_axis_off()
DPI = f.get_dpi()
plt.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0)
f.set_size_inches(patch_size / DPI, patch_size / DPI)
f.savefig("Mask_tmp1.png", pad_inches='tight')