def getPixelCoordinatesOfBuildings(urlBuildings, midX, midY):
images['source']['value'] = io.imread(urlBuildings)
images['grayscale']['value'] = color.rgb2gray(images['source']['value'])
# Will create inverted binary image.
images['binary']['value'] = np.where(
images['grayscale']['value'] > np.mean(images['grayscale']['value']),
0.0, 1.0)
contours = find_contours(images['binary']['value'], 0.1)
for n, contourBuilding in enumerate(contours):
if (contourBuilding[0, 1]
== contourBuilding[-1, 1]) and (contourBuilding[0, 0]
== contourBuilding[-1, 0]):
# Check if it is inside any other polygon, so this will remove any additional elements.
isInside = False
skipPoly = False
for othersPolygon in contours:
isInside = points_in_poly(contourBuilding, othersPolygon)
if all(isInside):
skipPoly = True
break
if skipPoly == False:
center_inside = points_in_poly(np.array([[midX, midY]]),
contourBuilding)
if center_inside:
# Approximate will generalize the polygon.
mainBuilding = approximate_polygon(contourBuilding,
tolerance=2)
print('Main building: ' + str(mainBuilding)) # DEBUG
def test_square(self):
v = np.array([[0, 0],
[0, 1],
[1, 1],
[1, 0]])
assert(points_in_poly([[0.5, 0.5]], v)[0])
assert(not points_in_poly([[-0.1, 0.1]], v)[0])
def test_triangle(self):
v = np.array([[0, 0],
[1, 0],
[0.5, 0.75]])
assert(points_in_poly([[0.5, 0.7]], v)[0])
assert(not points_in_poly([[0.5, 0.76]], v)[0])
assert(not points_in_poly([[0.7, 0.5]], v)[0])
def get_polygon_inner_point(polygon):
"""
Algorithm:
1) Take a point on the exterior boundary
2) Find an adjacent point (with digitized coordinates) that lies in the polygon
3) Return the coordinates of this point
Parameters
----------
polygon: Polygon
The polygon
Returns
-------
point: tuple
(x, y) coordinates for the found points. x and y are integers.
"""
if isinstance(polygon, Point):
return int(polygon.x), int(polygon.y)
if isinstance(polygon, LineString):
return [int(c) for c in polygon.coords[0]]
# this function works whether or not the boundary is inside or outside (one pixel around) the
# object boundary in the mask
exterior = polygon.exterior.coords
for x, y in exterior: # usually this function will return in one iteration
neighbours = np.array(neighbour_pixels(int(x), int(y)))
in_poly = np.array(points_in_poly(list(neighbours), exterior))
if np.count_nonzero(
in_poly) > 0: # make sure at least one point is in the polygon
return neighbours[in_poly][0]
if len(exterior) == 4: # fallback for three pixel polygons
return [int(v) for v in exterior[0]]
raise ValueError(
"No points could be found inside the polygon ({}) !".format(
polygon.wkt))
def _exclude_bad_XYpos(self, GDF):
"""Exclude all points outside of the image overlap area and where the bad data mask is True (if given).
:param GDF: <geopandas.GeoDataFrame> must include the columns 'X_UTM' and 'Y_UTM'
:return:
"""
from skimage.measure import points_in_poly # import here to avoid static TLS ImportError
# exclude all points outside of overlap area
inliers = points_in_poly(self.XY_mapPoints,
np.swapaxes(np.array(self.COREG_obj.overlap_poly.exterior.coords.xy), 0, 1))
GDF = GDF[inliers].copy()
# GDF = GDF[GDF['geometry'].within(self.COREG_obj.overlap_poly.simplify(tolerance=15))] # works but much slower
assert not GDF.empty, 'No coregistration point could be placed within the overlap area. Check your input data!'
# exclude all points where bad data mask is True (e.g. points on clouds etc.)
orig_len_GDF = len(GDF) # length of GDF after dropping all points outside the overlap polygon
mapXY = np.array(GDF.loc[:, ['X_UTM', 'Y_UTM']])
GDF['REF_BADDATA'] = self.COREG_obj.ref.mask_baddata.read_pointData(mapXY) \
if self.COREG_obj.ref.mask_baddata is not None else False
GDF['TGT_BADDATA'] = self.COREG_obj.shift.mask_baddata.read_pointData(mapXY) \
if self.COREG_obj.shift.mask_baddata is not None else False
GDF = GDF[(~GDF['REF_BADDATA']) & (~GDF['TGT_BADDATA'])]
if self.COREG_obj.ref.mask_baddata is not None or self.COREG_obj.shift.mask_baddata is not None:
if not self.q:
if not GDF.empty:
print('With respect to the provided bad data mask(s) %s points of initially %s have been excluded.'
% (orig_len_GDF - len(GDF), orig_len_GDF))
else:
warnings.warn('With respect to the provided bad data mask(s) no coregistration point could be '
'placed within an image area usable for coregistration.')
return GDF
def ExtractImage(tc,index =1, offsetx=128,offsety =128, level = 0):
offsetx = 128
offsety = 128
name = tc.Get_Aname(index)
pl_arr = tc.AnnotationDots(index)
pl_arr = np.vstack((pl_arr,pl_arr[0]))
xi = pl_arr[:,0].min()
xa = pl_arr[:,0].max()
yi = pl_arr[:,1].min()
ya = pl_arr[:,1].max()
tmpim = tc.img.read_region((xi-offsetx,yi-offsety),level,((xa-xi+2*offsetx)/2**level,(ya-yi+2*offsety)/2**level))
#fig,ax = plt.subplots()
#ax.imshow(tmpim)
#ax.axis('image')
#ax.axis('off')
#ax.plot((pl_arr[:,0]-xi+offsetx)/2**level,(pl_arr[:,1]-yi+offsety)/2**level,'y-',linewidth =3)
pl_arr2 = pl_arr
pl_arr2[:,0] = pl_arr[:,0]-xi+offsetx
pl_arr2[:,1] = pl_arr[:,1]-yi+offsety
maskx = pl_arr2[:,0].max() + offsetx
masky = pl_arr2[:,1].max() + offsety
maskp = [(x,y) for x in range(maskx) for y in range(masky)]
mask2 = measure.points_in_poly(maskp,pl_arr2)
mask = np.reshape(mask2,(maskx,masky)).T
mask = resize(mask, (np.array(tmpim).shape[0],np.array(tmpim).shape[1]))>0
#plt.figure()
#plt.imshow(mask)
return name,np.array(tmpim),mask
def ExtractAnnotationImage(self,
index=1,
offsetx=128,
offsety=128,
level=0):
"""
tc : CRLM instance
index: index of the annotation
offsetx,offsety: offset for extending the anontation area
level: magnification level for extaction
"""
name = self.Get_Aname(index)
pl_arr = self.AnnotationDots(index)
pl_arr = np.vstack((pl_arr, pl_arr[0]))
xi = pl_arr[:, 0].min()
xa = pl_arr[:, 0].max()
yi = pl_arr[:, 1].min()
ya = pl_arr[:, 1].max()
tmpim = self.img.read_region((xi-offsetx,yi-offsety),level,\
(int((xa-xi+2*offsetx)/2**level),int((ya-yi+2*offsety)/2**level)))
pl_arr2 = pl_arr
pl_arr2[:, 0] = pl_arr[:, 0] - xi + offsetx
pl_arr2[:, 1] = pl_arr[:, 1] - yi + offsety
maskx = pl_arr2[:, 0].max() + offsetx
masky = pl_arr2[:, 1].max() + offsety
maskp = [(x, y) for x in range(maskx) for y in range(masky)]
mask2 = measure.points_in_poly(maskp, pl_arr2)
mask = np.reshape(mask2, (maskx, masky)).T
mask = resize(mask,
(np.array(tmpim).shape[0], np.array(tmpim).shape[1])) > 0
return name, np.array(tmpim), mask
def get_sequences(tumors):
list_of_sequence = []
sequence = []
j = 0
while np.count_nonzero(tumors[..., j]) == 0:
j += 1
sequence.append(j)
label_image = label(tumors[..., j])
contour = find_contours(label_image, 0)[0]
coords_region_previous = approximate_polygon(contour, tolerance=0)
previous_index = j
for i in range(j + 1, tumors.shape[2]):
if np.count_nonzero(tumors[..., i]) == 0:
continue
label_image = label(tumors[..., i])
centroid = regionprops(label_image)[0].centroid
centroid = np.asarray([int(x) for x in centroid]).reshape(1, 2)
if points_in_poly(centroid, coords_region_previous) and abs(i - previous_index) < 3:
sequence.append(i)
else:
list_of_sequence.append(sequence)
sequence = []
sequence.append(i)
contour = find_contours(label_image, 0)[0]
coords_region_previous = approximate_polygon(contour, tolerance=0)
previous_index = i
list_of_sequence.append(sequence)
return list_of_sequence
def merge_sublist(list_of_sequence, tumors):
flag = True
while flag:
merged_sublists = []
for i in range(1, len(list_of_sequence) - 2):
if (len(list_of_sequence[i]) == 1 and len(list_of_sequence[i - 1]) >= 2 and len(list_of_sequence[i + 1]) >= 2 and
abs(list_of_sequence[i - 1][-1] - list_of_sequence[i][0]) < 3 and abs(list_of_sequence[i][-1] - list_of_sequence[i + 1][0]) < 3):
label_image = label(tumors[..., list_of_sequence[i - 1][-1]])
contour = find_contours(label_image, 0)[0]
coords_region_previous = approximate_polygon(contour, tolerance=0)
label_image = label(tumors[..., list_of_sequence[i + 1][0]])
centroid = regionprops(label_image)[0].centroid
centroid = np.asarray([int(x) for x in centroid]).reshape(1, 2)
if points_in_poly(centroid, coords_region_previous):
new_sublist = []
new_sublist = list_of_sequence[i - 1] + list_of_sequence[i] + list_of_sequence[i + 1]
merged_sublists += (new_sublist, i - 1)
flag = True
break
flag = False
if flag:
del list_of_sequence[merged_sublists[1]]
del list_of_sequence[merged_sublists[1]]
del list_of_sequence[merged_sublists[1]]
list_of_sequence.append(merged_sublists[0])
list_of_sequence.sort(key=lambda x:x[0])
return list_of_sequence
def get_polygon_inner_point(polygon):
"""
Algorithm:
1) Take a point on the exterior boundary
2) Find an adjacent point (with digitized coordinates) that lies in the polygon
3) Return the coordinates of this point
Parameters
----------
polygon: Polygon
The polygon
Returns
-------
point: tuple
(x, y) coordinates for the found points. x and y are integers.
"""
if isinstance(polygon, Point):
return int(polygon.x), int(polygon.y)
if isinstance(polygon, LineString):
return [int(c) for c in polygon.coords[0]]
# this function works whether or not the boundary is inside or outside (one pixel around) the
# object boundary in the mask
exterior = polygon.exterior.coords
for x, y in exterior: # usually this function will return in one iteration
neighbours = np.array(neighbour_pixels(int(x), int(y)))
in_poly = np.array(points_in_poly(list(neighbours), exterior))
if np.count_nonzero(in_poly) > 0: # make sure at least one point is in the polygon
return neighbours[in_poly][0]
if len(exterior) == 4: # fallback for three pixel polygons
return [int(v) for v in exterior[0]]
raise ValueError("No points could be found inside the polygon ({}) !".format(polygon.wkt))
def get_tumors_post(sub, coords, min_slice, max_slice):
struct = disk(4)
tumors = np.zeros(sub.shape)
for i in range(min_slice - 10, max_slice + 10):
if np.count_nonzero(sub[..., i]) == 0:
continue
test = binary_opening(sub[..., i], struct)
label_image = label(test)
list_of_data = []
for region in regionprops(label_image):
data = []
centroid = tuple(int(x) for x in region.centroid)
if (region.eccentricity < 0.95 and region.extent > 0.45 and region.area < 3600 and region.area > 50
and np.sum(points_in_poly(region.coords, coords)) > region.area // 2):
data.append(centroid)
data.append(region.area)
list_of_data.append(data)
if not list_of_data:
continue
centroid = max(list_of_data, key=lambda item:item[1])[0]
segmented_tumor = flood_fill(label_image, centroid, 255)
segmented_tumor[segmented_tumor < 255] = 0
tumors[..., i] = segmented_tumor
tumors /= 255
return tumors
def region_encloses_grid_center(region, grid_centers):
poly = bbox_to_poly(region.bbox)
hits = measure.points_in_poly(grid_centers, poly)
if np.sometrue(hits) and (np.sum(hits) == 1):
return True, np.argwhere(hits).flatten().tolist()
else:
return False, None
def _assign(cells_region: regional.many,
intensities: IntensityTable,
use_hull: bool = True,
verbose: bool = False) -> IntensityTable:
x = intensities.coords[Indices.X.value].values
y = intensities.coords[Indices.Y.value].values
points = pd.DataFrame(dict(x=x, y=y))
results = pd.DataFrame({'spot_id': range(0, intensities.shape[0])})
results[Features.CELL_ID] = None
if verbose:
cell_iterator = tqdm(range(cells_region.count))
else:
cell_iterator = range(cells_region.count)
for cell_id in cell_iterator:
if use_hull:
vertices = cells_region[cell_id].hull
else:
vertices = cells_region[cell_id].coordinates
vertices = np.array(vertices)
in_poly = points_in_poly(points, vertices)
results.loc[results.spot_id[in_poly], Features.CELL_ID] = cell_id
intensities[Features.CELL_ID] = (Features.AXIS,
results[Features.CELL_ID])
return intensities
def points_inside_curve(points, contour):
"""
Uses skimage.measure.points_in_poly function to find whether points are inside a contour (polygon)
:param points: 2d array (N, 2) of points coordinates viz. skimage.measure.points_in_poly
:param contour: 2d array of contour (polygon) coordinates viz. skimage.measure.points_in_poly
:return: array of bool
"""
return measure.points_in_poly(points, contour)
def inside(self, coord):
"""
Determine if a given coordinate is inside the polygon or not.
Arguments:
coord: 2 element tuple of int, e.g. (x, y)
Returns:
bool, if the coord is inside the polygon.
"""
return points_in_poly([coord], self._vertices)[0]
def does_contain(self, points: list) -> Sequence[bool]:
'''Check if the Annotation object contains the given coordinate.
- Args
points: A list of points to perform the test
- Returns
True if the given coorindate is inside the Annotation object,
False otherwise
'''
return points_in_poly(points, self.coords)
def prepare_mask_on_grid(x, y, mask_coords):
""" Converts mask coordinates of the image mask
to the grid of 1/0 on the x,y grid
Inputs:
x,y : grid of x,y points
mask_coords : array of coordinates in pixels of the image_mask
Outputs:
grid of points of the mask, of the shape of x
"""
xymask = points_in_poly(np.c_[y.flatten(), x.flatten()], mask_coords)
return xymask.reshape(x.shape).astype(np.int)
def contains_points(self, points: np.ndarray) -> np.ndarray:
"""Test whether points lie inside a polygon.
Parameters
----------
points : (n,2) np.ndarray
Description
Returns
-------
mask : (n,) boolean np.ndarray
True if corresponding point is inside the p olygon
"""
return measure.points_in_poly(points, self.points)
def get_surface(equilibrium,
psi,
r=100,
z=100,
norm=True,
closed=True,
insidelcfs=True):
"""
Finds points of surface with given value of psi.
:param equilibrium: Equilibrium object
:param psi: Value of psi to get the surface for
:param r: If number, specifies number of points in the r dimension of the mesh. If numpy array,
gives r grid points.
:param z: If number, specifies number of points in the z dimension of the mesh. If numpy array,
gives z grid points.
:param norm: Specifies whether we are working with normalised values of psi
:param closed: Are we looking for a closed surface?
:param insidelcfs: Are we looking for a closed surface inside lcfs?
:return: List of contours with surface coordinates
"""
# if r is integer make r grid
if not isinstance(r, np.ndarray):
r = np.linspace(equilibrium.R_min, equilibrium.R_max, r)
# if z is integer make z grid
if not isinstance(z, np.ndarray):
z = np.linspace(equilibrium.Z_min, equilibrium.Z_max, z)
# should we work with psi or psi_n
if norm:
psipol = equilibrium.psi_n(R=r, Z=z)
else:
psipol = equilibrium.psi(R=r, Z=z)
# find contours
contour = find_contour(psipol, psi, r, z)
# now we want the surfaces which enclose the magnetic acis, not some surfaces outside the vessel
fluxsurface = []
magaxis = np.expand_dims(equilibrium._mg_axis, axis=0)
for i in range(len(contour)):
# are we looking for a closed magnetic surface and is it closed?
if closed and curve_is_closed(contour[i]):
isinside = measure.points_in_poly(magaxis, contour[i])
# surface inside lcfs has to be enclosing magnetic axis
if insidelcfs and np.asscalar(isinside):
fluxsurface.append(contour[i])
return fluxsurface
def in_Polygon(self, x, y, scale=None):
self.get_cor(scale)
# print(self._regions)
for k, reigon in self._regions.items():
X = reigon['X']
Y = reigon['Y']
polygon = [[x, y] for x, y in zip(X, Y)]
vertices = np.array(polygon)
#print(vertices.shape)
coord = (x, y)
if points_in_poly([coord], vertices)[0]:
continue
else:
return False
return True
def _assign(cells_region, spots, use_hull=True, verbose=False):
res = pd.DataFrame({'spot_id': range(0, spots.shape[0])})
res['cell_id'] = None
for cell_id in range(cells_region.count):
if use_hull:
verts = cells_region[cell_id].hull
else:
verts = cells_region[cell_id].coordinates
verts = np.array(verts)
in_poly = points_in_poly(spots, verts)
res.loc[res.spot_id[in_poly], 'cell_id'] = cell_id
if verbose:
cnt = np.sum(in_poly)
print(cell_id, cnt)
return res
def inside_object(pred, obj):
# bounding box
if obj.object_type == '0':
x1, y1, x2, y2 = obj.coordinates
x, y = pred.coordinates
return x1 <= x <= x2 and y1 <= y <= y2
# bounding ellipse
if obj.object_type == '1':
x1, y1, x2, y2 = obj.coordinates
x, y = pred.coordinates
x_center, y_center = (x1 + x2) / 2, (y1 + y2) / 2
x_axis, y_axis = (x2 - x1) / 2, (y2 - y1) / 2
return ((x - x_center) / x_axis)**2 + ((y - y_center) / y_axis)**2 <= 1
# mask/polygon
if obj.object_type == '2':
num_points = len(obj.coordinates) // 2
poly_points = obj.coordinates.reshape(num_points, 2, order='C')
return points_in_poly(pred.coordinates.reshape(1, 2), poly_points)[0]
def find_point(self) -> np.ndarray:
"""Use rejection sampling to find point in polygon.
Returns
-------
point : np.ndarray
Coordinate of point in the polygon
"""
# start with guess in center of polygon
point = self.points.mean(axis=0)
while not measure.points_in_poly([point], self.points):
xmin, ymin = self.points.min(axis=0)
xmax, ymax = self.points.max(axis=0)
point = np.random.uniform(xmin,
xmax), np.random.uniform(ymin, ymax)
return point
def velocalc(outpath,
blobCoords, t, NoZeroVelocity=None,
favoured_direction=None):
''' Calculates velocity over the entire blob
video = number from zero to # of videos
'''
if NoZeroVelocity is None:
NoZeroVelocity = True
contours1 = getWaveContours(blobCoords, t)
contours2 = getWaveContours(blobCoords, t+1)
# only consider positive wave-veloxities (e.g. contours outside the precendent contours)
w2_end = np.zeros((0, 2))
len_zeroSpeed = 0
for w2 in contours2:
combi = np.zeros(len(w2.T), dtype=bool)
points_check = w2.T
for w1 in contours1:
on_poly = points_on_poly(points_check, w1.T)
inside = measure.points_in_poly(np.array(points_check), w1.T)
combi += on_poly + inside
len_zeroSpeed += len(on_poly)
w2_end = np.concatenate((w2_end, points_check[~combi]), axis=0)
if NoZeroVelocity:
len_zeroSpeed = 0
# compare the outside-contours (w2_end) with all precedent contours
w1 = np.zeros((0, 2))
for w in contours1:
w1 = np.concatenate((w1, w.T))
# get velocity
if (len(w2_end) != 0 and len(w1) != 0):
data = GetFrontDisplacementAlongSpline(w2_end, w1)
if favoured_direction is not None:
data = FilterVelocitiesByDirection(data, favoured_direction)
all_velocity = np.append(data[:,2], np.zeros(len_zeroSpeed)).flatten()
elif len_zeroSpeed != 0:
all_velocity = np.zeros(len_zeroSpeed)
else:
all_velocity = []
return all_velocity
def boxcheck_merge(df1, df2, pointcol, boxcol, dropcols=False):
new_df = pd.DataFrame()
for i, point in enumerate(df1[pointcol]):
arr_point = np.array(point).reshape(1, 2)
for j, bbox in enumerate(df2[boxcol]):
boxcheck = measure.points_in_poly(arr_point, bbox)
if boxcheck == True:
series1 = df1.loc[i]
series2 = df2.loc[j]
combo_series = series1.append(series2)
new_df = new_df.append(combo_series, ignore_index=True)
df1.drop([i], inplace=True)
break
if (dropcols == True) & (not new_df.empty):
new_df.drop(columns=[
'centroid_skel', 'label_bin', 'median_background',
'median_intensity', 'pc'
],
inplace=True)
return new_df
def fill(lung):
struct = disk(5)
test = lung.copy()
for i in range(lung.shape[2]):
test[..., i] = binary_fill_holes(lung[..., i])
label_test, num = label(test[..., i], return_num=True)
if num != 2:
continue
chull = convex_hull_object(test[..., i])
coords = []
for contour in find_contours(chull, 0):
coords.append(approximate_polygon(contour, tolerance=0))
if len(coords) < 2:
continue
inverted = np.invert(test[..., i])
distance = ndi.distance_transform_edt(inverted)
peaks = peak_local_max(distance, labels=inverted)
left_peaks = points_in_poly(peaks, coords[0])
right_peaks = points_in_poly(peaks, coords[1])
peaks_mask = left_peaks | right_peaks
peaks = peaks[peaks_mask]
peak_image = np.zeros(lung[..., i].shape)
peak_image[peaks[:, 0], peaks[:, 1]] = 1
if len(peaks == 1):
peak_image[0, 0] = 1
markers = ndi.label(peak_image)[0]
labels = watershed(-distance, markers, mask=inverted)
labels[labels == 1] = 0
for region in regionprops(labels):
centroid = np.asarray([int(x) for x in region.centroid]).reshape(1, 2)
if ((np.sum(points_in_poly(region.coords, coords[0])) < region.area and
np.sum(points_in_poly(region.coords, coords[1])) < region.area) or
(not points_in_poly(centroid, coords[1]) and not points_in_poly(centroid, coords[1]))):
centroid = tuple(int(x) for x in region.centroid)
labels = flood_fill(labels, centroid, 0)
labels[labels > 0] = 255
test[..., i][labels > 0] = 255
return test
def leftPressed(self, x, y, mods):
selected_blobs = self.viewerplus.selected_blobs
# no selected blobs: select it!
if len(selected_blobs) == 0:
selected_blob = self.viewerplus.annotations.clickedBlob(x, y)
if selected_blob is None:
self.infoMessage.emit("Click on an area to split.")
return
self.viewerplus.addToSelectedList(selected_blob)
if len(selected_blobs) != 1:
self.infoMessage.emit("A single selected area is required.")
self.pick_points.reset()
return
condition = points_in_poly(np.array([[x, y]]), self.viewerplus.selected_blobs[0].contour)
if condition[0] != True:
self.infoMessage.emit("Click on the selected area to split.")
return
self.pick_points.addPoint(x, y, self.pick_style)
def snapToContour(self, points, contour):
"""
Given a curve specified as a set of points, snap the curve on the blob mask:
1) the initial segments of the curve are removed until they snap
2) the end segments of the curve are removed until they snap
"""
test = points_in_poly(points, contour)
if test is None or test.shape[0] <= 3:
return None
jump = np.gradient(test.astype(int))
ind = np.nonzero(jump)
ind = np.asarray(ind)
snappoints = None
if ind.shape[1] > 2:
first_el = ind[0, 0]
last_el = ind[0, -1]
snappoints = points[first_el:last_el + 1, :].copy()
return snappoints
def mom_ellipseparams_poly(poly):
"""
Return the (estimated) moment ellipse params of a polygon.
Parameters
----------
poly : (N*2) ndarray of double
list of corner coordinates (r,c) of the polygon.
Returns
----------
params: list
[m0, xc, yc, a, b, theta]
where m0 is the total area
"""
from copy import deepcopy
from skimage.measure import points_in_poly
import moment
poly = deepcopy(poly)
xmin, xmax = np.min(poly[:, 1], axis=0.), np.max(poly[:, 1], axis=0.)
ymin, ymax = np.min(poly[:, 0], axis=0.), np.max(poly[:, 0], axis=0.)
poly[:, 1] = poly[:, 1]-xmin
poly[:, 0] = poly[:, 0]-ymin
img = np.zeros([int(ymax-ymin), int(xmax-xmin)])
for i in range(img.shape[0]):
for j in range(img.shape[1]):
if points_in_poly([[i,j]],poly):
img[i,j]=1.
if np.sum(img)>0.:
params=moment.mom_ellipseparams(img)
params[1]=xmin+params[1]
params[2]=ymin+params[2]
return params
else:
return [0., 0., 0., 0., 0., 0.]
def clickedBlob(self, x, y):
"""
It returns the blob clicked with the smallest area (to avoid problems with overlapping blobs).
"""
blobs_clicked = []
for blob in self.seg_blobs:
point = np.array([[x, y]])
out = measure.points_in_poly(point, blob.contour)
if out[0] == True:
blobs_clicked.append(blob)
area_min = 100000000.0
selected_blob = None
for i in range(len(blobs_clicked)):
blob = blobs_clicked[i]
if blob.area < area_min:
area_min = blob.area
selected_blob = blob
return selected_blob
def get_mask(self, shape, region):
"""
Parameters
----------
region : {'upper left', 'lower right'}
"""
if region == 'upper left':
theta = np.linspace(self.THETA_END, self.THETA_START - 2 * np.pi)
elif region == 'lower right':
theta = np.linspace(self.THETA_END, self.THETA_START)
else:
msg = "Expected 'upper left' or 'lower right'; got %s" % region
raise ValueError(msg)
xy_circle = self.circle.point_from_angle(theta).T
x, y = self.snake_curve()
xy_curve = np.array((x, y)).T
xy_poly = np.vstack((xy_curve, xy_circle))
h, w = shape[:2]
y_img, x_img = np.mgrid[:h, :w]
xy_points = np.column_stack((x_img.flat, y_img.flat))
mask = points_in_poly(xy_points, xy_poly)
return mask.reshape((h, w))
def get_mask(self, shape, region):
"""
Parameters
----------
region : {'upper left', 'lower right'}
"""
if region == 'upper left':
theta = np.linspace(self.THETA_END, self.THETA_START - 2 * np.pi)
elif region == 'lower right':
theta = np.linspace(self.THETA_END, self.THETA_START)
else:
msg = "Expected 'upper left' or 'lower right'; got %s" % region
raise ValueError(msg)
xy_circle = self.circle.point_from_angle(theta).T
x, y = self.snake_curve()
xy_curve = np.array((x, y)).T
xy_poly = np.vstack((xy_curve, xy_circle))
h, w = shape[:2]
y_img, x_img = np.mgrid[:h, :w]
xy_points = np.column_stack((x_img.flat, y_img.flat))
mask = points_in_poly(xy_points, xy_poly)
return mask.reshape((h, w))
def select_center_highcontours(contours, xc, yc, radius=3):
"""
select all the high contours in contours that overlaps with the center region, which is defeined as a square region (xc +/- radius, yc +/- radius).
Find all high contours that enclose the centroid xc, yc. +/- radius
# if skmeasure.points_in_poly([[yc, xc]], contour):
"""
# setting
carea = np.pi * radius**2
ptc = np.array([xc, yc])
highcontours = select_highcontours(contours)
ccontours = []
for contour in highcontours:
if SignedPolygonArea(contour) >= carea:
if skmeasure.points_in_poly(np.array([ptc]), contour)[0]:
ccontours = ccontours+[contour]
else:
if contour_is_close_to_point(contour, ptc, distance=radius):
ccontours = ccontours+[contour]
return ccontours
def get_search_area(list_of_sequence_merged, tumors, area, coords_region):
list_above_two = [x for x in list_of_sequence_merged if len(x) >= 2]
list_of_ratio = []
for sublist in list_above_two:
res = np.sum(tumors[..., sublist], axis=2)
min_value = np.min(res)
max_value = np.max(res)
res = (((res - min_value) / (max_value - min_value)) * 255).astype(np.uint8)
thresh = threshold_otsu(res)
res_otsu = res > thresh
l, num = label(res_otsu, return_num=True)
coords = regionprops(l)[0].coords
good = np.sum(points_in_poly(coords, coords_region))
ratio = good / area
list_of_ratio.append((ratio, sublist[0], sublist[-1]))
max_value = max(list_of_ratio, key=lambda item:item[0])
return max_value[1], max_value[2]
def get_sub(lung, segmented_lung):
struct_closing = disk(20)
struct_opening = disk(3)
sub = lung.copy()
for i in range(lung.shape[2]):
if np.count_nonzero(lung[..., i]) == 0:
sub[..., i] = np.zeros(lung[..., i].shape)
continue
test = lung[..., i]
coords = []
for contour in find_contours(segmented_lung[..., i], 0):
coords.append(approximate_polygon(contour, tolerance=0))
sub[..., i] = test.astype(np.uint8) - segmented_lung[..., i].astype(np.uint8)
distance = ndi.distance_transform_edt(sub[..., i])
local_maxi = peak_local_max(distance, indices=False, labels=sub[..., i])
markers = ndi.label(local_maxi)[0]
labels = watershed(-distance, markers, mask=sub[..., i])
for region in regionprops(labels):
remove = True
for coord in coords:
if np.sum(points_in_poly(region.coords, coord)) > (region.area // 2):
remove = False
if remove:
centroid = tuple(int(x) for x in region.centroid)
labels = flood_fill(labels, centroid, 0)
labels[labels > 0] = 255
sub[..., i] = labels
return sub
def main2D_3D_2D_LR_MeshHair():
'''1. read obj and img'''
objPath = '../../github/vrn-07231340/obj/trump-12.obj'
objLines, vLines, fLines = readObj(objPath)
imgPath = '../../github/vrn-07231340/examples/scaled/trump-12.jpg'
img = cv2.imread(imgPath)
'''2. 2D face landmark'''
oriFaceLandmark2DList = getLandmark2D(img)
'''3. create source hair region mesh'''
gridSize = 15
rows, cols = img.shape[0], img.shape[1]
src_rows = np.linspace(0, rows, gridSize) # 10 rows
src_cols = np.linspace(0, cols, gridSize) # 20 columns
src_rows, src_cols = np.meshgrid(src_rows, src_cols)
src = np.dstack([src_cols.flat, src_rows.flat])[0]
'''3.1 create head region ellipse'''
'''!!!手动修改了椭圆中心点，因为川普本来就是侧脸!!!'''
ellipseParam = {
'ellipseCenterX': oriFaceLandmark2DList[ELLIPSE_CENTER][1],
'ellipseCenterY': oriFaceLandmark2DList[ELLIPSE_CENTER][0] - 10,
'ellipseSemiX': 70,
'ellipseSemiY': 90,
'orientation': np.pi * 1.5
}
rr, cc = ellipse_perimeter(ellipseParam['ellipseCenterY'],
ellipseParam['ellipseCenterX'],
ellipseParam['ellipseSemiY'],
ellipseParam['ellipseSemiX'],
orientation=ellipseParam['orientation'])
'''3.2 mesh points in ellipse'''
ellipseVerts = np.dstack([rr, cc])[0]
'''3.3 add outer ellipse edge points'''
edgePoints, outerEllipseVerts = addOuterEllipseEdgeLandmark(
ellipseParam, img)
# drawPointsOnImg(ellipseVerts, img, 'g', cover=True)
# drawPointsOnImg(edgePoints, img, 'r')
mask = points_in_poly(src, ellipseVerts)
pointsInEllipseList = []
indexInEllipseList = []
for i, (s, m) in enumerate(zip(src, mask)):
if m == True:
pointsInEllipseList.append(s)
indexInEllipseList.append(i)
assert len(pointsInEllipseList) == len(indexInEllipseList)
'''3.3 mesh points in face region'''
faceVerts = []
for FACE_CONTOUR_INDICE in FACE_CONTOUR_INDICES:
faceVerts.append([
oriFaceLandmark2DList[FACE_CONTOUR_INDICE][0],
oriFaceLandmark2DList[FACE_CONTOUR_INDICE][1]
])
mask = points_in_poly(src, faceVerts)
pointsInFaceList = []
indexInFaceList = []
for i, (s, m) in enumerate(zip(src, mask)):
if m == True:
pointsInFaceList.append(s)
indexInFaceList.append(i)
assert len(pointsInFaceList) == len(indexInFaceList)
'''3.4 mesh points between (face region) and (ellipse)'''
for i, ((pointInEllipseX, pointInEllipseY), indexInEllise) in enumerate(
zip(pointsInEllipseList, indexInEllipseList)):
for (pointInFaceX, pointInFaceY) in pointsInFaceList:
if pointInEllipseX == pointInFaceX and pointInEllipseY == pointInFaceY:
pointsInEllipseList[i] = np.array([-1, -1])
indexInEllipseList[i] = -1
pointsInHairList = []
for (pointInEllipseX, pointInEllipseY) in pointsInEllipseList:
if pointInEllipseX != -1 and pointInEllipseY != -1:
pointsInHairList.append([pointInEllipseX, pointInEllipseY])
indexInHairList = [x for x in indexInEllipseList if x != -1]
assert len(pointsInHairList) == len(indexInHairList)
'''3.5 mesh points above minY'''
minY = minYInLandmark(oriFaceLandmark2DList)
hairMeshPointsInEllipseList = []
hairMeshIndexInEllipseList = []
for (s, i) in zip(pointsInHairList, indexInHairList):
srcY = s[1]
srcX = s[0]
if srcY < minY and srcY >= 0:
hairMeshPointsInEllipseList.append((srcX, srcY))
hairMeshIndexInEllipseList.append(i)
assert len(hairMeshPointsInEllipseList) == len(hairMeshIndexInEllipseList)
# drawPointsOnImg(hairMeshPointsInEllipseList, img, 'r')
'''4. 2D hair mesh points --> 3D hair mesh points'''
'''4.1 3D hair landmark list: (x, y, z)'''
# maxminDict = maxminXYZ(objLines)
# minZ = float(maxminDict['maxZCoord'][2])
minZ = 60.0
hairLandmark3DList = []
for hairLandmark2D in hairMeshPointsInEllipseList:
hairLandmark3D = (float(hairLandmark2D[0]), float(hairLandmark2D[1]),
minZ)
hairLandmark3DList.append(hairLandmark3D)
'''4.2 hair landmark color list: (r, g, b)'''
colorList = []
for hairLandmark2D in hairMeshPointsInEllipseList:
r = img[int(hairLandmark2D[0]), int(hairLandmark2D[1]), 2] / 255.0
g = img[int(hairLandmark2D[0]), int(hairLandmark2D[1]), 1] / 255.0
b = img[int(hairLandmark2D[0]), int(hairLandmark2D[1]), 0] / 255.0
color = (r, g, b)
colorList.append(color)
'''4.3 3D vLines'''
hairVLines = []
for (x, y, z), (r, g, b) in zip(hairLandmark3DList, colorList):
hairVLine = 'v {} {} {} {} {} {}'.format(x, y, z, r, g, b)
hairVLines.append(hairVLine)
'''4.4 write vLines txt'''
hairVLinesTxtPath = './hairVLines.txt'
hairVLinesTxt = open(hairVLinesTxtPath, 'w')
for hairVLine in hairVLines:
hairVLinesTxt.write(hairVLine + '\n')
hairVLinesTxt.close()
'''5. nod hair'''
nodAngle = 15
nodCenterMode = 'maxY'
nodHairVLines = nodHair(objPath, nodAngle, nodCenterMode, hairVLines,
hairVLinesTxtPath)
'''6. 2D nod hair landmark'''
nodHairLandmark2DList = []
for nodHairVLine in nodHairVLines:
_, x, y, _, _, _, _ = nodHairVLine.split()
nodHairLandmark2DList.append((float(x), float(y)))
assert len(hairMeshPointsInEllipseList) == len(nodHairLandmark2DList)
# print hairMeshPointsInEllipseList
# print nodHairLandmark2DList
return hairMeshPointsInEllipseList, nodHairLandmark2DList, edgePoints, ellipseVerts, outerEllipseVerts
def isinside_polygon(poly1, poly2):
""" tell if poly1 is enclosed by poly2, i.e. all the points are inside.
Identical polys are not inside each other """
return np.all(skmeasure.points_in_poly(poly1, poly2))
def test_type(self):
assert(points_in_poly([[0, 0]], [[0, 0]]).dtype == np.bool)
def checkContour(xRoi, yRoi):
# check = False
for contour in contours:
if measure.points_in_poly([[xRoi, yRoi]], contour):
return contour
Im.saveImageRegions()
def points_in_poly(points, verts):
'''see skimage.measure.points_in_poly'''
return measure.points_in_poly(points, verts)