def draw_ring(centre, r1, r2, contrast, N): #r1>r2, r_coord: (x,y)
ring=np.zeros((N,N), dtype=np.int8)
x1,y1 = draw.disk(centre,r1,shape=ring.shape)
x2,y2 = draw.disk(centre,r2,shape=ring.shape)
ring[x1,y1]=contrast
ring[x2,y2]=0
return ring
def test_blob_doh(dtype, threshold_type):
img = np.ones((512, 512), dtype=dtype)
xs, ys = disk((400, 130), 20)
img[xs, ys] = 255
xs, ys = disk((460, 50), 30)
img[xs, ys] = 255
xs, ys = disk((100, 300), 40)
img[xs, ys] = 255
xs, ys = disk((200, 350), 50)
img[xs, ys] = 255
if threshold_type == 'absolute':
# Note: have to either scale up threshold or rescale the image to the
# range [0, 1] internally.
threshold = 0.05
if img.dtype.kind == 'f':
# account for lack of internal scaling to [0, 1] by img_as_float
ptp = img.ptp()
threshold *= ptp**2
threshold_rel = None
elif threshold_type == 'relative':
threshold = None
threshold_rel = 0.5
blobs = blob_doh(img,
min_sigma=1,
max_sigma=60,
num_sigma=10,
threshold=threshold,
threshold_rel=threshold_rel)
radius = lambda x: x[2]
s = sorted(blobs, key=radius)
thresh = 4
b = s[0]
assert abs(b[0] - 400) <= thresh
assert abs(b[1] - 130) <= thresh
assert abs(radius(b) - 20) <= thresh
b = s[1]
assert abs(b[0] - 460) <= thresh
assert abs(b[1] - 50) <= thresh
assert abs(radius(b) - 30) <= thresh
b = s[2]
assert abs(b[0] - 100) <= thresh
assert abs(b[1] - 300) <= thresh
assert abs(radius(b) - 40) <= thresh
b = s[3]
assert abs(b[0] - 200) <= thresh
assert abs(b[1] - 350) <= thresh
assert abs(radius(b) - 50) <= thresh
def create_data(deformation=False):
img = np.zeros((100, 100))
coords = draw.ellipse(50, 50, 35, 13)
set_ellipse = set((tuple(i) for i in np.array(coords).T))
img[coords] = 120
coords2 = draw.disk((50, 63), 5)
set_disk = set((tuple(i) for i in np.array(coords2).T))
set_intersection = set_disk.intersection(set_ellipse)
inters_xy = tuple(np.array(list(set_intersection)).T)
img[inters_xy] = 200
coords_disktop = draw.disk((30, 55), 7)
set_disk = set((tuple(i) for i in np.array(coords_disktop).T))
set_intersection = set_disk.intersection(set_ellipse)
inters_xy = tuple(np.array(list(set_intersection)).T)
img[inters_xy] = 200
coords_line = draw.line(82, 46, 60, 40)
img[coords_line] = 200
coords_line = draw.line(82, 47, 60, 41)
img[coords_line] = 200
if deformation:
coords = draw.ellipse(50, 37, 7, 3)
img[coords] = 0
coords2 = draw.ellipse(50, 63, 7, 3)
set_coords2 = set((tuple(i) for i in np.array(coords2).T))
set_intersection2 = set_coords2.difference(set_ellipse)
inters2_xy = tuple(np.array(list(set_intersection2)).T)
img[inters2_xy] = 200
coords3 = draw.ellipse(76, 61, 7, 6)
img[coords3] = 0
coords_line = draw.line(82, 48, 60, 42)
img[coords_line] = 200
coords_line = draw.line(82, 49, 60, 43)
img[coords_line] = 200
set_intersection = set_disk.intersection(set_ellipse)
inters_xy = tuple(np.array(list(set_intersection)).T)
img[inters_xy] = 20
N = 100
x = np.linspace(-np.pi,np.pi, N)
sine1D = 20.0 + (20 * np.sin(x * 5.0))
sine1D = np.uint8(sine1D)
sine2D = np.tile(sine1D, (N,1))
sine2D = sine2D.T
sine2D = np.where(img == 0, 0, sine2D)
img += sine2D
return img
def test_blob_log_no_warnings():
img = np.ones((11, 11))
xs, ys = disk((5, 5), 2)
img[xs, ys] = 255
xs, ys = disk((7, 6), 2)
img[xs, ys] = 255
blob_log(img, max_sigma=20, num_sigma=10, threshold=.1)
def _get_cost_arrays_for_each_route(heatmap,
landmarks,
raise_to_power=4,
block_cost=10):
heatmap_epi, heatmap_end = heatmap
lv_x, lv_y = landmarks[2]
(rv_ant_x, rv_ant_y), (rv_inf_x, rv_inf_y) = landmarks[:2]
cost_epi = (1 - heatmap_epi)**raise_to_power
cost_end = (1 - heatmap_end)**raise_to_power
# outer paths (inner blocked)
rv_mid_x, rv_mid_y = int(rv_ant_x + rv_inf_x) // 2, int(rv_ant_y +
rv_inf_y) // 2
double_rv_mid_x, double_rv_mid_y = lv_x + (rv_mid_x - lv_x) * 2, lv_y + (
rv_mid_y - lv_y) * 3
# print("inner")
_, (inner_circle_y, inner_circle_x) = _get_max_of_image_between_two_points(
heatmap_epi, double_rv_mid_x, double_rv_mid_y, lv_x, lv_y)
inner_circle_radius = math.sqrt((rv_ant_x - rv_inf_x)**2 +
(rv_ant_y - rv_inf_y)**2) * 0.3
rr, cc = disk(inner_circle_y,
inner_circle_x,
inner_circle_radius,
shape=cost_epi.shape)
cost_outer_epi = cost_epi.copy()
cost_outer_epi[rr, cc] = block_cost
cost_outer_end = cost_end.copy()
cost_outer_end[rr, cc] = block_cost
# inner paths (outer blocked)
double_opposite_x, double_opposite_y = lv_x - (
rv_mid_x - lv_x) * 2, lv_y - (rv_mid_y - lv_y) * 3
# print("outer")
_, (outer_circle_y, outer_circle_x) = _get_max_of_image_between_two_points(
heatmap_epi, double_opposite_x, double_opposite_y, lv_x, lv_y)
outer_circle_radius = math.sqrt((outer_circle_x - lv_x)**2 +
(outer_circle_y - lv_y)**2)
rr, cc = disk(outer_circle_y,
outer_circle_x,
outer_circle_radius,
shape=cost_epi.shape)
cost_inner_epi = cost_epi.copy()
cost_inner_epi[rr, cc] = block_cost
cost_inner_end = cost_end.copy()
cost_inner_end[rr, cc] = block_cost
# import matplotlib.pyplot as plt
# plt.imshow(cost_outer_epi)
# plt.show()
# plt.imshow(cost_inner_epi)
# plt.show()
return cost_outer_epi, cost_inner_epi, cost_outer_end, cost_inner_end
def test_blob_dog(dtype, threshold_type):
r2 = math.sqrt(2)
img = np.ones((512, 512), dtype=dtype)
xs, ys = disk((400, 130), 5)
img[xs, ys] = 255
xs, ys = disk((100, 300), 25)
img[xs, ys] = 255
xs, ys = disk((200, 350), 45)
img[xs, ys] = 255
if threshold_type == 'absolute':
threshold = 2.0
if img.dtype.kind != 'f':
# account for internal scaling to [0, 1] by img_as_float
threshold /= img.ptp()
threshold_rel = None
elif threshold_type == 'relative':
threshold = None
threshold_rel = 0.5
blobs = blob_dog(
img,
min_sigma=4,
max_sigma=50,
threshold=threshold,
threshold_rel=threshold_rel,
)
radius = lambda x: r2 * x[2]
s = sorted(blobs, key=radius)
thresh = 5
ratio_thresh = 0.25
b = s[0]
assert abs(b[0] - 400) <= thresh
assert abs(b[1] - 130) <= thresh
assert abs(radius(b) - 5) <= ratio_thresh * 5
b = s[1]
assert abs(b[0] - 100) <= thresh
assert abs(b[1] - 300) <= thresh
assert abs(radius(b) - 25) <= ratio_thresh * 25
b = s[2]
assert abs(b[0] - 200) <= thresh
assert abs(b[1] - 350) <= thresh
assert abs(radius(b) - 45) <= ratio_thresh * 45
# Testing no peaks
img_empty = np.zeros((100, 100), dtype=dtype)
assert blob_dog(img_empty).size == 0
def test_blob_log_no_warnings():
img = np.ones((11, 11))
xs, ys = disk((5, 5), 2)
img[xs, ys] = 255
xs, ys = disk((7, 6), 2)
img[xs, ys] = 255
with pytest.warns(None) as records:
blob_log(img, max_sigma=20, num_sigma=10, threshold=.1)
assert len(records) == 0
def draw_nodes(img, nodes, r=2, labels=None):
img_copy = np.copy(img)
# source node
if labels == None:
for i, (x, y) in enumerate(nodes):
rr, cc = draw.disk((x, y), r)
img_copy[rr % img.shape[0], cc % img.shape[1]] = int(i + 1)
else:
for i, (x, y) in enumerate(nodes):
rr, cc = draw.disk((x, y), r)
img_copy[rr % img.shape[0], cc % img.shape[1]] = int(labels[i])
return img_copy
def create_test_image(image_size=256,
spot_count=30,
spot_radius=5,
cloud_noise_size=4):
"""
Generate a test image with random noise, uneven illumination and spots.
"""
state = np.random.get_state()
np.random.seed(314159265) # some digits of pi
image = np.random.normal(loc=0.25,
scale=0.25,
size=(image_size, image_size))
for _ in range(spot_count):
rr, cc = disk((np.random.randint(
image.shape[0]), np.random.randint(image.shape[1])),
spot_radius,
shape=image.shape)
image[rr, cc] = 1
image *= np.random.normal(loc=1.0, scale=0.1, size=image.shape)
image *= ndi.zoom(
np.random.normal(loc=1.0,
scale=0.5,
size=(cloud_noise_size, cloud_noise_size)),
image_size / cloud_noise_size)
np.random.set_state(state)
return ndi.gaussian_filter(image, sigma=2.0)
def createScenarioThree(self, vertiports, radius):
'''
Map of Scenario Three:
- Use a image to create a nrow x ncol matrix with values of populational density of Belo Horizonte.
- Create points for safe landing and determine a radius from those points where the aircraft could operate.
'''
from skimage import io
from skimage.util import invert
from skimage.transform import rotate, resize
from skimage.draw import disk
from skimage.draw import circle_perimeter
nrows = self.nrows
ncols = self.ncols
delta_d = 1 / nrows
x = np.arange(ncols + 1) * delta_d
y = np.arange(nrows + 1) * delta_d
original = io.imread(
'/home/josuehfa/System/CoreSystem/ImageLib/popCalculated.png')
image_resized = resize(original, (nrows + 1, ncols + 1),
anti_aliasing=True)
image_rotate = rotate(image_resized, 180)
final_image = image_rotate[:, ::-1]
final_image = np.multiply(final_image,
np.where(final_image >= 0.1, 110, 1))
self.vertiports = vertiports
vertiports_map = np.zeros((nrows + 1, ncols + 1), dtype=np.uint8)
for vertiport in vertiports:
#Obtem os dados de perimetros para cada vertice
xp, yp = circle_perimeter(int(vertiport[1] * nrows),
int(vertiport[0] * nrows),
int(radius * nrows))
x_del = np.argwhere((xp <= 0) | (xp >= nrows))
y_del = np.argwhere((yp <= 0) | (yp >= ncols))
xp = np.delete(xp, np.concatenate((x_del, y_del), axis=0)) / nrows
yp = np.delete(yp, np.concatenate((x_del, y_del), axis=0)) / nrows
self.verti_perimeters.append([xp, yp])
#Obtem a região dentro do circulo de perimetro
xx, yy = disk((vertiport[1] * nrows, vertiport[0] * nrows),
radius * nrows)
x_del = np.argwhere((xx <= 0) | (xx >= nrows))
y_del = np.argwhere((yy <= 0) | (yy >= ncols))
xx = np.delete(xx, np.concatenate((x_del, y_del), axis=0))
yy = np.delete(yy, np.concatenate((x_del, y_del), axis=0))
vertiports_map[xx, yy] = 1
mask = vertiports_map < 1
mapimage = final_image * vertiports_map + mask * 100
mapimage = mapimage + 0.1
for t in range(self.time):
self.z_time.append(mapimage)
self.obs_time = []
self.z = self.z_time[0]
self.y = y
self.x = x
def get_circle_colour(self, cr, cc, r):
rows, cols = draw.disk((cr, cc), r)
# colour = np.mean(self.data[rows, cols], axis=(0, 1))
colour = np.mean(self.data[rows, cols], axis=0)
return colour
def draw_joint(colors, pose_joints, joint_line_list, radius=2):
im_size = (colors.shape[0], colors.shape[1])
for f, t in joint_line_list:
from_missing = pose_joints[0, f] == MISSING_VALUE or pose_joints[
1, f] == MISSING_VALUE
to_missing = pose_joints[0, t] == MISSING_VALUE or pose_joints[
1, t] == MISSING_VALUE
if from_missing or to_missing:
continue
yy, xx, val = line_aa(pose_joints[0, f], pose_joints[1, f],
pose_joints[0, t], pose_joints[1, t])
yy, xx = np.clip(yy, 0, im_size[0] - 1), np.clip(xx, 0, im_size[1] - 1)
colors[yy, xx] = np.expand_dims(val, 1) * 255
# mask[yy, xx] = True
colormap = labelcolormap(pose_joints.shape[1])
for i in range(pose_joints.shape[1]):
if pose_joints[0,
i] == MISSING_VALUE or pose_joints[1,
i] == MISSING_VALUE:
continue
yy, xx = disk((pose_joints[0, i], pose_joints[1, i]),
radius=radius,
shape=im_size)
colors[yy, xx] = colormap[i]
return colors
def get_circle_stats(self, cr, cc, r) -> PickStats:
# import pdb; pdb.set_trace()
rows, cols = draw.disk((cr, cc), r)
mu = np.mean(self.fullData[rows, cols], axis=0)
sigma = np.std(self.fullData[rows, cols], axis=0)
ps = PickStats()
ps.mu_r = mu[0]
ps.mu_g = mu[1]
ps.mu_b = mu[2]
ps.sigma_r = sigma[0]
ps.sigma_g = sigma[1]
ps.sigma_b = sigma[2]
totSum = np.sum(self.fullData[rows, cols])
ps.perc_r = np.sum(self.fullData[rows, cols][:, 0]) / totSum
ps.perc_g = np.sum(self.fullData[rows, cols][:, 1]) / totSum
ps.perc_b = np.sum(self.fullData[rows, cols][:, 2]) / totSum
ps.num_pixels = len(rows)
return ps
def test_blob_doh_overlap():
img = np.ones((256, 256), dtype=np.uint8)
xs, ys = disk((100, 100), 20)
img[xs, ys] = 255
xs, ys = disk((120, 100), 30)
img[xs, ys] = 255
blobs = blob_doh(img,
min_sigma=1,
max_sigma=60,
num_sigma=10,
threshold=.05)
assert len(blobs) == 1
def test_disk():
img = np.zeros((15, 15), 'uint8')
rr, cc = disk((7, 7), 6)
img[rr, cc] = 1
img_ = np.array(
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0],
[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
)
assert_array_equal(img, img_)
def test_blob_dog_excl_border():
# Testing exclude border
# image where blob is 5 px from borders, radius 5
img = np.ones((512, 512))
xs, ys = disk((5, 5), 5)
img[xs, ys] = 255
blobs = blob_dog(
img,
min_sigma=1.5,
max_sigma=5,
sigma_ratio=1.2,
)
assert blobs.shape[0] == 1
b = blobs[0]
assert b[0] == b[1] == 5, "blob should be 5 px from x and y borders"
blobs = blob_dog(
img,
min_sigma=1.5,
max_sigma=5,
sigma_ratio=1.2,
exclude_border=6,
)
msg = "zero blobs should be detected, as only blob is 5 px from border"
assert blobs.shape[0] == 0, msg
def create_test_image(image_size=256,
spot_count=30,
spot_radius=5,
cloud_noise_size=4):
"""
Generate a test image with random noise, uneven illumination and spots.
"""
rng = np.random.default_rng()
image = rng.normal(loc=0.25, scale=0.25, size=(image_size, image_size))
for _ in range(spot_count):
rr, cc = disk(
(rng.integers(image.shape[0]), rng.integers(image.shape[1])),
spot_radius,
shape=image.shape)
image[rr, cc] = 1
image *= rng.normal(loc=1.0, scale=0.1, size=image.shape)
image *= ndi.zoom(
rng.normal(loc=1.0,
scale=0.5,
size=(cloud_noise_size, cloud_noise_size)),
image_size / cloud_noise_size)
return ndi.gaussian_filter(image, sigma=2.0)
def get_simulated_disc(square_size, disc_radius):
"""Create a uniform disc for correlating with the experimental square.
Parameters
----------
square size : int
(even) - size of the bounding box
disc_radius : int
radius of the disc
Returns
-------
arr: np.array()
Upsampled copy of the simulated disc as a numpy array
"""
if square_size % 2 != 0:
raise ValueError("'square_size' must be an even number")
ss = int(square_size)
arr = np.zeros((ss, ss))
rr, cc = draw.disk((int(ss / 2), int(ss / 2)),
radius=disc_radius,
shape=arr.shape) # is the thin disc a good idea
arr[rr, cc] = 1
return arr
def _draw_passengers(self, location, color):
passenger_radius = Passenger_SIZE * self.grid_size
pos_x, pos_y = self._get_screen_pos(location[0], location[1])
pos_x += int(self.grid_size / 2)
pos_y += int(self.grid_size / 2)
rr, cc = disk((pos_x, pos_y), passenger_radius)
self.rgb_observation[rr, cc, :] = list(color)
def _cost_annular_disk(params):
x0, y0, r, inr = params
coords = draw.disk((x0, y0), r, shape=img.shape)
template = np.zeros_like(img)
template[coords] = 1
coords2 = draw.disk((x0, y0), inr, shape=img.shape)
template2 = np.zeros_like(img)
template2[coords2] = 1
template -= template2
if display:
self._dispnobl(template + img, fign)
merit_fcn = np.sum((template - img)**2)
return np.sqrt(merit_fcn)
def _cost_disk(params):
x0, y0, r = params
coords = draw.disk((x0, y0), r, shape=img.shape)
template = np.zeros_like(img)
template[coords] = 1
if display:
self._dispnobl(template + img, fign)
return -np.sum((template > 0) & (img > 0))
def get_colour_display(self, cr, cc, r):
# colour = self.get_circle_colour(cr, cc, r)
ps = self.get_circle_stats(cr, cc, r)
colour = np.array([ps.mu_r, ps.mu_g, ps.mu_b])
ImgLogger.log("Got mean colour for display: ", colour)
rows, cols = draw.disk((cr, cc), r)
im = np.full((2 * r, 2 * r, 3), 255, dtype=self.fullData.dtype)
irows, icols = draw.disk((r, r), r)
im[irows, icols] = self.fullData[rows, cols]
im[:, :r] = colour
return DataImage(im)
def test_blob_doh_log_scale():
img = np.ones((512, 512), dtype=np.uint8)
xs, ys = disk((400, 130), 20)
img[xs, ys] = 255
xs, ys = disk((460, 50), 30)
img[xs, ys] = 255
xs, ys = disk((100, 300), 40)
img[xs, ys] = 255
xs, ys = disk((200, 350), 50)
img[xs, ys] = 255
blobs = blob_doh(
img,
min_sigma=1,
max_sigma=60,
num_sigma=10,
log_scale=True,
threshold=.05)
radius = lambda x: x[2]
s = sorted(blobs, key=radius)
thresh = 10
b = s[0]
assert abs(b[0] - 400) <= thresh
assert abs(b[1] - 130) <= thresh
assert abs(radius(b) - 20) <= thresh
b = s[2]
assert abs(b[0] - 460) <= thresh
assert abs(b[1] - 50) <= thresh
assert abs(radius(b) - 30) <= thresh
b = s[1]
assert abs(b[0] - 100) <= thresh
assert abs(b[1] - 300) <= thresh
assert abs(radius(b) - 40) <= thresh
b = s[3]
assert abs(b[0] - 200) <= thresh
assert abs(b[1] - 350) <= thresh
assert abs(radius(b) - 50) <= thresh
def get_snr(frame, y, x, fwhm, fmerit):
"""
"""
if fmerit == 'max':
yy, xx = disk((y, x), fwhm / 2.)
res = [
snr(frame, (x_, y_),
fwhm,
plot=False,
verbose=False,
exclude_negative_lobes=exclude_negative_lobes,
full_output=True) for y_, x_ in zip(yy, xx)
]
snr_pixels = np.array(res, dtype=object)[:, -1]
fluxes = np.array(res, dtype=object)[:, 2]
argm = np.argmax(snr_pixels)
# integrated fluxes for the max snr
return np.max(snr_pixels), fluxes[argm]
elif fmerit == 'px':
res = snr(frame, (x, y),
fwhm,
plot=False,
verbose=False,
exclude_negative_lobes=exclude_negative_lobes,
full_output=True)
snrpx = res[-1]
fluxpx = np.array(res, dtype=object)[2]
# integrated fluxes for the given px
return snrpx, fluxpx
elif fmerit == 'mean':
yy, xx = disk((y, x), fwhm / 2.)
res = [
snr(frame, (x_, y_),
fwhm,
plot=False,
verbose=False,
exclude_negative_lobes=exclude_negative_lobes,
full_output=True) for y_, x_ in zip(yy, xx)
]
snr_pixels = np.array(res, dtype=object)[:, -1]
fluxes = np.array(res, dtype=object)[:, 2]
# mean of the integrated fluxes (shifting the aperture)
return np.mean(snr_pixels), np.mean(fluxes)
def move(self, img, x, y):
"""Moving brush through canvas"""
old_x, old_y = self.press_pos
for c_x, c_y in zip(*disk((old_x, old_y), self.size, shape=img.shape)):
end_x = min(x + (c_x - old_x), img.shape[0] - 1)
end_y = min(y + (c_y - old_y), img.shape[1] - 1)
row_map, column_map = line(c_x, c_y, end_x, end_y)
img[row_map, column_map] = self.color
self.press_pos = (x, y)
def _draw_agent(self, location, color):
agent_radius = AGENT_SIZE * self.grid_size
pos_x, pos_y = self._get_screen_pos(location[0], location[1])
# move to grid center
pos_x += int(self.grid_size / 2)
pos_y += int(self.grid_size / 2)
rr, cc = disk((pos_x, pos_y), agent_radius)
self.rgb_observation[rr, cc, :] = list(color)
def get_circles(img, diameter, thresh): selem = np.ones((diameter+1, diameter+1), dtype=np.uint8) rr, cc = disk((diameter//2, diameter//2), diameter//2) selem[rr,cc] = 1 img_cpy = img.copy() selem = np.array([ [1,1,1], [1,1,1], [1,1,1] ]) img_cpy = binary_erosion(img_cpy, selem=selem) img_cpy = binary_erosion(img_cpy, selem=selem) img_cpy = binary_erosion(img_cpy, selem=selem) img_cpy = binary_erosion(img_cpy, selem=selem) result = convolve2d(np.uint8(img_cpy), selem, mode='same') + convolve2d(np.uint8(1-img_cpy), 1-selem, mode='same') # print(np.max(result), (selem.shape[0] * selem.shape[1]), diameter) # result = result / (selem.shape[0] * selem.shape[1]) if(np.max(result) > 0): result = result / np.max(result) ij = np.where(result >= thresh) x, y = ij[::-1] # circlesArrX = x # circlesArrY = y # Combine very close circles to one circle circlesArrX = [] circlesArrY = [] used = np.zeros(len(x), dtype=np.uint8) for i in range(len(x)): if(used[i] == 1): continue used[i] = 1 accumulator = [] accumulator.append(i) for j in range(len(x)): if(used[j] == 1): continue if abs(x[i] - x[j]) <= diameter and abs(y[i] - y[j]) <= diameter: used[j] = 1 accumulator.append(j) centerX = 0 centerY = 0 for k in accumulator: centerX += x[k] centerY += y[k] centerX /= len(accumulator) centerY /= len(accumulator) circlesArrX.append(centerX) circlesArrY.append(centerY) return np.array(circlesArrX), np.array(circlesArrY)
def test_multiotsu_output():
image = np.zeros((100, 100), dtype='int')
coords = [(25, 25), (50, 50), (75, 75)]
values = [64, 128, 192]
for coor, val in zip(coords, values):
rr, cc = disk(coor, 20)
image[rr, cc] = val
thresholds = [0, 64, 128]
assert np.array_equal(thresholds, threshold_multiotsu(image, classes=4))
def binary_draw(self, grid):
# print(self.x, self.y, self.radius, grid.shape)
# rr, cc = draw.circle(self.x, self.y, radius=self.radius, shape=grid.shape)
# x and y are reversed as numpy array first index correspond to y
rr, cc = draw.disk((self.y, self.x),
radius=self.radius,
shape=grid.shape)
grid[rr, cc] = 1
return grid
def exp_disc():
ss, disc_radius, upsample_factor = int(60), 6, 10
arr = np.zeros((ss, ss))
rr, cc = draw.disk((int(ss / 2) + 20, int(ss / 2) - 10),
radius=disc_radius,
shape=arr.shape)
arr[rr, cc] = 1
return arr
