def create_polygon(self, shape_polygon, alpha=np.nan):
""" Creates a polygon surrounding a cloud of shapepoints
:param shape_polygon: string, path to save the shapefile
:param alpha: float, excentricity of the alphashape (polygon) to be created
:returns: saves the polygon (*.shp) with the selected filename
"""
if np.isfinite(alpha):
try:
polygon = alphashape.alphashape(self.gdf, alpha)
polygon.crs = self.crs
polygon.to_file(shape_polygon)
print('Polygon *.shp saved successfully.')
except FileNotFoundError as e:
print(e)
else:
try:
polygon = alphashape.alphashape(self.gdf)
except FileNotFoundError as e:
print(e)
else:
polygon.crs = self.crs
polygon.to_file(shape_polygon)
print('Polygon *.shp saved successfully.')
def cocave_hull():
"""
Using alphashape() method from library to get both convex-hull points(alpha ≈ 0) and alpha shape points(high alpha value).
Deleting those points in alpha shape that are within the certain radius of each point in convex-hull.
Uning OpenCV approxPolyDP() to generate a fitted polygon.
"""
al_shape = alphashape.alphashape(data, 0.02)
hull_pts = al_shape.exterior.coords.xy
x = hull_pts[0]
y = hull_pts[1]
x, y = fine_tune(x, y, 0.8)
al_shape2 = alphashape.alphashape(data, 0.1285)
hull_pts2 = al_shape2.exterior.coords.xy
x5 = hull_pts2[0]
y5 = hull_pts2[1]
x5, y5 = fine_tune(x5, y5, 0.8)
for i in range(len(x)):
for j in range(len(x5) - 1, -1, -1):
dist = np.sqrt((x[i] - x5[j])**2 + (y[i] - y5[j])**2)
if (dist < 15):
x5 = np.delete(x5, j)
y5 = np.delete(y5, j)
return x5, y5
def surface_plot(fn):
pts = np.load(fn)
Cl = pts[:-1, 0]
Cm = pts[:-1, 1]
Cn = pts[:-1, 2]
ClCn = []
ClCm = []
CnCm = []
for i in range(len(Cl)):
ClCn.append((Cl[i], -Cn[i]))
ClCm.append((Cl[i], Cm[i]))
CnCm.append((-Cn[i], Cm[i]))
alpha_ClCn = alphashape.alphashape(ClCn, 5.0)
fig_ClCn, ax_ClCn = plt.subplots()
ax_ClCn.scatter(*zip(*ClCn))
ax_ClCn.scatter(pts[-1, 0], pts[-1, 2], color='r')
ax_ClCn.add_patch(PolygonPatch(alpha_ClCn, alpha=0.2, color='g'))
alpha_ClCm = alphashape.alphashape(ClCm, 2.0)
fig_ClCm, ax_ClCm = plt.subplots()
ax_ClCm.scatter(*zip(*ClCm))
ax_ClCm.scatter(pts[-1, 0], pts[-1, 1], color='r')
ax_ClCm.add_patch(PolygonPatch(alpha_ClCm, alpha=0.2, color='g'))
alpha_CnCm = alphashape.alphashape(CnCm, 5.0)
fig_CnCm, ax_CnCm = plt.subplots()
ax_CnCm.scatter(*zip(*CnCm))
ax_CnCm.scatter(pts[-1, 2], pts[-1, 1], color='r')
ax_CnCm.add_patch(PolygonPatch(alpha_CnCm, alpha=0.2, color='g'))
def hull_about(inside_points, outside_points, max_alpha, min_alpha):
alpha = max_alpha
shape = alphashape.alphashape(inside_points, alpha)
caught = [shapely.geometry.point.Point(p) for p in outside_points]
caught = [p for p in caught if shape.contains(p)]
while caught:
alpha *= 0.8
if alpha < min_alpha:
print("Min alpha reached")
break
shape = alphashape.alphashape(inside_points, alpha)
caught = [p for p in caught if shape.contains(p)]
return shape
def generate_image_and_stats(data, cluster_coords, regions_image,
optional_params, axes):
"""Adds cluster shape to shapes image and also returns regionprops of that shape"""
one_region_image = np.zeros((data["dimensions"][0], data["dimensions"][1]),
np.uint8)
concave_hull = alphashape.alphashape(cluster_coords)
border_points = concave_hull.exterior.coords
list_array = []
for coord in border_points:
list_array.append(coord)
# border_points = cluster_coords[spatial.ConvexHull(cluster_coords).vertices]
hull = spatial.ConvexHull(cluster_coords)
border_points = np.array(list_array, dtype='int32')
regions_image = cv2.fillPoly(regions_image, np.int32([border_points]),
(255, 255, 255))
one_region_image = cv2.fillPoly(one_region_image,
np.int32([border_points]), 255)
labeled_image = label(one_region_image, background=0)
properties = regionprops(labeled_image)
degrees = math.degrees(properties[0].orientation)
parameters = ((properties[0].centroid[1], properties[0].centroid[0]),
(int(properties[0].major_axis_length),
int(properties[0].minor_axis_length)), float(degrees))
regions_image = cv2.ellipse(regions_image, parameters, (0, 0, 255))
add_outline(border_points, axes, optional_params, properties)
ellipticity = compute_ellipticity_area_based(data, border_points)
return regions_image, properties, ellipticity, hull.area, hull.volume
def get_coor(image):
X, Y, Z = de_hole1(image)
Xk = roi(image)[0]
arr_X = []
arr_Y = []
for z in Z:
for x in X:
if z[0] == x[0] or z[1] == z[1]:
if check(z, x):
arr_X.append(z)
for z in Z:
for x in Y:
if z[0] == x[0] or z[1] == z[1]:
if check(z, x):
arr_Y.append(z)
output = []
arr = arr_X + arr_Y
for x in arr:
if x not in output:
output.append(x)
alpha = 0.3 * alphashape.optimizealpha(output)
hull = alphashape.alphashape(output, alpha)
hull_pts = hull.exterior.coords.xy
arr = []
for i in range(len(hull_pts[0])):
arr.append([int(hull_pts[0][i]), int(hull_pts[1][i])])
#r1=[[img[0]+Xk[0],img[1]+Xk[1]] for img in arr]
return arr
def calculate_concave_hull_of_points(pixel_coords, alpha=0.2):
"""
Return the alpha shape of the highlighted pixels using the alpha
entered by the user.
:param pixel_coords: the coordinates of the contour pixels
:return: List of lists of points ordered to form polygon(s).
"""
# Get all the pixels in the drawing window's list of highlighted
# pixels, excluding the removed pixels.
target_pixel_coords = [(item[0] + 1, item[1] + 1) for item in pixel_coords]
# Calculate the concave hull of the points.
# TODO: auto-generate an optimized alpha value
# alpha = 0.95 * alphashape.optimizealpha(points)
hull = target_pixel_coords
try:
hull = alphashape(target_pixel_coords, alpha)
except QhullError:
pass
polygon_list = []
if isinstance(hull, Polygon):
polygon_list.append(hull_to_points(hull))
elif isinstance(hull, MultiPolygon):
for polygon in hull:
polygon_list.append(hull_to_points(polygon))
return polygon_list
def get_alphashape(pdb, chain=None, plot=False):
'''
Returns an AlphaShape object of a pdb file, outlining its general
shape for use in a clash filter.
'''
if chain:
atoms = prody.parsePDB(pdb, chain=chain)
else:
atoms = prody.parsePDB(pdb)
atoms = atoms.select('not chain A')
# For some reason there is a level which is not populated. This may
# be for proteins w/ multiple chains.
coordsets = atoms.getCoordsets()
coords = []
for coordset in coordsets:
coords.extend(coordset)
# coords = [(0., 0.), (0., 1.), (1., 1.), (1., 0.), (0.5, 0.5)]
alpha_shape = alphashape.alphashape(coords, 0.18)
if plot:
helix = prody.parsePDB(pdb, chain='A')
helixcoords = helix.getCoordsets()[0]
fig = plt.figure()
# ax = fig.add_subplot(projection='3d')
ax = Axes3D(fig)
ax.scatter(*zip(*coords))
ax.scatter(*zip(*helixcoords))
# # ax.add_patch(PolygonPatch(alpha_shape, alpha=0.2))
ax.plot_trisurf(*zip(*alpha_shape.vertices),
triangles=alpha_shape.faces,
alpha=0.3)
plt.show()
return alpha_shape
def _testalpha(points, alpha):
"""
Evaluates an alpha parameter.
This helper function creates an alpha shape with the given points and alpha
parameter. It then checks that the produced shape is a Polygon and that it
intersects all the input points.
Args:
points (``shapely.geometry.Multipoint``): data points
alpha (float): alpha value
Returns:
bool: True if the resulting alpha shape is a single polygon that
intersects all the input data points.
"""
try:
from alphashape import alphashape
except ImportError:
from .alphashape import alphashape
polygon = alphashape(points, alpha)
if isinstance(polygon, shapely.geometry.polygon.Polygon) and all(
[polygon.intersects(point) for point in points]):
return True
else:
return False
def export_alphashape(path,files,params):
for idx in range(len(files)):
file_path = path + files[idx] + ext
points = []
with open(file_path) as f:
l_strip = [s.strip() for s in f.readlines()]
for l in l_strip:
if " " in l:
p2 = l.split(" ")
points.append([float(p2[0]), float(p2[2])])
alpha_shape = alphashape.alphashape(points, params[idx])
x, y = alpha_shape.exterior.coords.xy
num = len(x)
out_list = []
for i in range(num):
out_list.append(str(x[i])+" "+str(y[i]))
# print("clippoints["+str(i)+"].x =" + str(x[i])+";")
# print("clippoints["+str(i)+"].y =" + str(y[i])+";")
path_w = "../../resources/alpha_shapes/"+ files[idx] + ext
with open(path_w, mode='w') as f:
f.write(str(num)+"\n")
f.write('\n'.join(out_list))
print("write file:"+files[idx])
def get_coor(img):
(x,y),img=roi(img)
median = cv2.GaussianBlur(image,(5,5),0)
median = cv2.medianBlur(median,15)
hsv = cv2.cvtColor(median, cv2.COLOR_BGR2HSV)
lower_blue=np.array([91,111,68])
upper_blue=np.array([115,255,255])
mask=cv2.inRange(hsv,lower_blue,upper_blue)
edges = cv2.Canny(mask,100,200)
(contours,_) = cv2.findContours(edges.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
#hull = cv2.convexHull(contours,returnPoints = False)
#print(hull)
arr=[]
for contour in contours:
(x,y,w,h) = cv2.boundingRect(contour)
arr.append([x,y])
arr.append([x+w,y])
arr.append([x,y+h])
arr.append([x+w,y+h])
alpha = 0.4 * alphashape.optimizealpha(arr)
hull = alphashape.alphashape(arr, alpha)
hull_pts = hull.exterior.coords.xy
arr=[]
for i in range(len(hull_pts[0])):
arr.append([int(hull_pts[0][i]),int(hull_pts[1][i])])
results=[(np.array(z)+np.array([x,y])).tolist() for z in arr]
return results
def export_cluster_contour(geojson_path, alpha=None):
m = gpd.read_file(geojson_path)
cluster_label = m.label.unique()
if -1 in cluster_label:
cluster_label = np.delete(cluster_label, np.where(cluster_label == -1))
result = gpd.GeoDataFrame([])
for i in tqdm.tqdm(cluster_label):
print(i)
points = m[m.label == i].geometry.centroid
if len(points.unique()) < 4:
# print('cluster: ' + str(i) + 'doesn\'t work')
continue
result = result.append(
{
'label': i,
'geometry': alphashape.alphashape(points=points, alpha=alpha)
},
ignore_index=True)
result.plot()
plt.show()
result.to_file(geojson_path[:-8] + "_cluster_contour.geojson",
driver='GeoJSON')
def __getBoundary__(self):
'''
Sets object attributes: boundaryCurve, _sortIdx_
- Internal function, should not be used in isolation outside core.py
- Uses the alpha shape algorithm to get the boundary nodes - from alphashape library
- boundaryCurve stores the points (in order) which make up the boundary, as complex numbers
- _sortIdx_ is an internal attribute, index order to sort boundary cells, for connecting them correctly
'''
# Do alphashape import here, not needed anywhere else
import alphashape
# Get points into array format
points = np.column_stack([self.coords.real, self.coords.imag])
# Use alpha shape to get the bounding curve
# an alpha value of 0.1 performs well with nodes arranged in a circle or rectangle
# Basically just a small value over 0 seems to generalise well to simple shapes without ignoring the points on the sides of rectangle - since alpha=0 returns the convex hull
hull = alphashape.alphashape(points,alpha=0.1)
# Extract the actual coordinates into a numpy array
hull_pts = hull.boundary.coords.xy
hull_pts = np.array([hull_pts[0],hull_pts[1]])
# Put into complex format and assign into class attribute
self.boundaryCurve = hull_pts[0] + 1j * hull_pts[1]
# Get indices of these points within the full coords array
self._sortIdx_ = [np.where(self.coords == point)[0][0] for point in self.boundaryCurve]
def _create_mask(binary_data, slices=0):
result = np.zeros(binary_data[slices].shape)
coord_x, coord_y = np.where(binary_data[slices] > 0)
lst_pts = np.concatenate((coord_x[:, np.newaxis], coord_y[:, np.newaxis]),
axis=1)
alpha_shape = alphashape.alphashape(lst_pts[::16], 0.1)
if alpha_shape.type == 'MultiPolygon':
for alpha in alpha_shape:
if alpha.area > 20000:
x, y = alpha.exterior.coords.xy
rr, cc = polygon(np.asarray(x, dtype=np.int),
np.asarray(y, dtype=np.int))
result[rr, cc] = 1
elif alpha_shape.type == 'GeometryCollection':
pass
else:
x, y = alpha_shape.exterior.coords.xy
rr, cc = polygon(np.asarray(x, dtype=np.int),
np.asarray(y, dtype=np.int))
result[rr, cc] = 1
return result
def _testalpha(points: Union[List[Tuple[float]], np.ndarray], alpha: float):
"""
Evaluates an alpha parameter.
This helper function creates an alpha shape with the given points and alpha
parameter. It then checks that the produced shape is a Polygon and that it
intersects all the input points.
Args:
points: data points
alpha: alpha value
Returns:
bool: True if the resulting alpha shape is a single polygon that
intersects all the input data points.
"""
try:
from alphashape import alphashape
except ImportError:
from .alphashape import alphashape
polygon = alphashape(points, alpha)
if isinstance(polygon, shapely.geometry.polygon.Polygon):
if not isinstance(points, MultiPoint):
points = MultiPoint(list(points))
return all([polygon.intersects(point) for point in points])
elif isinstance(polygon, trimesh.base.Trimesh):
return len(polygon.faces) > 0 and all(
trimesh.proximity.signed_distance(polygon, list(points)) >= 0)
else:
return False
def next_update(self, timestep, states):
agents = states['agents']
points = [agent['boundary']['location'] for agent in agents.values()]
points = [tuple(point) for point in points if np.all(~np.isnan(point))]
alpha_shape = alphashape.alphashape(set(points),
self.parameters['alpha'])
if isinstance(alpha_shape, Polygon):
shapes = [alpha_shape]
elif isinstance(alpha_shape, (Point, LineString)):
# We need at least 3 cells to form a colony polygon
shapes = []
else:
assert isinstance(alpha_shape, (MultiPolygon, GeometryCollection))
shapes = list(alpha_shape)
agent_colony_map = gen_agent_colony_map(agents, shapes)
# Calculate colony surface areas
areas = [shape.area for shape in shapes]
# Calculate colony major and minor axes based on bounding
# rectangles
major_axes = []
minor_axes = []
for shape in shapes:
if isinstance(shape, Polygon):
major, minor = major_minor_axes(shape)
major_axes.append(major)
minor_axes.append(minor)
else:
major_axes.append(0)
minor_axes.append(0)
# Calculate colony circumference
circumference = [shape.length for shape in shapes]
# Calculate colony masses and cell surface areas
mass = [0] * len(shapes)
cell_area = [0] * len(shapes)
for agent_id, agent_state in agents.items():
if agent_id not in agent_colony_map:
# We ignore agents not in any colony
continue
colony_index = agent_colony_map[agent_id]
agent_mass = get_in(agent_state, ('boundary', 'mass'), 0)
mass[colony_index] += agent_mass
return {
'colony_global': {
'surface_area': areas,
'major_axis': major_axes,
'minor_axis': minor_axes,
'circumference': circumference,
'mass': mass,
}
}
def return_concave_hull(points):
# use alphashape library
#points=[(0., 0.), (0., 1.), (1., 1.), (1., 0.),
# (0.5, 0.25), (0.5, 0.75), (0.25, 0.5), (0.75, 0.5)]
#points = np.array([[10,10],[20,10],[10,20],[20,20]])
#alpha = 0.50*alphashape.optimizealpha(points)
hull = alphashape.alphashape(points, 0.05) #tune this as needed
hull_pts = hull.exterior.coords.xy
pts = np.vstack((hull_pts[0], hull_pts[1])).T
return pts
def getConcaveHull(self):
if self.dim == 3:
raise ValueError(
"3D point cloud concave hull calculation not provided.")
if self.concave_hull is None:
try:
self.concave_hull = alphashape(self.getPoints(), 2)
except QhullError:
self.concave_hull = None
return self.concave_hull
def get_coor12(image):
X, Y, Z = de_hole12(image)
if de_hole1(image) is not None:
Xk = roi(image)[0]
arr_X = []
arr_Y = []
for z in Z:
for x in X:
if z[0] == x[0] or z[1] == z[1]:
if check(z, x):
arr_X.append(z)
for z in Z:
for x in Y:
if z[0] == x[0] or z[1] == z[1]:
if check(z, x):
arr_Y.append(z)
output = []
arr = arr_X + arr_Y
for x in arr:
if x not in output:
output.append(x)
alpha = 0.3 * alphashape.optimizealpha(output)
hull = alphashape.alphashape(output, alpha)
hull_pts = hull.exterior.coords.xy
arr = []
for i in range(len(hull_pts[0])):
arr.append([int(hull_pts[0][i]), int(hull_pts[1][i])])
def check(coor1, coor2):
a = abs(coor1[0] - coor2[0]) + abs(coor2[1] - coor1[1])
if a > 10:
return False
return True
hull_pts = hull.exterior.coords.xy
arr1 = []
for i in range(len(hull_pts[0])):
arr1.append([int(hull_pts[0][i]), int(hull_pts[1][i])])
print(arr1)
t = {}
for i in range(len(arr1) - 1):
t[i] = [arr1[i + 1][0], arr1[i][1]]
print(t)
count = 1
for i in range(len(t)):
if t[i] is not arr1:
for v in arr:
if check(t[i], v):
arr1.insert(count, t[i])
count = count + 1
print(t[i])
break
count = count + 1
return arr1
def get_octomap_alpha_shape(self, map_2d, alpha):
'''
获取某高度以上的轮廓多边形
map_2d : 2d 的散点地图 类型： [(x,y),(x,y)...]
alpha : 控制生成的边界 类型：任意常数
return : 多个各个边界点 类型：[((x,y),(x,y)..),((x,y),(x,y)..)...]
它的原理可以想象成一个半径为α 的圆在点集 s 外滚动，当α足够大时，
这个圆就不会滚到点集内部，其滚动的痕迹就是这个点集的边界线。因此，当α
值很小，则每个点都是边界；如果α 很大（α →∞ ）时，则求出的边界线为
点集 s 的凸包。
'''
points = list(map_2d)
# 当获取到的点云数据大于2 时才能求他的边缘
if len(points) > 2:
# print (points)
# 获取点云的边缘多边形
time1 = time()
try:
alpha_shape = alphashape.alphashape(points, alpha)
except Exception:
print("异常")
return self.bank_muiltpolygon
time2 = time()
print("alpha_shape_time1: ", round((time2 - time1), 2))
polygon_list = []
if type(alpha_shape) == Polygon:
polygon_list.append(alpha_shape)
else:
for polygon in alpha_shape:
polygon_list.append(polygon)
for p in self.bank_muiltpolygon:
polygon = Polygon(p)
polygon_list.append(polygon)
# 将多个多边形进行融合
polygons = cascaded_union(polygon_list)
# 曲线平滑处理
polygons = polygons.simplify(0.6, preserve_topology=False)
if type(polygons) == Polygon:
self.bank_muiltpolygon = MultiPolygon([polygons])
else:
self.bank_muiltpolygon = polygons
# print (self.bank_muiltpolygon)
return self.bank_muiltpolygon
else:
return self.bank_muiltpolygon
def _poly_hull(map_2d: np.ndarray, threshold: float, alpha: float) -> List[sg.Polygon]:
points = np.argwhere(map_2d > threshold)
try:
polys = alphashape.alphashape(points, alpha)
except sp.QhullError:
return []
if isinstance(polys, sg.MultiPolygon):
return [p for p in polys]
elif isinstance(polys, sg.Polygon):
return [polys]
else:
return []
def polygon_from_shapepoints(shapepoints, polygon, alpha=np.nan):
"""
Create a polygon around a cloud of shapepoints
:param shapepoints: shape points filename, including directory.
:param polygon: target filename, including directory.
:param alpha: coefficient to adjust; the lower it is, the more slim will be the polygon.
:output: saves the polygon shapefile in the selected path
"""
gdf = geopandas.read_file(shapepoints)
# If the user doesnt select an alpha value, the alpha will be optimized automatically.
if np.isfinite(alpha):
try:
poly = alphashape.alphashape(gdf, alpha)
except FileNotFoundError as e:
print(e)
else:
try:
poly = alphashape.alphashape(gdf)
except FileNotFoundError as e:
print(e)
else:
poly.to_file(polygon)
def create_concave_polygon(gdf):
"""[summary] Takes in a dataframe sub frame of an area and creates a
polygon using alphashape, to create a concave_hull of the given area.
Arguments:
df {[geopandas]} -- [description]
alphashape_Value {[int]} -- set to 2.3
[the granuality of the concave hull.]
Returns:
[shapely.geometry.polygon.Polygon] -- [a shapely polygon, alphashape]
"""
# set to 2.3 [the granuality of the concave hull.]
polygon = alphashape.alphashape(gdf['Geometry'], 2.1)
return polygon
def join_polygons(polygons, loc=''):
"""construct concave hull (alpha shape) from input polygons"""
# compoundp = unary_union(polygons)
# jointp = compoundp.convex_hull
LOG = getLogger('processor.OcropyResegment')
if len(polygons) == 1:
return polygons[0]
# get equidistant list of points along hull
# (otherwise alphashape will jump across the interior)
points = [
poly.exterior.interpolate(dist).coords[0] # .xy
for poly in polygons for dist in np.arange(0, poly.length, 5.0)
]
#alpha = alphashape.optimizealpha(points) # too slow
alpha = 0.05
jointp = alphashape.alphashape(points, alpha)
tries = 0
# from descartes import PolygonPatch
# import matplotlib.pyplot as plt
while jointp.type in ['MultiPolygon', 'GeometryCollection']:
# plt.figure()
# plt.gca().scatter(*zip(*points))
# for geom in jointp.geoms:
# plt.gca().add_patch(PolygonPatch(geom, alpha=0.2))
# plt.show()
alpha *= 0.7
tries += 1
if tries > 10:
LOG.warning("cannot find alpha for concave hull on '%s'", loc)
alpha = 0
jointp = alphashape.alphashape(points, alpha)
if jointp.minimum_clearance < 1.0:
# follow-up calculations will necessarily be integer;
# so anticipate rounding here and then ensure validity
jointp = asPolygon(np.round(jointp.exterior.coords))
jointp = make_valid(jointp)
return jointp
def find_shapes(img, n, pixel_thresh=ACTIVE_PIXEL_THRESH):
img_gray = cv2.cvtColor(img, cv2.COLOR_BGRA2GRAY)
active_pixels = np.argwhere(np.flip(img_gray.T, axis=0) > pixel_thresh)
# TODO if DBSCAN then may want to resample to lower resolution
# and resolution of game may affect this later because of eps/min_samples
try:
clusters = DBSCAN(eps=5, min_samples=40,
metric='manhattan').fit(active_pixels)
except ValueError:
raise ValueError('Found 0 clouds in the image') from None
labels = np.unique(clusters.labels_)
clouds = [
active_pixels[np.argwhere(clusters.labels_ == lbl).flatten()]
for lbl in labels
]
if len(clouds) < n:
raise ValueError(f'Unable to find {n} clouds in the image')
elif len(clouds) > n:
print(f'WARNING: more than {n} clouds found in image')
clouds = sorted(clouds, key=len, reverse=True)[:n]
clouds = sorted(clouds, key=lambda c: c.min(axis=0)[1])
# shapes = [alphashape.alphashape(pt_cloud, 1) for pt_cloud in clouds]
shapes = [alphashape.alphashape(pt_cloud, 1) for pt_cloud in clouds]
return shapes
contours = [
np.array(list(zip(*shape.exterior.coords.xy))) for shape in shapes
]
contour_means = [contour.mean(axis=0) for contour in contours]
contour_maxs = [contour.max(axis=0) for contour in contours]
normalized_contours = [
(contour - contour_mean) / (contour_max[0] - contour_mean[0])
for contour, contour_mean, contour_max in zip(contours, contour_means,
contour_maxs)
]
# cloud_means = [cloud.mean(axis=0) for cloud in clouds]
# cloud_maxs = [cloud[:, 0].max() for cloud in clouds]
# normalized_pts = [(cloud - cloud_mean) / (cloud_max - cloud_mean[0]) for cloud, cloud_mean, cloud_max in zip(clouds, cloud_means, cloud_maxs)]
return normalized_contours
def testAlphashape(loc,time,alpha,channel):
lons = pd.read_csv('./../../data/extracts_{}/{}/{}{}_lons.csv'.format(loc,time,loc,time),header=None).to_numpy()
lats = pd.read_csv('./../../data/extracts_{}/{}/{}{}_lats.csv'.format(loc,time,loc,time),header=None).to_numpy()
data = pd.read_csv('./../../data/extracts_{}/{}/{}C07_{}_data.csv'.format(loc,time,loc,time),header=None).to_numpy()
print(lons.shape)
print(lats.shape)
print(data.shape)
indices = getIndexLevel(data,channel,"high")
latsByPattern = lats[indices]
lonsByPattern = lons[indices]
points = np.dstack((lonsByPattern,latsByPattern))
boundary = alphashape.alphashape(points[0],alpha)
print(boundary)
g = GeoSeries(boundary)
g.plot(cmap='winter')
plt.show()
def compute_iso(self,
points,
d_min=4,
line=True,
a_min=0,
a_max=0,
A=(0, 0)):
alpha_shape = np.array(
list(alphashape.alphashape(points, 0.43).exterior.coords))
if line:
angles = np.arctan2(alpha_shape[:, 1] - A[1],
alpha_shape[:, 0] - A[0])
#if faut travailler... he oui mon gars
return alpha_shape
def add_alphashap(points, ax, alpha_value=None, alpha=0.3, fc=None, ec=None):
"""
Add a alpha shape which corresponds to the ternary scatter plot
:param points: A list of 3-tuples that (i, j, k) requires i + j + k = scale
:param ax: the ax to plot the alpha shape, supposed to be same as the scatter plot
:param alpha_value: float. default None which will calculate the optimize. If zero a Convex hill will be added
:param alpha: float 0 to 1
:param fc: fill color
:param ec: edge color
:return: None
"""
t_points = to_t_points(points)
if alpha_value is None:
alpha_value = alphashape.optimizealpha(t_points)
alpha_shape = alphashape.alphashape(t_points, alpha_value)
ax.add_patch(PolygonPatch(alpha_shape, alpha=alpha, fc=fc, ec=ec))
def get_alphashape(points, alpha=0.1):
alpha_shape = alphashape.alphashape(points, alpha=alpha)
border = []
if type(alpha_shape).__name__ in ['Point', 'LineString']:
border = points.copy()
elif type(alpha_shape).__name__ == 'Polygon':
border = np.array(alpha_shape.exterior.coords)
elif type(alpha_shape).__name__ == 'MultiPolygon':
border = np.array([
point for polygon in alpha_shape
for point in polygon.exterior.coords[:-1]
])
# pdb.set_trace()
border_indices = [
np.where(np.all(points == v, axis=1))[0][0] for v in border
]
return (border_indices, border)
def generateStream():
times = []
dataChannel = {}
dataWeather = {}
days = ['extracts_{}'.format(location)] #['8','9','10','11','12','13','14']
points = {}
for c in patterns.keys():
points[c] = []
categories = []
boundaries = []
levels = []
# lats = lats.to_numpy()
# lons = lons.to_numpy()
# for w in weathers
for subdir in days:
print(subdir)
for rootDay,subdirDays,fileDays in os.walk("{}/{}/".format(dataset,subdir)):
subdirDays = sorted(subdirDays,key=sortTime)
for subdirDay in subdirDays:
print(subdirDay)
for c in patterns.keys():
for level in ["low","normal","high"]:
try:
dataChannel[c] = pd.read_csv("{}/{}/{}/{}{}_{}_data.csv".format(dataset,subdir,subdirDay,location,c,subdirDay),header=None).to_numpy()
indexs = getIndexLevel(dataChannel[c],c,level) #np.where(dataChannel[c] > thresholds[c][patterns[c]])
if indexs[0].size == 0:
continue
latsByPattern = lats[indexs]
lonsByPattern = lons[indexs]
points = np.dstack((lonsByPattern,latsByPattern))
boundary = alphashape.alphashape(points[0],50.0)
except:
continue
times.append(subdirDay)
categories.append(c)
boundaries.append(boundary)
levels.append(level)
df = pd.DataFrame({
'time' : times,
'category' : categories,
'boundary' : boundaries,
'value' : levels
})
gdf = gpd.GeoDataFrame(df,geometry='boundary')
gdf.to_csv('{}/Satellite_Events_Stream_Standard_in_{}.csv'.format(thresh_dir,subdir),index=None)
