def get_graphs(img, gt, sigma, edge_offsets):
overseg_factor = 1.7
sep_chnl = 2
affinities = get_naive_affinities(gaussian(img, sigma=sigma), edge_offsets)
affinities[:sep_chnl] *= -1
affinities[:sep_chnl] += +1
# scale affinities in order to get an oversegmentation
affinities[:sep_chnl] /= overseg_factor
affinities[sep_chnl:] *= overseg_factor
affinities = np.clip(affinities, 0, 1)
node_labeling = compute_mws_segmentation(affinities, edge_offsets,
sep_chnl)
node_labeling = node_labeling - 1
nodes = np.unique(node_labeling)
try:
assert all(nodes == np.array(range(len(nodes)), dtype=np.float))
except:
Warning("node ids are off")
# get edges from node labeling and edge features from affinity stats
edge_feat, neighbors = get_edge_features_1d(node_labeling, edge_offsets,
affinities)
# get gt edge weights based on edges and gt image
gt_edge_weights = calculate_gt_edge_costs(neighbors,
node_labeling.squeeze(),
gt.squeeze(), 0.5)
edges = neighbors.astype(np.long)
# calc multicut from gt
gt_seg = get_current_soln(gt_edge_weights, node_labeling, edges)
fig, (ax1, ax2, ax3, ax4) = plt.subplots(1, 4)
ax1.imshow(cm.prism(gt / gt.max()))
ax1.set_title('gt')
ax2.imshow(cm.prism(node_labeling / node_labeling.max()))
ax2.set_title('sp')
ax3.imshow(cm.prism(gt_seg / gt_seg.max()))
ax3.set_title('mc')
ax4.imshow(img)
ax4.set_title('raw')
plt.show()
affinities = affinities.astype(np.float32)
edge_feat = edge_feat.astype(np.float32)
nodes = nodes.astype(np.float32)
node_labeling = node_labeling.astype(np.float32)
gt_edge_weights = gt_edge_weights.astype(np.float32)
diff_to_gt = np.abs((edge_feat[:, 0] - gt_edge_weights)).sum()
edges = np.sort(edges, axis=-1)
edges = edges.T
return img, gt, edges, edge_feat, diff_to_gt, gt_edge_weights, node_labeling, nodes, affinities
def get_sp_graph(data, gt, scal=1.01):
offsets = [[0, -1], [-1, 0], [-3, 0], [0, -3]]
sep_chnl = 2
shape = (128, 128)
affinities = affutils.get_naive_affinities(data, offsets)
gt_affinities, _ = compute_affinities(gt == 1, offsets)
gt_affinities[sep_chnl:] *= -1
gt_affinities[sep_chnl:] += +1
affinities[sep_chnl:] *= -1
affinities[sep_chnl:] += +1
affinities[sep_chnl:] *= scal
affinities = (affinities - (affinities * gt_affinities)) + gt_affinities
affinities = affinities.clip(0, 1)
valid_edges = get_valid_edges((len(offsets), ) + shape, offsets, sep_chnl,
None, False)
node_labeling, neighbors, cutting_edges, mutexes = compute_mws_segmentation_cstm(
affinities.ravel(), valid_edges.ravel(), offsets, sep_chnl, shape)
node_labeling = node_labeling - 1
nodes = np.unique(node_labeling)
try:
assert all(nodes == np.array(range(len(nodes)), dtype=np.float))
except:
Warning("node ids are off")
noisy_affinities = np.random.rand(*affinities.shape)
noisy_affinities = noisy_affinities.clip(0, 1)
noisy_affinities = affinities
edge_feat, neighbors = get_edge_features_1d(node_labeling, offsets,
noisy_affinities)
gt_edge_weights = calculate_gt_edge_costs(neighbors,
node_labeling.squeeze(),
gt.squeeze())
edges = neighbors.astype(np.long)
noisy_affinities = noisy_affinities.astype(np.float32)
edge_feat = edge_feat.astype(np.float32)
nodes = nodes.astype(np.float32)
node_labeling = node_labeling.astype(np.float32)
gt_edge_weights = gt_edge_weights.astype(np.float32)
diff_to_gt = np.abs((edge_feat[:, 0] - gt_edge_weights)).sum()
edges = np.sort(edges, axis=-1)
edges = edges.T
# edges = np.concatenate((edges, np.stack((edges[1], edges[0]))), axis=1)
# return node_labeling
# print('imbalance: ', abs(gt_edge_weights.sum() - (len(gt_edge_weights) / 2)))
return edges, edge_feat, diff_to_gt, gt_edge_weights, node_labeling, nodes, noisy_affinities
def get(self, idx):
n_disc = np.random.randint(8, 10)
rads = []
mps = []
for disc in range(n_disc):
radius = np.random.randint(
max(self.shape) // 18,
max(self.shape) // 15)
touching = True
while touching:
mp = np.array([
np.random.randint(0 + radius, self.shape[0] - radius),
np.random.randint(0 + radius, self.shape[1] - radius)
])
touching = False
for other_rad, other_mp in zip(rads, mps):
diff = mp - other_mp
if (diff**2).sum()**.5 <= radius + other_rad + 2:
touching = True
rads.append(radius)
mps.append(mp)
# take static image
# rads = self.rads
# mps = self.mps
data = np.zeros(shape=self.shape, dtype=np.float)
gt = np.zeros(shape=self.shape, dtype=np.float)
for y in range(self.shape[0]):
for x in range(self.shape[1]):
bg = True
for radius, mp in zip(rads, mps):
ly, lx = y - mp[0], x - mp[1]
if (ly**2 + lx**2)**.5 <= radius:
data[y, x] += np.cos(
np.sqrt((x - self.shape[1])**2 + y**2) * 50 *
np.pi / self.shape[1])
data[y, x] += np.cos(
np.sqrt(x**2 + y**2) * 50 * np.pi / self.shape[1])
# data[y, x] += 6
gt[y, x] = 1
bg = False
if bg:
data[y, x] += np.cos(y * 40 * np.pi / self.shape[0])
data[y, x] += np.cos(
np.sqrt(x**2 + (self.shape[0] - y)**2) * 30 * np.pi /
self.shape[1])
data += 1
# plt.imshow(data);plt.show()
# if self.no_suppix:
# raw = torch.from_numpy(data).float()
# return raw.unsqueeze(0), torch.from_numpy(gt.astype(np.long))
# return torch.stack((torch.rand_like(raw), raw, torch.rand_like(raw))), torch.from_numpy(gt.astype(np.long))
affinities = affutils.get_naive_affinities(data, self.offsets)
gt_affinities, _ = compute_affinities(gt == 1, self.offsets)
gt_affinities[self.sep_chnl:] *= -1
gt_affinities[self.sep_chnl:] += +1
affinities[self.sep_chnl:] *= -1
affinities[self.sep_chnl:] += +1
# affinities[:self.sep_chnl] /= 1.1
affinities[self.sep_chnl:] *= 1.01
affinities = (affinities -
(affinities * gt_affinities)) + gt_affinities
# affinities[self.sep_chnl:] *= -1
# affinities[self.sep_chnl:] += +1
# affinities[self.sep_chnl:] *= 4
affinities = affinities.clip(0, 1)
valid_edges = get_valid_edges((len(self.offsets), ) + self.shape,
self.offsets, self.sep_chnl, None, False)
node_labeling, neighbors, cutting_edges, mutexes = compute_mws_segmentation_cstm(
affinities.ravel(), valid_edges.ravel(), self.offsets,
self.sep_chnl, self.shape)
node_labeling = node_labeling - 1
# rag = elf.segmentation.features.compute_rag(np.expand_dims(node_labeling, axis=0))
# neighbors = rag.uvIds()
i = 0
# node_labeling = gt * 5000 + node_labeling
# segs = np.unique(node_labeling)
#
# new_labeling = np.zeros_like(node_labeling)
# for seg in segs:
# i += 1
# new_labeling += (node_labeling == seg) * i
#
# node_labeling = new_labeling - 1
# gt_labeling, _, _, _ = compute_mws_segmentation_cstm(gt_affinities.ravel(),
# valid_edges.ravel(),
# offsets,
# self.shape)
# self.sep_chnl,
nodes = np.unique(node_labeling)
try:
assert all(nodes == np.array(range(len(nodes)), dtype=np.float))
except:
Warning("node ids are off")
noisy_affinities = np.random.rand(*affinities.shape)
noisy_affinities = noisy_affinities.clip(0, 1)
noisy_affinities = affinities
edge_feat, neighbors = get_edge_features_1d(node_labeling,
self.offsets,
noisy_affinities)
gt_edge_weights = calculate_gt_edge_costs(neighbors,
node_labeling.squeeze(),
gt.squeeze())
if self.less:
raw = torch.from_numpy(data).float()
node_labeling = torch.from_numpy(node_labeling.astype(np.float32))
gt_edge_weights = torch.from_numpy(gt_edge_weights.astype(np.long))
edges = torch.from_numpy(neighbors.astype(np.long))
edges = edges.t().contiguous()
edges = torch.cat((edges, torch.stack((edges[1], edges[0]))),
dim=1)
return raw.unsqueeze(0), node_labeling, torch.from_numpy(
gt.astype(np.long)), gt_edge_weights, edges
# affs = np.expand_dims(affinities, axis=1)
# boundary_input = np.mean(affs, axis=0)
# gt1 = gutils.multicut_from_probas(node_labeling.astype(np.float32), neighbors.astype(np.float32),
# gt_edge_weights.astype(np.float32), boundary_input.astype(np.float32))
# plt.imshow(node_labeling)
# plt.show()
# plt.imshow(gt1)
# plt.show()
gt = torch.from_numpy(gt.astype(np.float32)).squeeze().float()
edges = torch.from_numpy(neighbors.astype(np.long))
raw = torch.tensor(data).squeeze().float()
noisy_affinities = torch.tensor(noisy_affinities).squeeze().float()
edge_feat = torch.from_numpy(edge_feat.astype(np.float32))
nodes = torch.from_numpy(nodes.astype(np.float32))
node_labeling = torch.from_numpy(node_labeling.astype(np.float32))
gt_edge_weights = torch.from_numpy(gt_edge_weights.astype(np.float32))
diff_to_gt = (edge_feat[:, 0] - gt_edge_weights).abs().sum().item()
# node_features, angles = get_stacked_node_data(nodes, edges, node_labeling, raw, size=[32, 32])
# file = h5py.File("/g/kreshuk/hilt/projects/rags/" + "rag_" + str(self.fidx) + ".h5", "w")
# file.create_dataset("edges", data=edges.numpy())
# self.fidx += 1
if self.no_suppix:
raw = torch.from_numpy(data).float()
return raw.unsqueeze(0), torch.from_numpy(gt.numpy().astype(
np.long))
edges = edges.t().contiguous()
edges = torch.cat((edges, torch.stack((edges[1], edges[0]))), dim=1)
# print('imbalance: ', abs(gt_edge_weights.sum() - (len(gt_edge_weights) / 2)))
return edges, edge_feat, diff_to_gt, gt_edge_weights, node_labeling, raw, nodes, noisy_affinities, gt
def get_pix_data(length=50000, shape=(128, 128), radius=72):
dim = (256, 256)
edge_offsets = [
[0, -1],
[-1, 0],
# direct 3d nhood for attractive edges
# [0, -1], [-1, 0]]
[-3, 0],
[0, -3],
[-6, 0],
[0, -6]
]
sep_chnl = 2
n_ellips = 5
n_polys = 10
n_rect = 5
ellips_color = np.array([1, 0, 0], dtype=np.float)
rect_color = np.array([0, 0, 1], dtype=np.float)
col_diff = 0.4
min_r, max_r = 10, 20
min_dist = max_r
img = np.random.randn(*(dim + (3, ))) / 5
gt = np.zeros(dim)
ri1, ri2, ri3, ri4, ri5, ri6 = np.sign(np.random.randint(-100, 100)) * (
(np.random.rand() * 2) + .5), np.sign(np.random.randint(-100, 100)) * (
(np.random.rand() * 2) + .5), (np.random.rand() * 4) + 3, (
np.random.rand() * 4) + 3, np.sign(np.random.randint(
-100, 100)) * ((np.random.rand() * 2) + .5), np.sign(
np.random.randint(-100, 100)) * (
(np.random.rand() * 2) + .5)
x = np.zeros(dim)
x[:, :] = np.arange(img.shape[0])[np.newaxis, :]
y = x.transpose()
img += (np.sin(
np.sqrt((x * ri1)**2 + ((dim[1] - y) * ri2)**2) * ri3 * np.pi /
dim[0]))[..., np.newaxis]
img += (np.sin(
np.sqrt((x * ri5)**2 + ((dim[1] - y) * ri6)**2) * ri4 * np.pi /
dim[1]))[..., np.newaxis]
img = gaussian(np.clip(img, 0.1, 1), sigma=.8)
circles = []
cmps = []
while len(circles) < n_ellips:
mp = np.random.randint(min_r, dim[0] - min_r, 2)
too_close = False
for cmp in cmps:
if np.linalg.norm(cmp - mp) < min_dist:
too_close = True
if too_close:
continue
r = np.random.randint(min_r, max_r, 2)
circles.append(draw.circle(mp[0], mp[1], r[0], shape=dim))
cmps.append(mp)
polys = []
while len(polys) < n_polys:
mp = np.random.randint(min_r, dim[0] - min_r, 2)
too_close = False
for cmp in cmps:
if np.linalg.norm(cmp - mp) < min_dist // 2:
too_close = True
if too_close:
continue
circle = draw.circle_perimeter(mp[0], mp[1], max_r)
poly_vert = np.random.choice(len(circle[0]),
np.random.randint(3, 6),
replace=False)
polys.append(
draw.polygon(circle[0][poly_vert], circle[1][poly_vert],
shape=dim))
cmps.append(mp)
rects = []
while len(rects) < n_rect:
mp = np.random.randint(min_r, dim[0] - min_r, 2)
_len = np.random.randint(min_r // 2, max_r, (2, ))
too_close = False
for cmp in cmps:
if np.linalg.norm(cmp - mp) < min_dist:
too_close = True
if too_close:
continue
start = (mp[0] - _len[0], mp[1] - _len[1])
rects.append(
draw.rectangle(start, extent=(_len[0] * 2, _len[1] * 2),
shape=dim))
cmps.append(mp)
for poly in polys:
color = np.random.rand(3)
while np.linalg.norm(color -
ellips_color) < col_diff or np.linalg.norm(
color - rect_color) < col_diff:
color = np.random.rand(3)
img[poly[0], poly[1], :] = color
img[poly[0], poly[1], :] += np.random.randn(len(poly[1]), 3) / 5
cols = np.random.choice(np.arange(4, 11, 1).astype(np.float) / 10,
n_ellips,
replace=False)
for i, ellipse in enumerate(circles):
gt[ellipse[0], ellipse[1]] = 1 + (i / 10)
ri1, ri2, ri3, ri4, ri5, ri6 = np.sign(np.random.randint(
-100, 100)) * ((np.random.rand() * 4) + 7), np.sign(
np.random.randint(-100, 100)) * (
(np.random.rand() * 4) + 7), (np.random.rand() + 1) * 3, (
np.random.rand() + 1) * 3, np.sign(
np.random.randint(-100, 100)) * (
(np.random.rand() * 4) + 7), np.sign(
np.random.randint(-100, 100)) * (
(np.random.rand() * 4) + 7)
img[ellipse[0], ellipse[1], :] = np.array([cols[i], 0.0, 0.0])
img[ellipse[0], ellipse[1], :] += np.array([1.0, 1.0, 0.0]) * ((np.sin(
np.sqrt((x[ellipse[0], ellipse[1]] * ri5)**2 +
((dim[1] - y[ellipse[0], ellipse[1]]) * ri2)**2) * ri3 *
np.pi / dim[0]))[..., np.newaxis] * 0.15) + 0.2
img[ellipse[0], ellipse[1], :] += np.array([1.0, 1.0, 0.0]) * ((np.sin(
np.sqrt((x[ellipse[0], ellipse[1]] * ri6)**2 +
((dim[1] - y[ellipse[0], ellipse[1]]) * ri1)**2) * ri4 *
np.pi / dim[1]))[..., np.newaxis] * 0.15) + 0.2
# img[ellipse[0], ellipse[1], :] += np.random.randn(len(ellipse[1]), 3) / 10
cols = np.random.choice(np.arange(4, 11, 1).astype(np.float) / 10,
n_rect,
replace=False)
for i, rect in enumerate(rects):
gt[rect[0], rect[1]] = 2 + (i / 10)
ri1, ri2, ri3, ri4, ri5, ri6 = np.sign(np.random.randint(
-100, 100)) * ((np.random.rand() * 4) + 7), np.sign(
np.random.randint(-100, 100)) * (
(np.random.rand() * 4) + 7), (np.random.rand() + 1) * 3, (
np.random.rand() + 1) * 3, np.sign(
np.random.randint(-100, 100)) * (
(np.random.rand() * 4) + 7), np.sign(
np.random.randint(-100, 100)) * (
(np.random.rand() * 4) + 7)
img[rect[0], rect[1], :] = np.array([0.0, 0.0, cols[i]])
img[rect[0], rect[1], :] += np.array([1.0, 1.0, 0.0]) * ((np.sin(
np.sqrt((x[rect[0], rect[1]] * ri5)**2 +
((dim[1] - y[rect[0], rect[1]]) * ri2)**2) * ri3 * np.pi /
dim[0]))[..., np.newaxis] * 0.15) + 0.2
img[rect[0], rect[1], :] += np.array([1.0, 1.0, 0.0]) * ((np.sin(
np.sqrt((x[rect[0], rect[1]] * ri1)**2 +
((dim[1] - y[rect[0], rect[1]]) * ri6)**2) * ri4 * np.pi /
dim[1]))[..., np.newaxis] * 0.15) + 0.2
# img[rect[0], rect[1], :] += np.random.randn(*(rect[1].shape + (3,)))/10
img = np.clip(img, 0, 1)
affinities = get_naive_affinities(gaussian(np.clip(img, 0, 1), sigma=.2),
edge_offsets)
affinities[:sep_chnl] *= -1
affinities[:sep_chnl] += +1
affinities[:sep_chnl] /= 1.3
affinities[sep_chnl:] *= 1.3
affinities = np.clip(affinities, 0, 1)
#
valid_edges = get_valid_edges((len(edge_offsets), ) + dim, edge_offsets,
sep_chnl, None, False)
node_labeling, neighbors, cutting_edges, mutexes = compute_mws_segmentation_cstm(
affinities.ravel(), valid_edges.ravel(), edge_offsets, sep_chnl, dim)
node_labeling = node_labeling - 1
nodes = np.unique(node_labeling)
try:
assert all(nodes == np.array(range(len(nodes)), dtype=np.float))
except:
Warning("node ids are off")
edge_feat, neighbors = get_edge_features_1d(node_labeling, edge_offsets,
affinities)
gt_edge_weights = calculate_gt_edge_costs(neighbors,
node_labeling.squeeze(),
gt.squeeze())
edges = neighbors.astype(np.long)
gt_seg = get_current_soln(gt_edge_weights, node_labeling, edges)
fig, (ax1, ax2, ax3) = plt.subplots(1, 3)
ax1.imshow(cm.prism(gt / gt.max()))
ax1.set_title('gt')
ax2.imshow(cm.prism(node_labeling / node_labeling.max()))
ax2.set_title('sp')
ax3.imshow(cm.prism(gt_seg / gt_seg.max()))
ax3.set_title('mc')
plt.show()
affinities = affinities.astype(np.float32)
edge_feat = edge_feat.astype(np.float32)
nodes = nodes.astype(np.float32)
node_labeling = node_labeling.astype(np.float32)
gt_edge_weights = gt_edge_weights.astype(np.float32)
diff_to_gt = np.abs((edge_feat[:, 0] - gt_edge_weights)).sum()
edges = np.sort(edges, axis=-1)
edges = edges.T
return img, gt, edges, edge_feat, diff_to_gt, gt_edge_weights, node_labeling, nodes, affinities
def get_pix_data(shape=(256, 256)):
""" This generates raw-gt-superpixels and correspondinng rags of rectangles and circles"""
rsign = lambda: (-1)**np.random.randint(0, 2)
edge_offsets = [[0, -1], [-1, 0], [-3, 0], [0, -3], [-6, 0],
[0, -6]] # offsets defining the edges for pixel affinities
overseg_factor = 1.7
sep_chnl = 2 # channel separating attractive from repulsive edges
n_circles = 5 # number of ellipses in image
n_polys = 10 # number of rand polys in image
n_rect = 5 # number rectangles in image
circle_color = np.array([1, 0, 0], dtype=np.float)
rect_color = np.array([0, 0, 1], dtype=np.float)
col_diff = 0.4 # by this margin object color can vary ranomly
min_r, max_r = 10, 20 # min and max radii of ellipses/circles
min_dist = max_r
img = np.random.randn(*(shape + (3, ))) / 5 # init image with some noise
gt = np.zeros(shape)
# get some random frequencies
ri1, ri2, ri3, ri4, ri5, ri6 = rsign() * ((np.random.rand() * 2) + .5), \
rsign() * ((np.random.rand() * 2) + .5), \
(np.random.rand() * 4) + 3, \
(np.random.rand() * 4) + 3, \
rsign() * ((np.random.rand() * 2) + .5), \
rsign() * ((np.random.rand() * 2) + .5)
x = np.zeros(shape)
x[:, :] = np.arange(img.shape[0])[np.newaxis, :]
y = x.transpose()
# add background frequency interferences
img += (np.sin(
np.sqrt((x * ri1)**2 + ((shape[1] - y) * ri2)**2) * ri3 * np.pi /
shape[0]))[..., np.newaxis]
img += (np.sin(
np.sqrt((x * ri5)**2 + ((shape[1] - y) * ri6)**2) * ri4 * np.pi /
shape[1]))[..., np.newaxis]
# smooth a bit
img = gaussian(np.clip(img, 0.1, 1), sigma=.8)
# add some circles
circles = []
cmps = []
while len(circles) < n_circles:
mp = np.random.randint(min_r, shape[0] - min_r, 2)
too_close = False
for cmp in cmps:
if np.linalg.norm(cmp - mp) < min_dist:
too_close = True
if too_close:
continue
r = np.random.randint(min_r, max_r, 2)
circles.append(draw.circle(mp[0], mp[1], r[0], shape=shape))
cmps.append(mp)
# add some random polygons
polys = []
while len(polys) < n_polys:
mp = np.random.randint(min_r, shape[0] - min_r, 2)
too_close = False
for cmp in cmps:
if np.linalg.norm(cmp - mp) < min_dist // 2:
too_close = True
if too_close:
continue
circle = draw.circle_perimeter(mp[0], mp[1], max_r)
poly_vert = np.random.choice(len(circle[0]),
np.random.randint(3, 6),
replace=False)
polys.append(
draw.polygon(circle[0][poly_vert],
circle[1][poly_vert],
shape=shape))
cmps.append(mp)
# add some random rectangles
rects = []
while len(rects) < n_rect:
mp = np.random.randint(min_r, shape[0] - min_r, 2)
_len = np.random.randint(min_r // 2, max_r, (2, ))
too_close = False
for cmp in cmps:
if np.linalg.norm(cmp - mp) < min_dist:
too_close = True
if too_close:
continue
start = (mp[0] - _len[0], mp[1] - _len[1])
rects.append(
draw.rectangle(start,
extent=(_len[0] * 2, _len[1] * 2),
shape=shape))
cmps.append(mp)
# draw polys and give them some noise
for poly in polys:
color = np.random.rand(3)
while np.linalg.norm(color -
circle_color) < col_diff or np.linalg.norm(
color - rect_color) < col_diff:
color = np.random.rand(3)
img[poly[0], poly[1], :] = color
img[poly[0], poly[1], :] += np.random.randn(len(
poly[1]), 3) / 5 # add noise to the polygons
# draw circles with some frequency
cols = np.random.choice(np.arange(4, 11, 1).astype(np.float) / 10,
n_circles,
replace=False) # get colors
for i, circle in enumerate(circles):
gt[circle[0], circle[1]] = 1 + (i / 10)
ri1, ri2, ri3, ri4, ri5, ri6 = rsign() * ((np.random.rand() * 4) + 7), \
rsign() * ((np.random.rand() * 4) + 7), \
(np.random.rand() + 1) * 8, \
(np.random.rand() + 1) * 8, \
rsign() * ((np.random.rand() * 4) + 7), \
rsign() * ((np.random.rand() * 4) + 7)
img[circle[0],
circle[1], :] = np.array([cols[i], 0.0,
0.0]) # set even color intensity
# set interference of two freqs in circle color channel
img[circle[0], circle[1], :] += np.array([1.0, 1.0, 0.0]) * ((np.sin(
np.sqrt((x[circle[0], circle[1]] * ri5)**2 +
((shape[1] - y[circle[0], circle[1]]) * ri2)**2) * ri3 *
np.pi / shape[0]))[..., np.newaxis] * 0.15) + 0.2
img[circle[0], circle[1], :] += np.array([1.0, 1.0, 0.0]) * ((np.sin(
np.sqrt((x[circle[0], circle[1]] * ri6)**2 +
((shape[1] - y[circle[0], circle[1]]) * ri1)**2) * ri4 *
np.pi / shape[1]))[..., np.newaxis] * 0.15) + 0.2
# draw rectangles with some frequency
cols = np.random.choice(np.arange(4, 11, 1).astype(np.float) / 10,
n_rect,
replace=False)
for i, rect in enumerate(rects):
gt[rect[0], rect[1]] = 2 + (i / 10)
ri1, ri2, ri3, ri4, ri5, ri6 = rsign() * ((np.random.rand() * 4) + 7), \
rsign() * ((np.random.rand() * 4) + 7), \
(np.random.rand() + 1) * 8, \
(np.random.rand() + 1) * 8, \
rsign() * ((np.random.rand() * 4) + 7), \
rsign() * ((np.random.rand() * 4) + 7)
img[rect[0], rect[1], :] = np.array([0.0, 0.0, cols[i]])
img[rect[0], rect[1], :] += np.array([1.0, 1.0, 0.0]) * ((np.sin(
np.sqrt((x[rect[0], rect[1]] * ri5)**2 +
((shape[1] - y[rect[0], rect[1]]) * ri2)**2) * ri3 *
np.pi / shape[0]))[..., np.newaxis] * 0.15) + 0.2
img[rect[0], rect[1], :] += np.array([1.0, 1.0, 0.0]) * ((np.sin(
np.sqrt((x[rect[0], rect[1]] * ri1)**2 +
((shape[1] - y[rect[0], rect[1]]) * ri6)**2) * ri4 *
np.pi / shape[1]))[..., np.newaxis] * 0.15) + 0.2
img = np.clip(img, 0, 1) # clip to valid range
# get affinities and calc superpixels with mutex watershed
affinities = get_naive_affinities(gaussian(img, sigma=.2), edge_offsets)
affinities[:sep_chnl] *= -1
affinities[:sep_chnl] += +1
# scale affinities in order to get an oversegmentation
affinities[:sep_chnl] /= overseg_factor
affinities[sep_chnl:] *= overseg_factor
affinities = np.clip(affinities, 0, 1)
node_labeling = compute_mws_segmentation(affinities, edge_offsets,
sep_chnl)
node_labeling = node_labeling - 1
nodes = np.unique(node_labeling)
try:
assert all(nodes == np.array(range(len(nodes)), dtype=np.float))
except:
Warning("node ids are off")
# get edges from node labeling and edge features from affinity stats
edge_feat, neighbors = get_edge_features_1d(node_labeling, edge_offsets,
affinities)
# get gt edge weights based on edges and gt image
gt_edge_weights = calculate_gt_edge_costs(neighbors,
node_labeling.squeeze(),
gt.squeeze())
edges = neighbors.astype(np.long)
# # calc multicut from gt
# gt_seg = get_current_soln(gt_edge_weights, node_labeling, edges)
# # show result (uncomment for testing)
#
# fig, (ax1, ax2, ax3, ax4) = plt.subplots(1, 4)
# ax1.imshow(cm.prism(gt/gt.max()));ax1.set_title('gt')
# ax2.imshow(cm.prism(node_labeling / node_labeling.max()));ax2.set_title('sp')
# ax3.imshow(cm.prism(gt_seg / gt_seg.max()));ax3.set_title('mc')
# ax4.imshow(img);ax4.set_title('raw')
# plt.show()
affinities = affinities.astype(np.float32)
edge_feat = edge_feat.astype(np.float32)
nodes = nodes.astype(np.float32)
node_labeling = node_labeling.astype(np.float32)
gt_edge_weights = gt_edge_weights.astype(np.float32)
diff_to_gt = np.abs((edge_feat[:, 0] - gt_edge_weights)).sum()
edges = np.sort(edges, axis=-1)
edges = edges.T
return img, gt, edges, edge_feat, diff_to_gt, gt_edge_weights, node_labeling, nodes, affinities
def get_heat_map_by_affs(img):
affs = get_naive_affinities(img[..., np.newaxis], offsets=offs)
hmap = affs.sum(0) / affs.shape[0]
return hmap, affs
def create_dsets(self, num):
for file_index in range(num):
n_disc = np.random.randint(25, 30)
rads = []
mps = []
for disc in range(n_disc):
radius = np.random.randint(
max(self.shape) // 25,
max(self.shape) // 20)
touching = True
while touching:
mp = np.array([
np.random.randint(0 + radius, self.shape[0] - radius),
np.random.randint(0 + radius, self.shape[1] - radius)
])
touching = False
for other_rad, other_mp in zip(rads, mps):
diff = mp - other_mp
if (diff**2).sum()**.5 <= radius + other_rad + 2:
touching = True
rads.append(radius)
mps.append(mp)
data = np.zeros(shape=self.shape, dtype=np.float)
gt = np.zeros(shape=self.shape, dtype=np.float)
for y in range(self.shape[0]):
for x in range(self.shape[1]):
bg = True
for radius, mp in zip(rads, mps):
ly, lx = y - mp[0], x - mp[1]
if (ly**2 + lx**2)**.5 <= radius:
data[y, x] += np.cos(
np.sqrt((x - self.shape[1])**2 + y**2) * 50 *
np.pi / self.shape[1])
data[y, x] += np.cos(
np.sqrt(x**2 + y**2) * 50 * np.pi /
self.shape[1])
# data[y, x] += 6
gt[y, x] = 1
bg = False
if bg:
data[y, x] += np.cos(y * 40 * np.pi / self.shape[0])
data[y, x] += np.cos(
np.sqrt(x**2 + (self.shape[0] - y)**2) * 30 *
np.pi / self.shape[1])
data += 1
# plt.imshow(data);plt.show()
if self.no_suppix:
raw = torch.from_numpy(data).float()
return raw.unsqueeze(0), torch.from_numpy(gt.astype(np.long))
# return torch.stack((torch.rand_like(raw), raw, torch.rand_like(raw))), torch.from_numpy(gt.astype(np.long))
affinities = affutils.get_naive_affinities(data, self.offsets)
gt_affinities, _ = compute_affinities(gt == 1, self.offsets)
gt_affinities[self.sep_chnl:] *= -1
gt_affinities[self.sep_chnl:] += +1
affinities[self.sep_chnl:] *= -1
affinities[self.sep_chnl:] += +1
# affinities[:self.sep_chnl] /= 1.1
affinities[self.sep_chnl:] *= 1.01
affinities = (affinities -
(affinities * gt_affinities)) + gt_affinities
# affinities[self.sep_chnl:] *= -1
# affinities[self.sep_chnl:] += +1
# affinities[self.sep_chnl:] *= 4
affinities = affinities.clip(0, 1)
valid_edges = get_valid_edges((len(self.offsets), ) + self.shape,
self.offsets, self.sep_chnl, None,
False)
node_labeling, neighbors, cutting_edges, mutexes = compute_mws_segmentation_cstm(
affinities.ravel(), valid_edges.ravel(), self.offsets,
self.sep_chnl, self.shape)
node_labeling = node_labeling - 1
nodes = np.unique(node_labeling)
try:
assert all(
nodes == np.array(range(len(nodes)), dtype=np.float))
except:
Warning("node ids are off")
noisy_affinities = affinities
edge_feat, neighbors = get_edge_features_1d(
node_labeling, self.offsets, noisy_affinities)
gt_edge_weights = calculate_gt_edge_costs(neighbors,
node_labeling.squeeze(),
gt.squeeze())
while abs(gt_edge_weights.sum() - (len(gt_edge_weights) / 2)) > 1:
edge_idx = np.random.choice(np.arange(len(gt_edge_weights)),
p=torch.softmax(torch.from_numpy(
(gt_edge_weights == 0).astype(
np.float)),
dim=0).numpy())
if gt_edge_weights[edge_idx] != 0.0:
continue
# print(abs(gt_edge_weights.sum() - (len(gt_edge_weights) / 2)))
edge = neighbors[edge_idx].astype(np.int)
# merge superpixel
diff = edge[0] - edge[1]
mass = (node_labeling == edge[0]).sum()
node_labeling = node_labeling - (node_labeling
== edge[0]) * diff
new_mass = (node_labeling == edge[1]).sum()
try:
assert new_mass >= mass
except:
a = 1
# if edge_idx == 0:
# neighbors = neighbors[1:]
# gt_edge_weights = gt_edge_weights[1:]
# elif edge_idx == len(gt_edge_weights):
# neighbors = neighbors[:-1]
# gt_edge_weights = gt_edge_weights[:-1]
# else:
# neighbors = np.concatenate((neighbors[:edge_idx], neighbors[edge_idx+1:]), axis=0)
# gt_edge_weights = np.concatenate((gt_edge_weights[:edge_idx], gt_edge_weights[edge_idx+1:]), axis=0)
#
# neighbors[neighbors == edge[0]] == edge[1]
edge_feat, neighbors = get_edge_features_1d(
node_labeling, self.offsets, noisy_affinities)
gt_edge_weights = calculate_gt_edge_costs(
neighbors, node_labeling.squeeze(), gt.squeeze())
edge_feat, neighbors = get_edge_features_1d(
node_labeling, self.offsets, noisy_affinities)
gt_edge_weights = calculate_gt_edge_costs(neighbors,
node_labeling.squeeze(),
gt.squeeze())
gt = torch.from_numpy(gt.astype(np.float32)).squeeze().float()
edges = torch.from_numpy(neighbors.astype(np.long))
raw = torch.tensor(data).squeeze().float()
noisy_affinities = torch.tensor(noisy_affinities).squeeze().float()
edge_feat = torch.from_numpy(edge_feat.astype(np.float32))
nodes = torch.from_numpy(nodes.astype(np.float32))
node_labeling = torch.from_numpy(node_labeling.astype(np.float32))
gt_edge_weights = torch.from_numpy(
gt_edge_weights.astype(np.float32))
diff_to_gt = (edge_feat[:, 0] - gt_edge_weights).abs().sum()
edges = edges.t().contiguous()
edges = torch.cat((edges, torch.stack((edges[1], edges[0]))),
dim=1)
self.write_to_h5(
'/g/kreshuk/hilt/projects/fewShotLearning/mutexWtsd/data/storage/balanced_graphs/balanced_graph_data'
+ str(file_index) + '.h5', edges, edge_feat, diff_to_gt,
gt_edge_weights, node_labeling, raw, nodes, noisy_affinities,
gt)