def print_minimum(self): self.info('print_minimum:') connections = self.compute_connections(only_close_enough=False) self.show_connections(connections, 'all of them') nodes1 = list(self.tree1.G.nodes()) nodes2 = list(self.tree2.G.nodes()) # TODO: do not compute all of this Db = construct_matrix_iterators((nodes1, nodes2), lambda n1, n2: self.distance(n1, n2)) Dp = construct_matrix_iterators((nodes1, nodes2), lambda n1, n2: self.distance_prediction(n1, n2)) Db_min, m = md_argmin(Db) n1 = nodes1[m[0]] n2 = nodes2[m[1]] assert_allclose(Db_min, self.distance(n1, n2)) self.info('Minimum distance_branch: %g between %s and %s' % (Db_min, self.tree1.node_friendly(n1), self.tree2.node_friendly(n2))) Dp_min, m = md_argmin(Dp) n1 = nodes1[m[0]] n2 = nodes2[m[1]] assert_allclose(Dp_min, self.distance_prediction(n1, n2)) self.info('Minimum distance_prediction: %g between %s and %s' % (Dp_min, self.tree1.node_friendly(n1), self.tree2.node_friendly(n2)))
def print_minimum(self): self.info('print_minimum:') connections = self.compute_connections(only_close_enough=False) self.show_connections(connections, 'all of them') nodes1 = list(self.tree1.G.nodes()) nodes2 = list(self.tree2.G.nodes()) # TODO: do not compute all of this Db = construct_matrix_iterators((nodes1, nodes2), lambda n1, n2: self.distance(n1, n2)) Dp = construct_matrix_iterators( (nodes1, nodes2), lambda n1, n2: self.distance_prediction(n1, n2)) Db_min, m = md_argmin(Db) n1 = nodes1[m[0]] n2 = nodes2[m[1]] assert_allclose(Db_min, self.distance(n1, n2)) self.info('Minimum distance_branch: %g between %s and %s' % (Db_min, self.tree1.node_friendly(n1), self.tree2.node_friendly(n2))) Dp_min, m = md_argmin(Dp) n1 = nodes1[m[0]] n2 = nodes2[m[1]] assert_allclose(Dp_min, self.distance_prediction(n1, n2)) self.info('Minimum distance_prediction: %g between %s and %s' % (Dp_min, self.tree1.node_friendly(n1), self.tree2.node_friendly(n2)))
def plot_3d_graph(pylab, G, plan2point, plan2color, edges2color=None): if edges2color is None: edges2color = lambda n1, n2: [0, 0, 0] #@UnusedVariable cm = matplotlib.cm.get_cmap('RdYlBu') import mpl_toolkits.mplot3d.axes3d as plot3 fig = pylab.gcf() ax = plot3.Axes3D(fig) for pi, pj, ec in get_edges_points_and_color(G, plan2point, edges2color): coords = np.vstack((pi, pj)).T ax.plot3D(xs=coords[0], ys=coords[1], zs=coords[2], linestyle='-', color=ec) n = len(G) P = np.array(map(plan2point, G)).T assert_allclose(P.shape, (3, n)) color = map(plan2color, G) patches = ax.scatter3D(P[0], P[1], P[2], s=40, c=color, cmap=cm) try: fig.colorbar(patches) except TypeError as e: logger.error('Cannot use colorbar') logger.exception(e)
def md_argmin(a): """ Returns the value and the index coordinate of a multidimensional array """ min_value = np.min(a) index_flat = np.argmin(a) ij = np.unravel_index(index_flat, a.shape) ij = tuple(ij) assert_allclose(a[ij], min_value) return a[ij], ij
def get_nodes_distance_matrix(G, nodelist, weight_field=None): n = len(nodelist) D = floyd_warshall_numpy(G, nodelist, weight=weight_field) assert_allclose(D.shape, (n, n)) assert_allclose(np.isfinite(D), True) assert np.all(D >= 0) # there was some strange bug. Keep this even if you don't understand why D = np.array(D, dtype='float64') return D
def plot_2d_graph(pylab, G, plan2point, plan2color, edges2color=None, s=120): if edges2color is None: edges2color = lambda n1, n2: [0, 0, 0] #@UnusedVariable cm = matplotlib.cm.get_cmap('RdYlBu') for pi, pj, ec in get_edges_points_and_color(G, plan2point, edges2color): coords = np.vstack((pi, pj)).T pylab.plot(coords[0], coords[1], linestyle='-', color=ec, zorder=1) n = len(G) P = np.array(map(plan2point, G)).T assert_allclose(P.shape, (2, n)) color = map(plan2color, G) pylab.scatter(P[0], P[1], s=s, c=color, cmap=cm, zorder=3) pylab.axis('equal') turn_all_axes_off(pylab) pylab.colorbar()
def distance(self, y0, y1): """ Compare Y1(s) with best matching pixel in Y2(s_n) where s_s \in (the neighbourhood of s) """ Y1 = y0.get_values() Y2 = y1.get_values() fs = self._get_flat_structure(Y1.shape[:2]) Y2_unrolled = fs.ndvalues2unrolledneighbors(Y2) Y1_repeated = fs.ndvalues2repeated(Y1) assert_allclose(Y2_unrolled.shape, Y1_repeated.shape) diff1 = np.abs(Y2_unrolled - Y1_repeated) if diff1.ndim == 3: diff1 = np.mean(diff1, axis=2) D = fs.get_distances() N, _ = D.shape distance_to_closest = np.zeros(N) for i in range(N): diff_i = diff1[i, :] # best matches matches, = np.nonzero(diff_i == np.min(diff_i)) distance_to_matches = D[i, matches] distance_to_closest[i] = np.min(distance_to_matches) if False: if i == N / 2: print('i: %s' % i) print('distances[i]: %s' % D[i, :]) print('diff1[i]: %s' % diff_i) print('matches: %s' % matches) print('matches dist: %s' % distance_to_matches) print('dist[i]: %s' % distance_to_closest[i]) myres = np.mean(distance_to_closest) return myres
def test_distance_neighbor_dist2_repeated(): # A constant pattern a = np.ones((100, 100, 3)) # Let's get some translated slices w = 80 N = 10 A = [] for i in range(N): A.append(a[i:i + w, 0:0 + w, ...]) print() areas = [0.01, 0.03, 0.05, 0.07] Ds = [DistanceNeighborDist((a, a)) for a in areas] L2 = DistanceNorm(2) for i in range(N): y0 = UncertainImage(A[0]) y1 = UncertainImage(A[i]) vl2 = L2.distance(y0, y1) ds = [x.distance(y0, y1) for x in Ds] assert_allclose(ds, 0) # < this must be zero s = ";".join("%1.5f" % x for x in ds) print('- step %d L2: %1.5f %s' % (i, vl2, s))
def ManualMotion(tcname, id_discdds, id_image, planstring): # Get a random plan config = get_current_config() discdds = config.discdds.instance(id_discdds) rgb = config.images.instance(id_image) shape = discdds.get_shape() image1 = resize(rgb, shape[1], shape[0]) assert_allclose(image1.shape[:2], shape) chars = "abcdefghilmnopqrst" char2int = dict([(c, i) for i, c in enumerate(chars)]) plan = tuple(map(char2int.__getitem__, planstring)) # predict the result y0 = UncertainImage(image1) y1 = discdds.predict(y0, plan) tc = TestCase(id_tc=tcname, id_discdds=id_discdds, y0=y0, y1=y1, true_plan=plan) return tc
def FromImages(tcname, id_discdds, image1, image2, true_plan=None): config = get_current_config() discdds = config.discdds.instance(id_discdds) shape = discdds.get_shape() rgb1 = config.images.instance(image1) image1 = resize(rgb1, shape[1], shape[0]) assert_allclose(image1.shape[:2], shape) rgb2 = config.images.instance(image2) image2 = resize(rgb2, shape[1], shape[0]) assert_allclose(image2.shape[:2], shape) # predict the result y0 = UncertainImage(image1) y1 = UncertainImage(image2) tc = TestCase(id_tc=tcname, id_discdds=id_discdds, y0=y0, y1=y1, true_plan=true_plan) return tc
def distance(self, y0, y1): """ Compare Y1(s) with best matching pixel in Y2(s_n) where s_s \in (the neighbourhood of s) """ Y1 = y0.get_values() Y2 = y1.get_values() fs = self._get_flat_structure(Y1.shape[:2]) Y2_unrolled = fs.image2unrolledneighbors(Y2) Y1_repeated = fs.image2repeated(Y1) assert_allclose(Y2_unrolled.shape, Y1_repeated.shape) diff1 = np.abs(Y2_unrolled - Y1_repeated) myres = np.mean(np.min(diff1, axis=1)) if False: # old method, equivalent neighbor_indices_flat = fs.neighbor_indices_flat nchannels = Y1.shape[2] nsensel = Y1[:, :, 0].size best = np.zeros((nsensel, Y1.shape[2])) for c in range(nchannels): y1_flat = Y1[:, :, c].astype(np.int16).flat y2_flat = Y2[:, :, c].astype(np.int16).flat for k in range(nsensel): a = y1_flat[k].astype(np.float) b = y2_flat[neighbor_indices_flat[k]] diff = np.abs(a - b) best[k, c] = np.min(diff) res = np.mean(best)#/self.maxval_distance_neighborhood_bestmatch assert_allclose(res, myres) return myres
def distance(self, y0, y1): """ Compare Y1(s) with best matching pixel in Y2(s_n) where s_s \in (the neighbourhood of s) """ Y1 = y0.get_values() Y2 = y1.get_values() fs = self._get_flat_structure(Y1.shape[:2]) Y2_unrolled = fs.image2unrolledneighbors(Y2) Y1_repeated = fs.image2repeated(Y1) assert_allclose(Y2_unrolled.shape, Y1_repeated.shape) diff1 = np.abs(Y2_unrolled - Y1_repeated) myres = np.mean(np.min(diff1, axis=1)) if False: # old method, equivalent neighbor_indices_flat = fs.neighbor_indices_flat nchannels = Y1.shape[2] nsensel = Y1[:, :, 0].size best = np.zeros((nsensel, Y1.shape[2])) for c in range(nchannels): y1_flat = Y1[:, :, c].astype(np.int16).flat y2_flat = Y2[:, :, c].astype(np.int16).flat for k in range(nsensel): a = y1_flat[k].astype(np.float) b = y2_flat[neighbor_indices_flat[k]] diff = np.abs(a - b) best[k, c] = np.min(diff) res = np.mean(best) # /self.maxval_distance_neighborhood_bestmatch assert_allclose(res, myres) return myres
def test_distance_neighbor_dist3(): gs = FlatStructure((100, 100), (3, 3)) D = gs.get_distances() assert_allclose(np.max(D), np.sqrt(2))
def test_distance_neighbor_dist1(): gs = FlatStructure((100, 100), (1, 1)) D = gs.get_distances() assert_allclose(D, 0)