def show_chip_distinctiveness_plot(chip, kpts, dstncvs, fnum=1, pnum=None): import wbia.plottool as pt pt.figure(fnum, pnum=pnum) ax = pt.gca() divider = pt.ensure_divider(ax) # ax1 = divider.append_axes("left", size="50%", pad=0) ax1 = ax ax2 = divider.append_axes('bottom', size='100%', pad=0.05) # f, (ax1, ax2) = pt.plt.subplots(1, 2, sharex=True) cmapstr = 'rainbow' # 'hot' color_list = pt.df2.plt.get_cmap(cmapstr)(ut.norm_zero_one(dstncvs)) sortx = dstncvs.argsort() # pt.df2.plt.plot(qfx2_dstncvs[sortx], c=color_list[sortx]) pt.plt.sca(ax1) pt.colorline(np.arange(len(sortx)), dstncvs[sortx], cmap=pt.plt.get_cmap(cmapstr)) pt.gca().set_xlim(0, len(sortx)) pt.dark_background() pt.plt.sca(ax2) pt.imshow(chip, darken=0.2) # MATPLOTLIB BUG CANNOT SHOW DIFFERENT ALPHA FOR POINTS AND KEYPOINTS AT ONCE # pt.draw_kpts2(kpts, pts_color=color_list, ell_color=color_list, ell_alpha=.1, ell=True, pts=True) # pt.draw_kpts2(kpts, color_list=color_list, pts_alpha=1.0, pts_size=1.5, # ell=True, ell_alpha=.1, pts=False) ell = ut.get_argflag('--ell') pt.draw_kpts2( kpts, color_list=color_list, pts_alpha=1.0, pts_size=1.5, ell=ell, ell_alpha=0.3, pts=not ell, ) pt.plt.sca(ax)
def test_mcc(): import wbia.plottool as pt import sklearn.metrics num = 100 xdata = np.linspace(0, 1, num * 2) ydata = np.linspace(1, -1, num * 2) pt.plt.plot(xdata, ydata, '--k', label='linear') y_true = [1] * num + [0] * num y_pred = y_true[:] xs = [] for i in range(0, len(y_true)): y_pred[-i] = 1 - y_pred[-i] xs.append(sklearn.metrics.matthews_corrcoef(y_true, y_pred)) pt.plot(xdata, xs, label='change one class at a time') y_true = ut.flatten(zip([1] * num, [0] * num)) y_pred = y_true[:] xs = [] for i in range(0, len(y_true)): y_pred[-i] = 1 - y_pred[-i] xs.append(sklearn.metrics.matthews_corrcoef(y_true, y_pred)) pt.plot(xdata, xs, label='change classes evenly') pt.gca().legend()
def draw_tree_model(model, **kwargs): import wbia.plottool as pt import networkx as netx if not ut.get_argval('--hackjunc'): fnum = pt.ensure_fnum(None) fig = pt.figure(fnum=fnum, doclf=True) # NOQA ax = pt.gca() # name_nodes = sorted(ut.list_getattr(model.ttype2_cpds[NAME_TTYPE], 'variable')) netx_graph = model.to_markov_model() # pos = netx.pygraphviz_layout(netx_graph) # pos = netx.graphviz_layout(netx_graph) # pos = get_hacked_pos(netx_graph, name_nodes, prog='neato') pos = netx.nx_pydot.pydot_layout(netx_graph) node_color = [pt.WHITE] * len(pos) drawkw = dict(pos=pos, ax=ax, with_labels=True, node_color=node_color, node_size=1100) netx.draw(netx_graph, **drawkw) if kwargs.get('show_title', True): pt.set_figtitle('Markov Model') if not ut.get_argval('--hackmarkov'): fnum = pt.ensure_fnum(None) fig = pt.figure(fnum=fnum, doclf=True) # NOQA ax = pt.gca() netx_graph = model.to_junction_tree() # prettify nodes def fixtupkeys(dict_): return { ', '.join(k) if isinstance(k, tuple) else k: fixtupkeys(v) for k, v in dict_.items() } # FIXME n = fixtupkeys(netx_graph.node) e = fixtupkeys(netx_graph.edge) a = fixtupkeys(netx_graph.adj) netx_graph.nodes.update(n) netx_graph.edges.update(e) netx_graph.adj.update(a) # netx_graph = model.to_markov_model() # pos = netx.pygraphviz_layout(netx_graph) # pos = netx.graphviz_layout(netx_graph) pos = netx.nx_pydot.pydot_layout(netx_graph) node_color = [pt.WHITE] * len(pos) drawkw = dict(pos=pos, ax=ax, with_labels=True, node_color=node_color, node_size=2000) netx.draw(netx_graph, **drawkw) if kwargs.get('show_title', True): pt.set_figtitle('Junction/Clique Tree / Cluster Graph')
def label_ticks(label_texts): import wbia.plottool as pt truncated_labels = [repr(lbl[0:100]) for lbl in label_texts] ax = pt.gca() ax.set_xticks(list(range(len(label_texts)))) ax.set_xticklabels(truncated_labels) [lbl.set_rotation(-55) for lbl in ax.get_xticklabels()] [ lbl.set_horizontalalignment('left') for lbl in ax.get_xticklabels() ] # xgrid, ygrid = np.meshgrid(range(len(label_texts)), range(len(label_texts))) # pt.plot_surface3d(xgrid, ygrid, disjoint_mat) ax.set_yticks(list(range(len(label_texts)))) ax.set_yticklabels(truncated_labels) [ lbl.set_horizontalalignment('right') for lbl in ax.get_yticklabels() ] [ lbl.set_verticalalignment('center') for lbl in ax.get_yticklabels() ]
def show_single_namematch(): import wbia.plottool as pt ax = cm.show_single_namematch(qreq_, aid2, mode=0) ax = pt.gca() ax.figure.canvas.draw() pt.update()
def static_plot(self, fnum=None, pnum=(1, 1, 1)): import wbia.plottool as pt self.ax = pt.gca() # self.ax.imshow(img, interpolation='nearest', alpha=1) # self.ax.imshow(mask, interpolation='nearest', alpha=0.6) pt.imshow(self.img, ax=self.ax, interpolation='nearest', alpha=1) pt.imshow(self.mask, ax=self.ax, interpolation='nearest', alpha=0.6) self.update_title() self.ax.grid(False)
def zoom_factory(ax=None, zoomable_list=[], base_scale=1.1): """ References: https://gist.github.com/tacaswell/3144287 http://stackoverflow.com/questions/11551049/matplotlib-plot-zooming-with-scroll-wheel """ if ax is None: ax = pt.gca() def zoom_fun(event): # print('zooming') # get the current x and y limits cur_xlim = ax.get_xlim() cur_ylim = ax.get_ylim() xdata = event.xdata # get event x location ydata = event.ydata # get event y location if xdata is None or ydata is None: return if event.button == 'up': # deal with zoom in scale_factor = 1 / base_scale elif event.button == 'down': # deal with zoom out scale_factor = base_scale else: raise NotImplementedError('event.button=%r' % (event.button, )) # deal with something that should never happen scale_factor = 1 print(event.button) for zoomable in zoomable_list: zoom = zoomable.get_zoom() new_zoom = zoom / (scale_factor**(1.2)) zoomable.set_zoom(new_zoom) # Get distance from the cursor to the edge of the figure frame x_left = xdata - cur_xlim[0] x_right = cur_xlim[1] - xdata y_top = ydata - cur_ylim[0] y_bottom = cur_ylim[1] - ydata ax.set_xlim( [xdata - x_left * scale_factor, xdata + x_right * scale_factor]) ax.set_ylim( [ydata - y_top * scale_factor, ydata + y_bottom * scale_factor]) # ---- ax.figure.canvas.draw() # force re-draw fig = ax.get_figure() # get the figure of interest # attach the call back fig.canvas.mpl_connect('scroll_event', zoom_fun) # return the function return zoom_fun
def pan_factory(ax=None): if ax is None: ax = pt.gca() self = PanEvents(ax) ax = self.ax fig = ax.get_figure() # get the figure of interest self.cidBP = fig.canvas.mpl_connect('button_press_event', self.pan_on_press) self.cidBR = fig.canvas.mpl_connect('button_release_event', self.pan_on_release) self.cidBM = fig.canvas.mpl_connect('motion_notify_event', self.pan_on_motion) # attach the call back return self
def plot(self, fnum, pnum): self.infr.update_visual_attrs(self.show_cuts) layoutkw = dict(prog='neato', splines='spline', sep=10 / 72) # draw_implicit=self.show_cuts) self.plotinfo = pt.show_nx( self.infr.graph, as_directed=False, fnum=self.fnum, layoutkw=layoutkw, # node_labels=True, modify_ax=False, use_image=self.use_image, verbose=0, ) ut.util_graph.graph_info(self.infr.graph, verbose=True) # _, edge_weights, edge_colors = self.infr.get_colored_edge_weights() # pt.colorbar(edge_weights, edge_colors, lbl='weights') # _normal_ticks = np.linspace(0, 1, num=11) # _normal_scores = np.linspace(0, 1, num=500) # _normal_colors = self.infr.get_colored_weights(_normal_scores) # cb = pt.colorbar(_normal_scores, _normal_colors, lbl='weights', # ticklabels=_normal_ticks) # cb.ax.annotate('threshold', # xy=(1, self.infr.thresh), # xytext=(2.5, .3 if self.infr.thresh < .5 else .7), # arrowprops=dict( # alpha=.5, # fc="0.6", # connectionstyle="angle3,angleA=90,angleB=0"),) ax = pt.gca() self.enable_pan_and_zoom(ax) # ax.autoscale() for aid in self.selected_aids: self.highlight_aid(aid, pt.ORANGE) # self.static_plot(fnum, pnum) self.make_hud() # logger.info(ut.repr2(self.infr.graph.edges, nl=2)) logger.info('Finished Plot')
def get_popup_options(self): from wbia.gui import inspect_gui options = [] ax = pt.gca() # HACK from wbia.plottool import plot_helpers as ph viztype = ph.get_plotdat(ax, 'viztype', '') is_match_type = viztype in ['matches', 'multi_match'] if is_match_type: options += inspect_gui.get_aidpair_context_menu_options( self.ibs, self.qaid, self.daid, self.cm, qreq_=self.qreq_, # update_callback=self.show_page, # backend_callback=None, aid_list=aid_list) ) options += [ # ('Toggle same_fig', self.toggle_samefig), # ('Toggle vert', self.toggle_vert), ('query last feature', self.query_last_feature), ('show each chip', self.show_each_chip), ('show each distinctiveness chip', self.show_each_dstncvs_chip), ('show each foreground weight chip', self.show_each_fgweight_chip), ('show each probchip', self.show_each_probchip), ('show coverage', self.show_coverage), # ('show each probchip', self.query_last_feature), ] # options.append(('name_interaction', self.name_interaction)) # if self.H1 is not None: # options.append(('Toggle homog', self.toggle_homog)) if ut.is_developer(): options.append(('dev_reload', self.dev_reload)) options.append(('dev_embed', self.dev_embed)) # options.append(('cancel', lambda: print('cancel'))) options += super(MatchInteraction, self).get_popup_options() return options
def show_edge(infr, edge, fnum=None, pnum=None, **kwargs): import wbia.plottool as pt match = infr._exec_pairwise_match([edge])[0] fnum = pt.ensure_fnum(fnum) pt.figure(fnum=fnum, pnum=pnum) ax = pt.gca() showkw = dict( vert=False, heatmask=True, show_lines=False, show_ell=False, show_ori=False, show_eig=False, modifysize=True, ) showkw.update(kwargs) match.show(ax, **showkw)
def show_page(self): if self.fig is None: raise AssertionError( 'fig is None, did you run interction.start()?') import wbia.plottool as pt fig = ih.begin_interaction('expandable', self.fnum) if not any(self.pnum_list): # If no pnum was given, find a set that agrees with constraints self.nRows, self.nCols = pt.get_num_rc(len(self.pnum_list), nRows=self.nRows, nCols=self.nCols) nSubplots = len(self.func_list) pnum_ = pt.make_pnum_nextgen(self.nRows, self.nCols, nSubplots=nSubplots) pnum_list = [pnum_() for _ in self.pnum_list] else: pnum_list = self.pnum_list for index, (pnum, func) in enumerate(zip(pnum_list, self.func_list)): if check_if_subinteract(func): # Hack interclass = func interclass.static_plot(fnum=self.fnum, pnum=pnum) elif hasattr(func, 'plot'): inter = func inter.plot(fnum=self.fnum, pnum=pnum) else: try: func(fnum=self.fnum, pnum=pnum) except Exception as ex: ut.printex(ex, 'failed plotting', keys=['func', 'fnum', 'pnum']) raise ax = pt.gca() pt.set_plotdat(ax, 'plot_func', func) pt.set_plotdat(ax, 'expandable_index', index) # if self.interactive is None or self.interactive: # ih.connect_callback(fig, 'button_press_event', self.onclick) self.connect_callbacks() self.fig = fig return fig
def _plot_index(self, index, _vizkw): gpath = self.gpath_list[index] if ut.is_funclike(gpath): showfunc = gpath # HACK # override of plot image function showfunc(**_vizkw) import wbia.plottool as pt ax = pt.gca() else: if isinstance(gpath, six.string_types): img = vt.imread(gpath) else: img = gpath bbox_list = self.bboxes_list[index] # print('bbox_list %r in display for px: %r ' % (bbox_list, px)) theta_list = self.thetas_list[index] label_list = [ix + 1 for ix in range(len(bbox_list))] # Add true values for every bbox to display sel_list = [True for ix in range(len(bbox_list))] _vizkw.update( { # title should always be the image number 'title': str(index), 'bbox_list': bbox_list, 'theta_list': theta_list, 'sel_list': sel_list, 'label_list': label_list, } ) # print(utool.repr2(_vizkw)) # print('vizkw = ' + utool.repr2(_vizkw)) _, ax = viz_image2.show_image(img, **_vizkw) if self.xlabel_list is not None: import wbia.plottool as pt pt.set_xlabel(self.xlabel_list[index]) # print(index) ph.set_plotdat(ax, 'bbox_list', bbox_list) ph.set_plotdat(ax, 'gpath', gpath) return ax
def draw_junction_tree(model, fnum=None, **kwargs): import wbia.plottool as pt fnum = pt.ensure_fnum(fnum) pt.figure(fnum=fnum) ax = pt.gca() from pgmpy.models import JunctionTree if not isinstance(model, JunctionTree): netx_graph = model.to_junction_tree() else: netx_graph = model # prettify nodes def fixtupkeys(dict_): return { ', '.join(k) if isinstance(k, tuple) else k: fixtupkeys(v) for k, v in dict_.items() } n = fixtupkeys(netx_graph.nodes) e = fixtupkeys(netx_graph.edge) a = fixtupkeys(netx_graph.adj) netx_graph.nodes = n netx_graph.edge = e netx_graph.adj = a # netx_graph = model.to_markov_model() # pos = nx.nx_agraph.pygraphviz_layout(netx_graph) # pos = nx.nx_agraph.graphviz_layout(netx_graph) pos = nx.pydot_layout(netx_graph) node_color = [pt.NEUTRAL] * len(pos) drawkw = dict(pos=pos, ax=ax, with_labels=True, node_color=node_color, node_size=2000) nx.draw(netx_graph, **drawkw) if kwargs.get('show_title', True): pt.set_figtitle('Junction / Clique Tree / Cluster Graph')
def annotate_matches3( ibs, aid_list, bbox_list, offset_list, name_fm_list, name_fs_list, qreq_=None, **kwargs ): """ TODO: use this as the main function. """ # TODO Use this function when you clean show_matches in_image = kwargs.get('in_image', False) # show_query = kwargs.get('show_query', True) draw_border = kwargs.get('draw_border', True) draw_lbl = kwargs.get('draw_lbl', True) notitle = kwargs.get('notitle', False) # List of annotation scores for each annot in the name # printDBG('[viz] annotate_matches3()') # truth = ibs.get_match_truth(aid1, aid2) # name_equality = ( # np.array(ibs.get_annot_nids(aid_list[1:])) == ibs.get_annot_nids(aid_list[0]) # ).tolist() # truth = 1 if all(name_equality) else (2 if any(name_equality) else 0) # truth_color = vh.get_truth_color(truth) # # Build title # score = kwargs.pop('score', None) # rawscore = kwargs.pop('rawscore', None) # aid2_raw_rank = kwargs.pop('aid2_raw_rank', None) # logger.info(kwargs) # title = vh.get_query_text(ibs, None, aid2, truth, qaid=aid1, **kwargs) # Build xlbl ax = pt.gca() ph.set_plotdat(ax, 'viztype', 'multi_match') ph.set_plotdat(ax, 'qaid', aid_list[0]) ph.set_plotdat(ax, 'num_matches', len(aid_list) - 1) ph.set_plotdat(ax, 'aid_list', aid_list[1:]) for count, aid in enumerate(aid_list, start=1): ph.set_plotdat(ax, 'aid%d' % (count,), aid) # name_equality = (ibs.get_annot_nids(aid_list[0]) == # np.array(ibs.get_annot_nids(aid_list[1:]))) # truth = 1 if np.all(name_equality) else (2 if np.any(name_equality) else 0) truth = get_multitruth(ibs, aid_list) if any(ibs.is_aid_unknown(aid_list[1:])) or ibs.is_aid_unknown(aid_list[0]): truth = ibs.const.EVIDENCE_DECISION.UNKNOWN truth_color = vh.get_truth_color(truth) name_annot_scores = kwargs.get('name_annot_scores', None) if len(aid_list) == 2: # HACK; generalize to multple annots title = vh.get_query_text( ibs, None, aid_list[1], truth, qaid=aid_list[0], **kwargs ) if not notitle: pt.set_title(title, ax) if draw_lbl: # Build labels nid_list = ibs.get_annot_nids(aid_list, distinguish_unknowns=False) name_list = ibs.get_annot_names(aid_list) lbls_list = [[] for _ in range(len(aid_list))] if kwargs.get('show_name', False): for count, (lbls, name) in enumerate(zip(lbls_list, name_list)): lbls.append(ut.repr2((name))) if kwargs.get('show_nid', True): for count, (lbls, nid) in enumerate(zip(lbls_list, nid_list)): # only label the first two images with nids LABEL_ALL_NIDS = False if count <= 1 or LABEL_ALL_NIDS: # lbls.append(vh.get_nidstrs(nid)) lbls.append(('q' if count == 0 else '') + vh.get_nidstrs(nid)) if kwargs.get('show_aid', True): for count, (lbls, aid) in enumerate(zip(lbls_list, aid_list)): lbls.append(('q' if count == 0 else '') + vh.get_aidstrs(aid)) if kwargs.get('show_annot_score', True) and name_annot_scores is not None: max_digits = kwargs.get('score_precision', None) for (lbls, score) in zip(lbls_list[1:], name_annot_scores): lbls.append(ut.num_fmt(score, max_digits=max_digits)) lbl_list = [' : '.join(lbls) for lbls in lbls_list] else: lbl_list = [None] * len(aid_list) # Plot annotations over images if in_image: in_image_bbox_list = vh.get_bboxes(ibs, aid_list, offset_list) in_image_theta_list = ibs.get_annot_thetas(aid_list) # HACK! # if show_query: # pt.draw_bbox(bbox1, bbox_color=pt.ORANGE, lbl=lbl1, theta=theta1) bbox_color = pt.ORANGE bbox_color = truth_color if draw_border else pt.ORANGE for bbox, theta, lbl in zip(in_image_bbox_list, in_image_theta_list, lbl_list): pt.draw_bbox(bbox, bbox_color=bbox_color, lbl=lbl, theta=theta) pass else: xy, w, h = pt.get_axis_xy_width_height(ax) if draw_border: pt.draw_border(ax, color=truth_color, lw=4) if draw_lbl: # Custom user lbl for chips 1 and 2 for bbox, lbl in zip(bbox_list, lbl_list): (x, y, w, h) = bbox pt.absolute_lbl(x + w, y, lbl) # No matches draw a red box if True: no_matches = name_fm_list is None or all( [True if fm is None else len(fm) == 0 for fm in name_fm_list] ) if no_matches: xy, w, h = pt.get_axis_xy_width_height(ax) # axes_bbox = (xy[0], xy[1], w, h) if draw_border: pass
def _dev_iters_until_threshold(): """ INTERACTIVE DEVELOPMENT FUNCTION How many iterations of ewma until you hit the poisson / biniomal threshold This establishes a principled way to choose the threshold for the refresh criterion in my thesis. There are paramters --- moving parts --- that we need to work with: `a` the patience, `s` the span, and `mu` our ewma. `s` is a span paramter indicating how far we look back. `mu` is the average number of label-changing reviews in roughly the last `s` manual decisions. These numbers are used to estimate the probability that any of the next `a` manual decisions will be label-chanigng. When that probability falls below a threshold we terminate. The goal is to choose `a`, `s`, and the threshold `t`, such that the probability will fall below the threshold after a maximum of `a` consecutive non-label-chaning reviews. IE we want to tie the patience paramter (how far we look ahead) to how far we actually are willing to go. """ import numpy as np import utool as ut import sympy as sym i = sym.symbols('i', integer=True, nonnegative=True, finite=True) # mu_i = sym.symbols('mu_i', integer=True, nonnegative=True, finite=True) s = sym.symbols('s', integer=True, nonnegative=True, finite=True) # NOQA thresh = sym.symbols('tau', real=True, nonnegative=True, finite=True) # NOQA alpha = sym.symbols('alpha', real=True, nonnegative=True, finite=True) # NOQA c_alpha = sym.symbols('c_alpha', real=True, nonnegative=True, finite=True) # patience a = sym.symbols('a', real=True, nonnegative=True, finite=True) available_subs = { a: 20, s: a, alpha: 2 / (s + 1), c_alpha: (1 - alpha), } def subs(expr, d=available_subs): """ recursive expression substitution """ expr1 = expr.subs(d) if expr == expr1: return expr1 else: return subs(expr1, d=d) # mu is either the support for the poisson distribution # or is is the p in the binomial distribution # It is updated at timestep i based on ewma, assuming each incoming responce is 0 mu_0 = 1.0 mu_i = c_alpha ** i # Estimate probability that any event will happen in the next `a` reviews # at time `i`. poisson_i = 1 - sym.exp(-mu_i * a) binom_i = 1 - (1 - mu_i) ** a # Expand probabilities to be a function of i, s, and a part = ut.delete_dict_keys(available_subs.copy(), [a, s]) mu_i = subs(mu_i, d=part) poisson_i = subs(poisson_i, d=part) binom_i = subs(binom_i, d=part) if True: # ewma of mu at time i if review is always not label-changing (meaningful) mu_1 = c_alpha * mu_0 # NOQA mu_2 = c_alpha * mu_1 # NOQA if True: i_vals = np.arange(0, 100) mu_vals = np.array([subs(mu_i).subs({i: i_}).evalf() for i_ in i_vals]) # NOQA binom_vals = np.array( [subs(binom_i).subs({i: i_}).evalf() for i_ in i_vals] ) # NOQA poisson_vals = np.array( [subs(poisson_i).subs({i: i_}).evalf() for i_ in i_vals] ) # NOQA # Find how many iters it actually takes my expt to terminate thesis_draft_thresh = np.exp(-2) np.where(mu_vals < thesis_draft_thresh)[0] np.where(binom_vals < thesis_draft_thresh)[0] np.where(poisson_vals < thesis_draft_thresh)[0] sym.pprint(sym.simplify(mu_i)) sym.pprint(sym.simplify(binom_i)) sym.pprint(sym.simplify(poisson_i)) # Find the thresholds that force termination after `a` reviews have passed # do this by setting i=a poisson_thresh = poisson_i.subs({i: a}) binom_thresh = binom_i.subs({i: a}) logger.info('Poisson thresh') logger.info(sym.latex(sym.Eq(thresh, poisson_thresh))) logger.info(sym.latex(sym.Eq(thresh, sym.simplify(poisson_thresh)))) poisson_thresh.subs({a: 115, s: 30}).evalf() sym.pprint(sym.Eq(thresh, poisson_thresh)) sym.pprint(sym.Eq(thresh, sym.simplify(poisson_thresh))) logger.info('Binomial thresh') sym.pprint(sym.simplify(binom_thresh)) sym.pprint(sym.simplify(poisson_thresh.subs({s: a}))) def taud(coeff): return coeff * 360 if 'poisson_cache' not in vars(): poisson_cache = {} binom_cache = {} S, A = np.meshgrid(np.arange(1, 150, 1), np.arange(0, 150, 1)) import wbia.plottool as pt SA_coords = list(zip(S.ravel(), A.ravel())) for sval, aval in ut.ProgIter(SA_coords): if (sval, aval) not in poisson_cache: poisson_cache[(sval, aval)] = float( poisson_thresh.subs({a: aval, s: sval}).evalf() ) poisson_zdata = np.array( [poisson_cache[(sval, aval)] for sval, aval in SA_coords] ).reshape(A.shape) fig = pt.figure(fnum=1, doclf=True) pt.gca().set_axis_off() pt.plot_surface3d( S, A, poisson_zdata, xlabel='s', ylabel='a', rstride=3, cstride=3, zlabel='poisson', mode='wire', contour=True, title='poisson3d', ) pt.gca().set_zlim(0, 1) pt.gca().view_init(elev=taud(1 / 16), azim=taud(5 / 8)) fig.set_size_inches(10, 6) fig.savefig( 'a-s-t-poisson3d.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True), ) for sval, aval in ut.ProgIter(SA_coords): if (sval, aval) not in binom_cache: binom_cache[(sval, aval)] = float( binom_thresh.subs({a: aval, s: sval}).evalf() ) binom_zdata = np.array( [binom_cache[(sval, aval)] for sval, aval in SA_coords] ).reshape(A.shape) fig = pt.figure(fnum=2, doclf=True) pt.gca().set_axis_off() pt.plot_surface3d( S, A, binom_zdata, xlabel='s', ylabel='a', rstride=3, cstride=3, zlabel='binom', mode='wire', contour=True, title='binom3d', ) pt.gca().set_zlim(0, 1) pt.gca().view_init(elev=taud(1 / 16), azim=taud(5 / 8)) fig.set_size_inches(10, 6) fig.savefig( 'a-s-t-binom3d.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True), ) # Find point on the surface that achieves a reasonable threshold # Sympy can't solve this # sym.solve(sym.Eq(binom_thresh.subs({s: 50}), .05)) # sym.solve(sym.Eq(poisson_thresh.subs({s: 50}), .05)) # Find a numerical solution def solve_numeric(expr, target, want, fixed, method=None, bounds=None): """ Args: expr (Expr): symbolic expression target (float): numberic value fixed (dict): fixed values of the symbol expr = poisson_thresh expr.free_symbols fixed = {s: 10} solve_numeric(poisson_thresh, .05, {s: 30}, method=None) solve_numeric(poisson_thresh, .05, {s: 30}, method='Nelder-Mead') solve_numeric(poisson_thresh, .05, {s: 30}, method='BFGS') """ import scipy.optimize # Find the symbol you want to solve for want_symbols = expr.free_symbols - set(fixed.keys()) # TODO: can probably extend this to multiple params assert len(want_symbols) == 1, 'specify all but one var' assert want == list(want_symbols)[0] fixed_expr = expr.subs(fixed) def func(a1): expr_value = float(fixed_expr.subs({want: a1}).evalf()) return (expr_value - target) ** 2 # if method is None: # method = 'Nelder-Mead' # method = 'Newton-CG' # method = 'BFGS' # Use one of the other params the startin gpoing a1 = list(fixed.values())[0] result = scipy.optimize.minimize(func, x0=a1, method=method, bounds=bounds) if not result.success: logger.info('\n') logger.info(result) logger.info('\n') return result # Numeric measurments of thie line thresh_vals = [0.001, 0.01, 0.05, 0.1, 0.135] svals = np.arange(1, 100) target_poisson_plots = {} for target in ut.ProgIter(thresh_vals, bs=False, freq=1): poisson_avals = [] for sval in ut.ProgIter(svals, 'poisson', freq=1): expr = poisson_thresh fixed = {s: sval} want = a aval = solve_numeric(expr, target, want, fixed, method='Nelder-Mead').x[0] poisson_avals.append(aval) target_poisson_plots[target] = (svals, poisson_avals) fig = pt.figure(fnum=3) for target, dat in target_poisson_plots.items(): pt.plt.plot(*dat, label='prob={}'.format(target)) pt.gca().set_xlabel('s') pt.gca().set_ylabel('a') pt.legend() pt.gca().set_title('poisson') fig.set_size_inches(5, 3) fig.savefig( 'a-vs-s-poisson.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True), ) target_binom_plots = {} for target in ut.ProgIter(thresh_vals, bs=False, freq=1): binom_avals = [] for sval in ut.ProgIter(svals, 'binom', freq=1): aval = solve_numeric( binom_thresh, target, a, {s: sval}, method='Nelder-Mead' ).x[0] binom_avals.append(aval) target_binom_plots[target] = (svals, binom_avals) fig = pt.figure(fnum=4) for target, dat in target_binom_plots.items(): pt.plt.plot(*dat, label='prob={}'.format(target)) pt.gca().set_xlabel('s') pt.gca().set_ylabel('a') pt.legend() pt.gca().set_title('binom') fig.set_size_inches(5, 3) fig.savefig( 'a-vs-s-binom.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True), ) # ---- if True: fig = pt.figure(fnum=5, doclf=True) s_vals = [1, 2, 3, 10, 20, 30, 40, 50] for sval in s_vals: pp = poisson_thresh.subs({s: sval}) a_vals = np.arange(0, 200) pp_vals = np.array( [float(pp.subs({a: aval}).evalf()) for aval in a_vals] ) # NOQA pt.plot(a_vals, pp_vals, label='s=%r' % (sval,)) pt.legend() pt.gca().set_xlabel('a') pt.gca().set_ylabel('poisson prob after a reviews') fig.set_size_inches(5, 3) fig.savefig( 'a-vs-thresh-poisson.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True), ) fig = pt.figure(fnum=6, doclf=True) s_vals = [1, 2, 3, 10, 20, 30, 40, 50] for sval in s_vals: pp = binom_thresh.subs({s: sval}) a_vals = np.arange(0, 200) pp_vals = np.array( [float(pp.subs({a: aval}).evalf()) for aval in a_vals] ) # NOQA pt.plot(a_vals, pp_vals, label='s=%r' % (sval,)) pt.legend() pt.gca().set_xlabel('a') pt.gca().set_ylabel('binom prob after a reviews') fig.set_size_inches(5, 3) fig.savefig( 'a-vs-thresh-binom.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True), ) # ------- fig = pt.figure(fnum=5, doclf=True) a_vals = [1, 2, 3, 10, 20, 30, 40, 50] for aval in a_vals: pp = poisson_thresh.subs({a: aval}) s_vals = np.arange(1, 200) pp_vals = np.array( [float(pp.subs({s: sval}).evalf()) for sval in s_vals] ) # NOQA pt.plot(s_vals, pp_vals, label='a=%r' % (aval,)) pt.legend() pt.gca().set_xlabel('s') pt.gca().set_ylabel('poisson prob') fig.set_size_inches(5, 3) fig.savefig( 's-vs-thresh-poisson.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True), ) fig = pt.figure(fnum=5, doclf=True) a_vals = [1, 2, 3, 10, 20, 30, 40, 50] for aval in a_vals: pp = binom_thresh.subs({a: aval}) s_vals = np.arange(1, 200) pp_vals = np.array( [float(pp.subs({s: sval}).evalf()) for sval in s_vals] ) # NOQA pt.plot(s_vals, pp_vals, label='a=%r' % (aval,)) pt.legend() pt.gca().set_xlabel('s') pt.gca().set_ylabel('binom prob') fig.set_size_inches(5, 3) fig.savefig( 's-vs-thresh-binom.png', dpi=300, bbox_inches=pt.extract_axes_extents(fig, combine=True), ) # --------------------- # Plot out a table mu_i.subs({s: 75, a: 75}).evalf() poisson_thresh.subs({s: 75, a: 75}).evalf() sval = 50 for target, dat in target_poisson_plots.items(): slope = np.median(np.diff(dat[1])) aval = int(np.ceil(sval * slope)) thresh = float(poisson_thresh.subs({s: sval, a: aval}).evalf()) logger.info( 'aval={}, sval={}, thresh={}, target={}'.format(aval, sval, thresh, target) ) for target, dat in target_binom_plots.items(): slope = np.median(np.diff(dat[1])) aval = int(np.ceil(sval * slope))
def show_model(model, evidence={}, soft_evidence={}, **kwargs): """ References: http://stackoverflow.com/questions/22207802/pygraphviz-networkx-set-node-level-or-layer Ignore: pkg-config --libs-only-L libcgraph sudo apt-get install libgraphviz-dev -y sudo apt-get install libgraphviz4 -y # sudo apt-get install pkg-config sudo apt-get install libgraphviz-dev # pip install git+git://github.com/pygraphviz/pygraphviz.git pip install pygraphviz python -c "import pygraphviz; print(pygraphviz.__file__)" sudo pip3 install pygraphviz --install-option="--include-path=/usr/include/graphviz" --install-option="--library-path=/usr/lib/graphviz/" python3 -c "import pygraphviz; print(pygraphviz.__file__)" CommandLine: python -m wbia.algo.hots.bayes --exec-show_model --show Example: >>> # DISABLE_DOCTEST >>> from wbia.algo.hots.bayes import * # NOQA >>> model = '?' >>> evidence = {} >>> soft_evidence = {} >>> result = show_model(model, evidence, soft_evidence) >>> print(result) >>> ut.quit_if_noshow() >>> import wbia.plottool as pt >>> ut.show_if_requested() """ if ut.get_argval('--hackmarkov') or ut.get_argval('--hackjunc'): draw_tree_model(model, **kwargs) return import wbia.plottool as pt import networkx as netx fnum = pt.ensure_fnum(None) netx_graph = model # netx_graph.graph.setdefault('graph', {})['size'] = '"10,5"' # netx_graph.graph.setdefault('graph', {})['rankdir'] = 'LR' pos_dict = get_hacked_pos(netx_graph) # pos_dict = netx.nx_agraph.pygraphviz_layout(netx_graph) # pos = netx.nx_agraph.nx_pydot.pydot_layout(netx_graph, prog='dot') # pos_dict = netx.nx_agraph.graphviz_layout(netx_graph) textprops = { 'family': 'monospace', 'horizontalalignment': 'left', # 'horizontalalignment': 'center', # 'size': 12, 'size': 8, } netx_nodes = model.nodes(data=True) node_key_list = ut.get_list_column(netx_nodes, 0) pos_list = ut.dict_take(pos_dict, node_key_list) var2_post = {f.variables[0]: f for f in kwargs.get('factor_list', [])} prior_text = None post_text = None evidence_tas = [] post_tas = [] prior_tas = [] node_color = [] has_inferred = evidence or var2_post if has_inferred: ignore_prior_with_ttype = [SCORE_TTYPE, MATCH_TTYPE] show_prior = False else: ignore_prior_with_ttype = [] # show_prior = True show_prior = False dpy = 5 dbx, dby = (20, 20) takw1 = { 'bbox_align': (0.5, 0), 'pos_offset': [0, dpy], 'bbox_offset': [dbx, dby] } takw2 = { 'bbox_align': (0.5, 1), 'pos_offset': [0, -dpy], 'bbox_offset': [-dbx, -dby] } name_colors = pt.distinct_colors(max(model.num_names, 10)) name_colors = name_colors[:model.num_names] # cmap_ = 'hot' #mx = 0.65 #mn = 0.15 cmap_, mn, mx = 'plasma', 0.15, 1.0 _cmap = pt.plt.get_cmap(cmap_) def cmap(x): return _cmap((x * mx) + mn) for node, pos in zip(netx_nodes, pos_list): variable = node[0] cpd = model.var2_cpd[variable] prior_marg = (cpd if cpd.evidence is None else cpd.marginalize( cpd.evidence, inplace=False)) show_evidence = variable in evidence show_prior = cpd.ttype not in ignore_prior_with_ttype show_post = variable in var2_post show_prior |= cpd.ttype not in ignore_prior_with_ttype post_marg = None if show_post: post_marg = var2_post[variable] def get_name_color(phi): order = phi.values.argsort()[::-1] if len(order) < 2: dist_next = phi.values[order[0]] else: dist_next = phi.values[order[0]] - phi.values[order[1]] dist_total = phi.values[order[0]] confidence = (dist_total * dist_next)**(2.5 / 4) # logger.info('confidence = %r' % (confidence,)) color = name_colors[order[0]] color = pt.color_funcs.desaturate_rgb(color, 1 - confidence) color = np.array(color) return color if variable in evidence: if cpd.ttype == SCORE_TTYPE: cmap_index = evidence[variable] / (cpd.variable_card - 1) color = cmap(cmap_index) color = pt.lighten_rgb(color, 0.4) color = np.array(color) node_color.append(color) elif cpd.ttype == NAME_TTYPE: color = name_colors[evidence[variable]] color = np.array(color) node_color.append(color) else: color = pt.FALSE_RED node_color.append(color) # elif variable in soft_evidence: # color = pt.LIGHT_PINK # show_prior = True # color = get_name_color(prior_marg) # node_color.append(color) else: if cpd.ttype == NAME_TTYPE and post_marg is not None: color = get_name_color(post_marg) node_color.append(color) elif cpd.ttype == MATCH_TTYPE and post_marg is not None: color = cmap(post_marg.values[1]) color = pt.lighten_rgb(color, 0.4) color = np.array(color) node_color.append(color) else: # color = pt.WHITE color = pt.NEUTRAL node_color.append(color) if show_prior: if variable in soft_evidence: prior_color = pt.LIGHT_PINK else: prior_color = None prior_text = pgm_ext.make_factor_text(prior_marg, 'prior') prior_tas.append( dict(text=prior_text, pos=pos, color=prior_color, **takw2)) if show_evidence: _takw1 = takw1 if cpd.ttype == SCORE_TTYPE: _takw1 = takw2 evidence_text = cpd.variable_statenames[evidence[variable]] if isinstance(evidence_text, int): evidence_text = '%d/%d' % (evidence_text + 1, cpd.variable_card) evidence_tas.append( dict(text=evidence_text, pos=pos, color=color, **_takw1)) if show_post: _takw1 = takw1 if cpd.ttype == MATCH_TTYPE: _takw1 = takw2 post_text = pgm_ext.make_factor_text(post_marg, 'post') post_tas.append(dict(text=post_text, pos=pos, color=None, **_takw1)) def trnps_(dict_list): """ tranpose dict list """ list_dict = ut.ddict(list) for dict_ in dict_list: for key, val in dict_.items(): list_dict[key + '_list'].append(val) return list_dict takw1_ = trnps_(post_tas + evidence_tas) takw2_ = trnps_(prior_tas) # Draw graph if has_inferred: pnum1 = (3, 1, (slice(0, 2), 0)) else: pnum1 = None fig = pt.figure(fnum=fnum, pnum=pnum1, doclf=True) # NOQA ax = pt.gca() # logger.info('node_color = %s' % (ut.repr3(node_color),)) drawkw = dict(pos=pos_dict, ax=ax, with_labels=True, node_size=1500, node_color=node_color) netx.draw(netx_graph, **drawkw) hacks = [] if len(post_tas + evidence_tas): hacks.append(pt.draw_text_annotations(textprops=textprops, **takw1_)) if prior_tas: hacks.append(pt.draw_text_annotations(textprops=textprops, **takw2_)) xmin, ymin = np.array(pos_list).min(axis=0) xmax, ymax = np.array(pos_list).max(axis=0) num_annots = len(model.ttype2_cpds[NAME_TTYPE]) if num_annots > 4: ax.set_xlim((xmin - 40, xmax + 40)) ax.set_ylim((ymin - 50, ymax + 50)) fig.set_size_inches(30, 7) else: ax.set_xlim((xmin - 42, xmax + 42)) ax.set_ylim((ymin - 50, ymax + 50)) fig.set_size_inches(23, 7) fig = pt.gcf() title = 'num_names=%r, num_annots=%r' % ( model.num_names, num_annots, ) map_assign = kwargs.get('map_assign', None) top_assignments = kwargs.get('top_assignments', None) if top_assignments is not None: map_assign, map_prob = top_assignments[0] if map_assign is not None: def word_insert(text): return '' if len(text) == 0 else text + ' ' title += '\n%sMAP: ' % (word_insert(kwargs.get('method', ''))) title += map_assign + ' @' + '%.2f%%' % (100 * map_prob, ) if kwargs.get('show_title', True): pt.set_figtitle(title, size=14) for hack in hacks: hack() # Hack in colorbars if has_inferred: pt.colorbar( np.linspace(0, 1, len(name_colors)), name_colors, lbl=NAME_TTYPE, ticklabels=model.ttype2_template[NAME_TTYPE].basis, ticklocation='left', ) basis = model.ttype2_template[SCORE_TTYPE].basis scalars = np.linspace(0, 1, len(basis)) scalars = np.linspace(0, 1, 100) colors = pt.scores_to_color(scalars, cmap_=cmap_, reverse_cmap=False, cmap_range=(mn, mx)) colors = [pt.lighten_rgb(c, 0.4) for c in colors] if ut.list_type(basis) is int: pt.colorbar(scalars, colors, lbl=SCORE_TTYPE, ticklabels=np.array(basis) + 1) else: pt.colorbar(scalars, colors, lbl=SCORE_TTYPE, ticklabels=basis) # logger.info('basis = %r' % (basis,)) # Draw probability hist if has_inferred and top_assignments is not None: bin_labels = ut.get_list_column(top_assignments, 0) bin_vals = ut.get_list_column(top_assignments, 1) # bin_labels = ['\n'.join(ut.textwrap.wrap(_lbl, width=30)) for _lbl in bin_labels] pt.draw_histogram( bin_labels, bin_vals, fnum=fnum, pnum=(3, 8, (2, slice(4, None))), transpose=True, use_darkbackground=False, # xtick_rotation=-10, ylabel='Prob', xlabel='assignment', ) pt.set_title('Assignment probabilities')
def show_graph(infr, title, final=False, selected_edges=None): if not VISUALIZE: return # TODO: rich colored text? latest = '\n'.join(infr.latest_logs()) showkw = dict( # fontsize=infr.graph.graph['fontsize'], # fontname=infr.graph.graph['fontname'], show_unreviewed_edges=True, show_inferred_same=False, show_inferred_diff=False, outof=(len(infr.aids)), # show_inferred_same=True, # show_inferred_diff=True, selected_edges=selected_edges, show_labels=True, simple_labels=True, # show_recent_review=not final, show_recent_review=False, # splines=infr.graph.graph['splines'], reposition=False, # with_colorbar=True ) verbose = infr.verbose infr.verbose = 0 infr_ = infr.copy() infr_ = infr infr_.verbose = verbose infr_.show(pickable=True, verbose=0, **showkw) infr.verbose = verbose # logger.info('status ' + ut.repr4(infr_.status())) # infr.show(**showkw) ax = pt.gca() pt.set_title(title, fontsize=20) fig = pt.gcf() fontsize = 22 if True: # postprocess xlabel lines = [] for line in latest.split('\n'): if False and line.startswith('ORACLE ERROR'): lines += ['ORACLE ERROR'] else: lines += [line] latest = '\n'.join(lines) if len(lines) > 10: fontsize = 16 if len(lines) > 12: fontsize = 14 if len(lines) > 14: fontsize = 12 if len(lines) > 18: fontsize = 10 if len(lines) > 23: fontsize = 8 if True: pt.adjust_subplots(top=0.95, left=0, right=1, bottom=0.45, fig=fig) ax.set_xlabel('\n' + latest) xlabel = ax.get_xaxis().get_label() xlabel.set_horizontalalignment('left') # xlabel.set_x(.025) xlabel.set_x(-0.6) # xlabel.set_fontname('CMU Typewriter Text') xlabel.set_fontname('Inconsolata') xlabel.set_fontsize(fontsize) ax.set_aspect('equal') # ax.xaxis.label.set_color('red') from os.path import join fpath = join(dpath, 'demo_{:04d}.png'.format(next(fig_counter))) fig.savefig( fpath, dpi=300, # transparent=True, edgecolor='none', ) # pt.save_figure(dpath=dpath, dpi=300) infr.latest_logs()
def plot_chip(self, aid, nRows, nCols, px, fulldraw=True, **kwargs): """ Plots an individual chip in a subaxis """ ibs = self.ibs if aid in [self.aid1, self.aid2]: # Bold color for the matching chips lw = 5 text_color = np.array((135, 206, 235, 255)) / 255.0 else: lw = 2 text_color = None pnum = (nRows, nCols, px) if not fulldraw: # not doing full draw so we have to clear any axes # that are here already manually ax = self.fig.add_subplot(*pnum) self.clear_parent_axes(ax) # ut.embed() # logger.info(subax) viz_chip_kw = { 'fnum': self.fnum, 'pnum': pnum, 'nokpts': True, 'show_name': True, 'show_gname': False, 'show_aidstr': True, 'notitle': True, 'show_num_gt': False, 'text_color': text_color, } if False and ut.is_developer(): enable_chip_title_prefix = True viz_chip_kw.update({ 'enable_chip_title_prefix': enable_chip_title_prefix, 'show_name': True, 'show_aidstr': True, 'show_viewcode': True, 'show_num_gt': True, 'show_quality_text': True, }) viz_chip.show_chip(ibs, aid, **viz_chip_kw) ax = pt.gca() pt.draw_border(ax, color=kwargs.get('color'), lw=lw) if kwargs.get('make_buttons', True): # divider = pt.ensure_divider(ax) butkw = { # 'divider': divider, 'ax': ax, 'size': '13%' # 'size': '15%' } # Chip matching/naming options nid = ibs.get_annot_name_rowids(aid) annotation_unknown = ibs.is_nid_unknown([nid])[0] if not annotation_unknown: # remove name callback = functools.partial(self.unname_annotation, aid) self.append_button( 'remove name (' + ibs.get_name_texts(nid) + ')', callback=callback, **butkw, ) else: # new name callback = functools.partial(self.mark_annotation_as_new_name, aid) self.append_button('mark as new name', callback=callback, **butkw) if (nid != self.nid2 and not ibs.is_nid_unknown([self.nid2])[0] and not self.is_split_case): # match to nid2 callback = functools.partial(self.rename_annotation, aid, self.nid2) text = 'match to name2: ' + ibs.get_name_texts(self.nid2) self.append_button(text, callback=callback, **butkw) if nid != self.nid1 and not ibs.is_nid_unknown([self.nid1])[0]: # match to nid1 callback = functools.partial(self.rename_annotation, aid, self.nid1) text = 'match to name1: ' + ibs.get_name_texts(self.nid1) self.append_button(text, callback=callback, **butkw) other_nid_list = self.get_other_nids() for other_nid in other_nid_list: if other_nid == nid: continue # rename nid2 callback = functools.partial(self.rename_annotation, aid, other_nid) text = 'match to: ' + ibs.get_name_texts(other_nid) self.append_button(text, callback=callback, **butkw) return ax
def plot_chip(self, aid, nRows, nCols, px, **kwargs): """ Plots an individual chip in a subaxis """ ibs = self.ibs enable_chip_title_prefix = ut.is_developer() # enable_chip_title_prefix = False if aid in self.comp_aids: score = self.cm.get_annot_scores([aid])[0] rawscore = self.cm.get_annot_scores([aid])[0] title_suf = kwargs.get('title_suffix', '') if score != rawscore: if score is None: title_suf += '\n score=____' else: title_suf += '\n score=%0.2f' % score title_suf += '\n rawscore=%0.2f' % rawscore else: title_suf = kwargs.get('title_suffix', '') if enable_chip_title_prefix: title_suf = '\n' + title_suf # nid = ibs.get_annot_name_rowids(aid) viz_chip_kw = { 'fnum': self.fnum, 'pnum': (nRows, nCols, px), 'nokpts': True, 'show_gname': False, 'show_exemplar': False, 'show_num_gt': False, 'show_gname': False, 'title_suffix': title_suf, # 'text_color': kwargs.get('color'), ### # 'show_name': False, # 'show_aidstr': False, 'enable_chip_title_prefix': enable_chip_title_prefix, 'show_name': True, 'show_aidstr': True, 'show_viewcode': True, 'show_quality_text': True, } viz_chip.show_chip(ibs, aid, **viz_chip_kw) ax = pt.gca() if kwargs.get('make_buttons', True): divider = pt.ensure_divider(ax) butkw = {'divider': divider, 'size': '13%'} self.aid2_ax = {} self.aid2_border = {} if aid in self.comp_aids: callback = partial(self.select, aid) self.append_button('Select This Animal', callback=callback, **butkw) # Hack to toggle colors if aid in self.aid_checkbox_states: # If we are selecting it, then make it green, otherwise change it back to grey if self.aid_checkbox_states[aid]: border = pt.draw_border(ax, color=(0, 1, 0), lw=4) else: border = pt.draw_border(ax, color=(0.7, 0.7, 0.7), lw=4) self.aid2_border[aid] = border else: self.aid_checkbox_states[aid] = False self.append_button('Examine', callback=partial(self.examine, aid), **butkw)
def hackshow_names(ibs, aid_list, fnum=None): r""" Args: ibs (IBEISController): wbia controller object aid_list (list): CommandLine: python -m wbia.other.dbinfo --exec-hackshow_names --show python -m wbia.other.dbinfo --exec-hackshow_names --show --db PZ_Master1 Example: >>> # DISABLE_DOCTEST >>> from wbia.other.dbinfo import * # NOQA >>> import wbia >>> ibs = wbia.opendb(defaultdb='PZ_MTEST') >>> aid_list = ibs.get_valid_aids() >>> result = hackshow_names(ibs, aid_list) >>> print(result) >>> ut.show_if_requested() """ import wbia.plottool as pt import vtool as vt grouped_aids, nid_list = ibs.group_annots_by_name(aid_list) grouped_aids = [aids for aids in grouped_aids if len(aids) > 1] unixtimes_list = ibs.unflat_map(ibs.get_annot_image_unixtimes_asfloat, grouped_aids) yaws_list = ibs.unflat_map(ibs.get_annot_yaws, grouped_aids) # markers_list = [[(1, 2, yaw * 360 / (np.pi * 2)) for yaw in yaws] for yaws in yaws_list] unixtime_list = ut.flatten(unixtimes_list) timemax = np.nanmax(unixtime_list) timemin = np.nanmin(unixtime_list) timerange = timemax - timemin unixtimes_list = [ ((unixtimes[:] - timemin) / timerange) for unixtimes in unixtimes_list ] for unixtimes in unixtimes_list: num_nan = sum(np.isnan(unixtimes)) unixtimes[np.isnan(unixtimes)] = np.linspace(-1, -0.5, num_nan) # ydata_list = [np.arange(len(aids)) for aids in grouped_aids] sortx_list = vt.argsort_groups(unixtimes_list, reverse=False) # markers_list = ut.list_ziptake(markers_list, sortx_list) yaws_list = ut.list_ziptake(yaws_list, sortx_list) ydatas_list = vt.ziptake(unixtimes_list, sortx_list) # ydatas_list = sortx_list # ydatas_list = vt.argsort_groups(unixtimes_list, reverse=False) # Sort by num members # ydatas_list = ut.take(ydatas_list, np.argsort(list(map(len, ydatas_list)))) xdatas_list = [ np.zeros(len(ydatas)) + count for count, ydatas in enumerate(ydatas_list) ] # markers = ut.flatten(markers_list) # yaws = np.array(ut.flatten(yaws_list)) y_data = np.array(ut.flatten(ydatas_list)) x_data = np.array(ut.flatten(xdatas_list)) fnum = pt.ensure_fnum(fnum) pt.figure(fnum=fnum) ax = pt.gca() # unique_yaws, groupxs = vt.group_indices(yaws) ax.scatter(x_data, y_data, color=[1, 0, 0], s=1, marker='.') # pt.draw_stems(x_data, y_data, marker=markers, setlims=True, linestyle='') pt.dark_background() ax = pt.gca() ax.set_xlim(min(x_data) - 0.1, max(x_data) + 0.1) ax.set_ylim(min(y_data) - 0.1, max(y_data) + 0.1)
def viz_netx_chipgraph( ibs, graph, fnum=None, use_image=False, layout=None, zoom=None, prog='neato', as_directed=False, augment_graph=True, layoutkw=None, framewidth=True, **kwargs, ): r""" DEPRICATE or improve Args: ibs (IBEISController): wbia controller object graph (nx.DiGraph): fnum (int): figure number(default = None) use_image (bool): (default = False) zoom (float): (default = 0.4) Returns: ?: pos CommandLine: python -m wbia --tf viz_netx_chipgraph --show Cand: wbia review_tagged_joins --save figures4/mergecase.png --figsize=15,15 --clipwhite --diskshow wbia compute_occurrence_groups --save figures4/occurgraph.png --figsize=40,40 --clipwhite --diskshow ~/code/wbia/wbia/algo/preproc/preproc_occurrence.py Example: >>> # DISABLE_DOCTEST >>> from wbia.viz.viz_graph import * # NOQA >>> import wbia >>> ibs = wbia.opendb(defaultdb='PZ_MTEST') >>> nid_list = ibs.get_valid_nids()[0:10] >>> fnum = None >>> use_image = True >>> zoom = 0.4 >>> make_name_graph_interaction(ibs, nid_list, prog='neato') >>> ut.show_if_requested() """ import wbia.plottool as pt logger.info('[viz_graph] drawing chip graph') fnum = pt.ensure_fnum(fnum) pt.figure(fnum=fnum, pnum=(1, 1, 1)) ax = pt.gca() if layout is None: layout = 'agraph' logger.info('layout = %r' % (layout, )) if use_image: ensure_node_images(ibs, graph) nx.set_node_attributes(graph, name='shape', values='rect') if layoutkw is None: layoutkw = {} layoutkw['prog'] = layoutkw.get('prog', prog) layoutkw.update(kwargs) if prog == 'neato': graph = graph.to_undirected() plotinfo = pt.show_nx( graph, ax=ax, # img_dict=img_dict, layout=layout, # hacknonode=bool(use_image), layoutkw=layoutkw, as_directed=as_directed, framewidth=framewidth, ) return plotinfo
def show_error_case(infr, aids, edge=None, error_edges=None, colorby=None, fnum=1): """ Example """ import wbia.plottool as pt if error_edges is None: # compute a minimal set of edges to minimally fix the case pass sub_infr = infr.subgraph(aids) # err_graph.add_edges_from(missing_edges) subdf = sub_infr.get_edge_dataframe() mistake_edges = [] if len(subdf) > 0: mistakes = subdf[(subdf.truth != subdf.evidence_decision) & (subdf.evidence_decision != UNREV)] mistake_edges = mistakes.index.tolist() err_edges = mistake_edges + list(error_edges) missing = [e for e in err_edges if not sub_infr.has_edge(e)] # Hack, make sure you don't reuse sub_infr.graph.add_edges_from(missing) stroke = {'linewidth': 2.5, 'foreground': sub_infr._error_color} edge_overrides = { # 'alpha': {e: .05 for e in true_negatives}, 'alpha': {}, 'style': {e: '' for e in err_edges}, 'sketch': {e: None for e in err_edges}, 'linestyle': {e: 'dashed' for e in missing}, 'linewidth': {e: 2.0 for e in err_edges + missing}, 'stroke': {e: stroke for e in err_edges + missing}, } selected_kw = { 'stroke': { 'linewidth': 5, 'foreground': sub_infr._error_color }, 'alpha': 1.0, } for k, v in selected_kw.items(): if k not in edge_overrides: edge_overrides[k] = {} edge_overrides[k][edge] = selected_kw[k] sub_infr.show_edge(edge, fnum=1, pnum=(2, 1, 2)) ax = pt.gca() xy, w, h = pt.get_axis_xy_width_height(ax=ax) nx.set_node_attributes(sub_infr.graph, name='framewidth', values=1.0) nx.set_node_attributes(sub_infr.graph, name='framealign', values='outer') nx.set_node_attributes(sub_infr.graph, name='framealpha', values=0.7) sub_infr.show_graph( fnum=fnum, pnum=(2, 1, 1), show_recent_review=False, zoomable=False, pickable=False, show_cand=False, splines='spline', simple_labels=True, colorby=colorby, use_image=True, edge_overrides=edge_overrides, # ratio=1 / abs(w / h) )
def show_time_distributions(ibs, unixtime_list): r""" """ # import vtool as vt import wbia.plottool as pt unixtime_list = np.array(unixtime_list) num_nan = np.isnan(unixtime_list).sum() num_total = len(unixtime_list) unixtime_list = unixtime_list[~np.isnan(unixtime_list)] from wbia.scripts.thesis import TMP_RC import matplotlib as mpl mpl.rcParams.update(TMP_RC) if False: from matplotlib import dates as mpldates # data_list = list(map(ut.unixtime_to_datetimeobj, unixtime_list)) n, bins, patches = pt.plt.hist(unixtime_list, 365) # n_ = list(map(ut.unixtime_to_datetimeobj, n)) # bins_ = list(map(ut.unixtime_to_datetimeobj, bins)) pt.plt.setp(patches, 'facecolor', 'g', 'alpha', 0.75) ax = pt.gca() # ax.xaxis.set_major_locator(mpldates.YearLocator()) # hfmt = mpldates.DateFormatter('%y/%m/%d') # ax.xaxis.set_major_formatter(hfmt) mpldates.num2date(unixtime_list) # pt.gcf().autofmt_xdate() # y = pt.plt.normpdf( bins, unixtime_list.mean(), unixtime_list.std()) # ax.set_xticks(bins_) # l = pt.plt.plot(bins_, y, 'k--', linewidth=1.5) else: pt.draw_time_distribution(unixtime_list) # pt.draw_histogram() ax = pt.gca() ax.set_xlabel('Date') ax.set_title( 'Timestamp distribution of %s. #nan=%d/%d' % (ibs.get_dbname_alias(), num_nan, num_total) ) pt.gcf().autofmt_xdate() icon = ibs.get_database_icon() if False and icon is not None: # import matplotlib as mpl # import vtool as vt ax = pt.gca() # Overlay a species icon # http://matplotlib.org/examples/pylab_examples/demo_annotation_box.html # icon = vt.convert_image_list_colorspace([icon], 'RGB', 'BGR')[0] # pt.overlay_icon(icon, coords=(0, 1), bbox_alignment=(0, 1)) pt.overlay_icon( icon, coords=(0, 1), bbox_alignment=(0, 1), as_artist=1, max_asize=(100, 200), ) # imagebox = mpl.offsetbox.OffsetImage(icon, zoom=1.0) # # xy = [ax.get_xlim()[0] + 5, ax.get_ylim()[1]] # # ax.set_xlim(1, 100) # # ax.set_ylim(0, 100) # # x = np.array(ax.get_xlim()).sum() / 2 # # y = np.array(ax.get_ylim()).sum() / 2 # # xy = [x, y] # # logger.info('xy = %r' % (xy,)) # # x = np.nanmin(unixtime_list) # # xy = [x, y] # # logger.info('xy = %r' % (xy,)) # # ax.get_ylim()[0]] # xy = [ax.get_xlim()[0], ax.get_ylim()[1]] # ab = mpl.offsetbox.AnnotationBbox( # imagebox, xy, xycoords='data', # xybox=(-0., 0.), # boxcoords="offset points", # box_alignment=(0, 1), pad=0.0) # ax.add_artist(ab) if ut.get_argflag('--contextadjust'): # pt.adjust_subplots(left=.08, bottom=.1, top=.9, wspace=.3, hspace=.1) pt.adjust_subplots(use_argv=True)
def do_infr_test(ccs, edges, new_edges): """ Creates a graph with `ccs` + `edges` and then adds `new_edges` """ # import networkx as nx import wbia.plottool as pt infr = demo.make_demo_infr(ccs, edges) if ut.show_was_requested(): pt.qtensure() # Preshow fnum = 1 if ut.show_was_requested(): infr.set_node_attrs('shape', 'circle') infr.show( pnum=(2, 1, 1), fnum=fnum, show_unreviewed_edges=True, show_reviewed_cuts=True, splines='spline', show_inferred_diff=True, groupby='name_label', show_labels=True, pickable=True, ) pt.set_title('pre-review') pt.gca().set_aspect('equal') infr.set_node_attrs('pin', 'true') # fig1 = pt.gcf() # fig1.canvas.mpl_connect('pick_event', ut.partial(on_pick, infr=infr)) infr1 = infr infr2 = infr.copy() for new_edge in new_edges: aid1, aid2, data = new_edge evidence_decision = data['evidence_decision'] infr2.add_feedback((aid1, aid2), evidence_decision) infr2.relabel_using_reviews(rectify=False) infr2.apply_nondynamic_update() # Postshow if ut.show_was_requested(): infr2.show( pnum=(2, 1, 2), fnum=fnum, show_unreviewed_edges=True, show_inferred_diff=True, show_labels=True, ) pt.gca().set_aspect('equal') pt.set_title('post-review') # fig2 = pt.gcf() # if fig2 is not fig1: # fig2.canvas.mpl_connect('pick_event', ut.partial(on_pick, infr=infr2)) class Checker(object): """ Asserts pre and post test properties of the graph """ def __init__(self, infr1, infr2): self._errors = [] self.infr1 = infr1 self.infr2 = infr2 def __call__(self, infr, u, v, key, val, msg): data = infr.get_nonvisual_edge_data((u, v)) if data is None: assert infr.graph.has_edge( u, v), 'uv=%r, %r does not exist' % (u, v) got = data.get(key) if got != val: msg1 = 'key=%s %r!=%r, ' % (key, got, val) errmsg = ''.join([ msg1, msg, '\nedge=', ut.repr2((u, v)), '\n', infr.repr_edge_data(data), ]) self._errors.append(errmsg) def custom_precheck(self, func): try: func(self.infr1) except AssertionError as ex: self._errors.append(str(ex)) def after(self, errors=[]): """ Delays error reporting until after visualization prints errors, then shows you the graph, then finally if any errors were discovered they are raised """ errors = errors + self._errors if errors: ut.cprint('PRINTING %d FAILURE' % (len(errors)), 'red') for msg in errors: logger.info(msg) ut.cprint('HAD %d FAILURE' % (len(errors)), 'red') if ut.show_was_requested(): pt.all_figures_tile(percent_w=0.5) ut.show_if_requested() if errors: raise AssertionError('There were errors') check = Checker(infr1, infr2) return infr1, infr2, check
def show_name_matches( ibs, qaid, name_daid_list, name_fm_list, name_fs_list, name_H1_list, name_featflag_list, qreq_=None, **kwargs ): """ Called from chip_match.py Args: ibs (IBEISController): wbia controller object qaid (int): query annotation id name_daid_list (list): name_fm_list (list): name_fs_list (list): name_H1_list (list): name_featflag_list (list): qreq_ (QueryRequest): query request object with hyper-parameters(default = None) Kwargs: draw_fmatches, name_rank, fnum, pnum, colorbar_, nonvote_mode, fastmode, show_matches, fs, fm_norm, lbl1, lbl2, rect, draw_border, cmap, H1, H2, scale_factor1, scale_factor2, draw_pts, draw_ell, draw_lines, show_nMatches, all_kpts, in_image, show_query, draw_lbl, name_annot_scores, score, rawscore, aid2_raw_rank, show_name, show_nid, show_aid, show_annot_score, show_truth, name_score, show_name_score, show_name_rank, show_timedelta CommandLine: python -m wbia.viz.viz_matches --exec-show_name_matches python -m wbia.viz.viz_matches --test-show_name_matches --show Example: >>> # DISABLE_DOCTEST >>> from wbia.viz.viz_matches import * # NOQA >>> from wbia.algo.hots import chip_match >>> from wbia.algo.hots import name_scoring >>> import vtool as vt >>> from wbia.algo.hots import _pipeline_helpers as plh # NOQA >>> import numpy as np >>> func = chip_match.ChipMatch.show_single_namematch >>> sourcecode = ut.get_func_sourcecode(func, stripdef=True, stripret=True, >>> strip_docstr=True) >>> setup = ut.regex_replace('viz_matches.show_name_matches', '#', sourcecode) >>> homog = False >>> print(ut.indent(setup, '>>> ')) >>> ibs, qreq_, cm_list = plh.testdata_post_sver('PZ_MTEST', qaid_list=[1]) >>> cm = cm_list[0] >>> cm.score_name_nsum(qreq_) >>> dnid = ibs.get_annot_nids(cm.qaid) >>> # +--- COPIED SECTION >>> locals_ = locals() >>> var_list = ut.exec_func_src( >>> func, locals_=locals_, >>> sentinal='name_annot_scores = cm.annot_score_list.take(sorted_groupxs') >>> exec(ut.execstr_dict(var_list)) >>> # L___ COPIED SECTION >>> kwargs = {} >>> show_name_matches(ibs, qaid, name_daid_list, name_fm_list, >>> name_fs_list, name_h1_list, name_featflag_list, >>> qreq_=qreq_, **kwargs) >>> ut.quit_if_noshow() >>> ut.show_if_requested() """ # logger.info("SHOW NAME MATCHES") # logger.info(ut.repr2(kwargs, nl=True)) # from wbia import constants as const from wbia import tag_funcs draw_fmatches = kwargs.pop('draw_fmatches', True) rchip1, kpts1 = get_query_annot_pair_info(ibs, qaid, qreq_, draw_fmatches) rchip2_list, kpts2_list = get_data_annot_pair_info( ibs, name_daid_list, qreq_, draw_fmatches ) heatmask = kwargs.pop('heatmask', False) if heatmask: from vtool.coverage_kpts import make_kpts_heatmask import numpy as np import vtool as vt wh1 = vt.get_size(rchip1) fx1 = np.unique(np.hstack([fm.T[0] for fm in name_fm_list])) heatmask1 = make_kpts_heatmask(kpts1[fx1], wh1) rchip1 = vt.overlay_alpha_images(heatmask1, rchip1) # Hack cast back to uint8 rchip1 = (rchip1 * 255).astype(np.uint8) rchip2_list_ = rchip2_list rchip2_list = [] for rchip2, kpts2, fm in zip(rchip2_list_, kpts2_list, name_fm_list): fx2 = fm.T[1] wh2 = vt.get_size(rchip2) heatmask2 = make_kpts_heatmask(kpts2[fx2], wh2) rchip2 = vt.overlay_alpha_images(heatmask2, rchip2) # Hack cast back to uint8 rchip2 = (rchip2 * 255).astype(np.uint8) rchip2_list.append(rchip2) # fm_list = name_fm_list fs_list = name_fs_list featflag_list = name_featflag_list offset_list, sf_list, bbox_list = show_multichip_match( rchip1, rchip2_list, kpts1, kpts2_list, fm_list, fs_list, featflag_list, **kwargs ) aid_list = [qaid] + name_daid_list annotate_matches3( ibs, aid_list, bbox_list, offset_list, name_fm_list, name_fs_list, qreq_=None, **kwargs ) ax = pt.gca() title = vh.get_query_text(ibs, None, name_daid_list, False, qaid=qaid, **kwargs) pt.set_title(title, ax) # Case tags annotmatch_rowid_list = ibs.get_annotmatch_rowid_from_superkey( [qaid] * len(name_daid_list), name_daid_list ) annotmatch_rowid_list = ut.filter_Nones(annotmatch_rowid_list) tags_list = ibs.get_annotmatch_case_tags(annotmatch_rowid_list) if not ut.get_argflag('--show'): # False: tags_list = tag_funcs.consolodate_annotmatch_tags(tags_list) tag_list = ut.unique_ordered(ut.flatten(tags_list)) name_rank = kwargs.get('name_rank', None) truth = get_multitruth(ibs, aid_list) xlabel = {1: 'Correct ID', 0: 'Incorrect ID', 2: 'Unknown ID'}[truth] if False: if name_rank is None: xlabel = {1: 'Genuine', 0: 'Imposter', 2: 'Unknown'}[truth] # xlabel = {1: 'True', 0: 'False', 2: 'Unknown'}[truth] else: if name_rank == 0: xlabel = {1: 'True Positive', 0: 'False Positive', 2: 'Unknown'}[truth] else: xlabel = {1: 'False Negative', 0: 'True Negative', 2: 'Unknown'}[truth] if len(tag_list) > 0: xlabel += '\n' + ', '.join(tag_list) noshow_truth = ut.get_argflag('--noshow_truth') if not noshow_truth: pt.set_xlabel(xlabel) return ax
def show_chip(ibs, aid, in_image=False, annote=True, title_suffix='', weight_label=None, weights=None, config2_=None, **kwargs): r"""Driver function to show chips Args: ibs (wbia.IBEISController): aid (int): annotation rowid in_image (bool): displays annotation with the context of its source image annote (bool): enables overlay annoations title_suffix (str): weight_label (None): (default = None) weights (None): (default = None) config2_ (dict): (default = None) Kwargs: enable_chip_title_prefix, nokpts, kpts_subset, kpts, text_color, notitle, draw_lbls, show_aidstr, show_gname, show_name, show_nid, show_exemplar, show_num_gt, show_quality_text, show_viewcode, fnum, title, figtitle, pnum, interpolation, cmap, heatmap, data_colorbar, darken, update, xlabel, redraw_image, ax, alpha, docla, doclf, projection, pts, ell color (3/4-tuple, ndarray, or str): colors for keypoints CommandLine: python -m wbia.viz.viz_chip show_chip --show --ecc python -c "import utool as ut; ut.print_auto_docstr('wbia.viz.viz_chip', 'show_chip')" python -m wbia.viz.viz_chip show_chip --show --db NNP_Master3 --aids 14047 --no-annote python -m wbia.viz.viz_chip show_chip --show --db NNP_Master3 --aids 14047 --no-annote python -m wbia.viz.viz_chip show_chip --show --db PZ_MTEST --aid 1 --bgmethod=cnn python -m wbia.viz.viz_chip show_chip --show --db PZ_MTEST --aid 1 --bgmethod=cnn --scale_max=30 python -m wbia.viz.viz_chip show_chip --show --db PZ_MTEST --aid 1 --ecc --draw_lbls=False --notitle --save=~/slides/lnbnn_query.jpg --dpi=300 Example: >>> # xdoctest: +REQUIRES(module:wbia_cnn) >>> # VIZ_TEST >>> from wbia.viz.viz_chip import * # NOQA >>> import numpy as np >>> import vtool as vt >>> in_image = False >>> ibs, aid_list, kwargs, config2_ = testdata_showchip() >>> aid = aid_list[0] >>> if True: >>> import matplotlib as mpl >>> from wbia.scripts.thesis import TMP_RC >>> mpl.rcParams.update(TMP_RC) >>> if ut.get_argflag('--ecc'): >>> kpts = ibs.get_annot_kpts(aid, config2_=config2_) >>> weights = ibs.get_annot_fgweights([aid], ensure=True, config2_=config2_)[0] >>> kpts = ut.random_sample(kpts[weights > .9], 200, seed=0) >>> ecc = vt.get_kpts_eccentricity(kpts) >>> scale = 1 / vt.get_scales(kpts) >>> #s = ecc if config2_.affine_invariance else scale >>> s = scale >>> colors = pt.scores_to_color(s, cmap_='jet') >>> kwargs['color'] = colors >>> kwargs['kpts'] = kpts >>> kwargs['ell_linewidth'] = 3 >>> kwargs['ell_alpha'] = .7 >>> show_chip(ibs, aid, in_image=in_image, config2_=config2_, **kwargs) >>> pt.show_if_requested() """ if ut.VERBOSE: logger.info('[viz] show_chip(aid=%r)' % (aid, )) # ibs.assert_valid_aids((aid,)) # Get chip # logger.info('in_image = %r' % (in_image,)) chip = vh.get_chips(ibs, aid, in_image=in_image, config2_=config2_) # Create chip title chip_text = vh.get_annot_texts(ibs, [aid], **kwargs)[0] if kwargs.get('enable_chip_title_prefix', True): chip_title_text = chip_text + title_suffix else: chip_title_text = title_suffix chip_title_text = chip_title_text.strip('\n') # Draw chip fig, ax = pt.imshow(chip, **kwargs) # Populate axis user data vh.set_ibsdat(ax, 'viztype', 'chip') vh.set_ibsdat(ax, 'aid', aid) if annote and not kwargs.get('nokpts', False): # Get and draw keypoints if 'color' not in kwargs: if weight_label == 'fg_weights': if weights is None and ibs.has_species_detector( ibs.get_annot_species_texts(aid)): weight_label = 'fg_weights' weights = ibs.get_annot_fgweights([aid], ensure=True, config2_=config2_)[0] if weights is not None: cmap_ = 'hot' # if weight_label == 'dstncvs': # cmap_ = 'rainbow' color = pt.scores_to_color(weights, cmap_=cmap_, reverse_cmap=False) kwargs['color'] = color kwargs['ell_color'] = color kwargs['pts_color'] = color kpts_ = vh.get_kpts( ibs, aid, in_image, config2_=config2_, kpts_subset=kwargs.get('kpts_subset', None), kpts=kwargs.pop('kpts', None), ) pt.viz_keypoints._annotate_kpts(kpts_, **kwargs) if kwargs.get('draw_lbls', True): pt.upperleft_text(chip_text, color=kwargs.get('text_color', None)) use_title = not kwargs.get('notitle', False) if use_title: pt.set_title(chip_title_text) if in_image: gid = ibs.get_annot_gids(aid) aid_list = ibs.get_image_aids(gid) annotekw = viz_image.get_annot_annotations(ibs, aid_list, sel_aids=[aid], draw_lbls=kwargs.get( 'draw_lbls', True)) # Put annotation centers in the axis ph.set_plotdat(ax, 'annotation_bbox_list', annotekw['bbox_list']) ph.set_plotdat(ax, 'aid_list', aid_list) pt.viz_image2.draw_image_overlay(ax, **annotekw) zoom_ = ut.get_argval('--zoom', type_=float, default=None) if zoom_ is not None: import vtool as vt # Zoom into the chip for some image context rotated_verts = ibs.get_annot_rotated_verts(aid) bbox = ibs.get_annot_bboxes(aid) # logger.info(bbox) # logger.info(rotated_verts) rotated_bbox = vt.bbox_from_verts(rotated_verts) imgw, imgh = ibs.get_image_sizes(gid) pad_factor = zoom_ pad_length = min(bbox[2], bbox[3]) * pad_factor minx = max(rotated_bbox[0] - pad_length, 0) miny = max(rotated_bbox[1] - pad_length, 0) maxx = min((rotated_bbox[0] + rotated_bbox[2]) + pad_length, imgw) maxy = min((rotated_bbox[1] + rotated_bbox[3]) + pad_length, imgh) # maxy = imgh - maxy # miny = imgh - miny ax = pt.gca() ax.set_xlim(minx, maxx) ax.set_ylim(miny, maxy) ax.invert_yaxis() else: ph.set_plotdat(ax, 'chipshape', chip.shape) # if 'featweights' in vars() and 'color' in kwargs: if weights is not None and weight_label is not None: # # HACK HACK HACK if len(weights) > 0: cb = pt.colorbar(weights, kwargs['color']) cb.set_label(weight_label) return fig, ax
def annotate_matches2( ibs, aid1, aid2, fm, fs, offset1=(0, 0), offset2=(0, 0), xywh2=None, # (0, 0, 0, 0), xywh1=None, # (0, 0, 0, 0), qreq_=None, **kwargs ): """ TODO: use this as the main function. """ if True: aid_list = [aid1, aid2] bbox_list = [xywh1, xywh2] offset_list = [offset1, offset2] name_fm_list = [fm] name_fs_list = [fs] return annotate_matches3( ibs, aid_list, bbox_list, offset_list, name_fm_list, name_fs_list, qreq_=qreq_, **kwargs ) else: # TODO: make sure all of this functionality is incorporated into annotate_matches3 in_image = kwargs.get('in_image', False) show_query = kwargs.get('show_query', True) draw_border = kwargs.get('draw_border', True) draw_lbl = kwargs.get('draw_lbl', True) notitle = kwargs.get('notitle', False) truth = ibs.get_match_truth(aid1, aid2) truth_color = vh.get_truth_color(truth) # Build title title = vh.get_query_text(ibs, None, aid2, truth, qaid=aid1, **kwargs) # Build xlbl ax = pt.gca() ph.set_plotdat(ax, 'viztype', 'matches') ph.set_plotdat(ax, 'qaid', aid1) ph.set_plotdat(ax, 'aid1', aid1) ph.set_plotdat(ax, 'aid2', aid2) if draw_lbl: name1, name2 = ibs.get_annot_names([aid1, aid2]) nid1, nid2 = ibs.get_annot_name_rowids( [aid1, aid2], distinguish_unknowns=False ) # lbl1 = repr(name1) + ' : ' + 'q' + vh.get_aidstrs(aid1) # lbl2 = repr(name2) + ' : ' + vh.get_aidstrs(aid2) lbl1_list = [] lbl2_list = [] if kwargs.get('show_aid', True): lbl1_list.append('q' + vh.get_aidstrs(aid1)) lbl2_list.append(vh.get_aidstrs(aid2)) if kwargs.get('show_name', True): lbl1_list.append(repr((name1))) lbl2_list.append(repr((name2))) if kwargs.get('show_nid', True): lbl1_list.append(vh.get_nidstrs(nid1)) lbl2_list.append(vh.get_nidstrs(nid2)) lbl1 = ' : '.join(lbl1_list) lbl2 = ' : '.join(lbl2_list) else: lbl1, lbl2 = None, None if vh.NO_LBL_OVERRIDE: title = '' if not notitle: pt.set_title(title, ax) # Plot annotations over images if in_image: bbox1, bbox2 = vh.get_bboxes(ibs, [aid1, aid2], [offset1, offset2]) theta1, theta2 = ibs.get_annot_thetas([aid1, aid2]) # HACK! if show_query: pt.draw_bbox(bbox1, bbox_color=pt.ORANGE, lbl=lbl1, theta=theta1) bbox_color2 = truth_color if draw_border else pt.ORANGE pt.draw_bbox(bbox2, bbox_color=bbox_color2, lbl=lbl2, theta=theta2) else: xy, w, h = pt.get_axis_xy_width_height(ax) bbox2 = (xy[0], xy[1], w, h) theta2 = 0 if xywh2 is None: # xywh2 = (xy[0], xy[1], w, h) # weird when sidebyside is off y seems to be inverted xywh2 = (0, 0, w, h) if not show_query and xywh1 is None: data_config2 = None if qreq_ is None else qreq_.extern_data_config2 # FIXME, pass data in kpts2 = ibs.get_annot_kpts([aid2], config2_=data_config2)[0] # pt.draw_kpts2(kpts2.take(fm.T[1], axis=0)) # Draw any selected matches # sm_kw = dict(rect=True, colors=pt.BLUE) pt.plot_fmatch(None, xywh2, None, kpts2, fm, fs=fs, **kwargs) if draw_border: pt.draw_border(ax, truth_color, 4, offset=offset2) if draw_lbl: # Custom user lbl for chips 1 and 2 if show_query: (x1, y1, w1, h1) = xywh1 pt.absolute_lbl(x1 + w1, y1, lbl1) (x2, y2, w2, h2) = xywh2 pt.absolute_lbl(x2 + w2, y2, lbl2) if True: # No matches draw a red box if fm is None or len(fm) == 0: if draw_border: pass
def show_model(model, evidence={}, soft_evidence={}, **kwargs): """ References: http://stackoverflow.com/questions/22207802/pygraphviz-networkx-set-node-level-or-layer Ignore: pkg-config --libs-only-L libcgraph sudo apt-get install libgraphviz-dev -y sudo apt-get install libgraphviz4 -y # sudo apt-get install pkg-config sudo apt-get install libgraphviz-dev # pip install git+git://github.com/pygraphviz/pygraphviz.git pip install pygraphviz python -c "import pygraphviz; print(pygraphviz.__file__)" sudo pip3 install pygraphviz --install-option="--include-path=/usr/include/graphviz" --install-option="--library-path=/usr/lib/graphviz/" python3 -c "import pygraphviz; print(pygraphviz.__file__)" """ if ut.get_argval('--hackmarkov') or ut.get_argval('--hackjunc'): draw_tree_model(model, **kwargs) return import wbia.plottool as pt import networkx as netx import matplotlib as mpl fnum = pt.ensure_fnum(None) fig = pt.figure(fnum=fnum, pnum=(3, 1, (slice(0, 2), 0)), doclf=True) # NOQA # fig = pt.figure(fnum=fnum, pnum=(3, 2, (1, slice(1, 2))), doclf=True) # NOQA ax = pt.gca() var2_post = {f.variables[0]: f for f in kwargs.get('factor_list', [])} netx_graph = model # netx_graph.graph.setdefault('graph', {})['size'] = '"10,5"' # netx_graph.graph.setdefault('graph', {})['rankdir'] = 'LR' pos = get_hacked_pos(netx_graph) # netx.nx_agraph.pygraphviz_layout(netx_graph) # pos = netx.nx_agraph.pydot_layout(netx_graph, prog='dot') # pos = netx.nx_agraph.graphviz_layout(netx_graph) drawkw = dict(pos=pos, ax=ax, with_labels=True, node_size=1500) if evidence is not None: node_colors = [ # (pt.TRUE_BLUE (pt.WHITE if node not in soft_evidence else pt.LIGHT_PINK) if node not in evidence else pt.FALSE_RED for node in netx_graph.nodes() ] for node in netx_graph.nodes(): cpd = model.var2_cpd[node] if cpd.ttype == 'score': pass drawkw['node_color'] = node_colors netx.draw(netx_graph, **drawkw) show_probs = True if show_probs: textprops = { 'family': 'monospace', 'horizontalalignment': 'left', #'horizontalalignment': 'center', #'size': 12, 'size': 8, } textkw = dict( xycoords='data', boxcoords='offset points', pad=0.25, framewidth=True, arrowprops=dict(arrowstyle='->'), # bboxprops=dict(fc=node_attr['fillcolor']), ) netx_nodes = model.nodes(data=True) node_key_list = ut.get_list_column(netx_nodes, 0) pos_list = ut.dict_take(pos, node_key_list) artist_list = [] offset_box_list = [] for pos_, node in zip(pos_list, netx_nodes): x, y = pos_ variable = node[0] cpd = model.var2_cpd[variable] prior_marg = (cpd if cpd.evidence is None else cpd.marginalize( cpd.evidence, inplace=False)) prior_text = None text = None if variable in evidence: text = cpd.variable_statenames[evidence[variable]] elif variable in var2_post: post_marg = var2_post[variable] text = pgm_ext.make_factor_text(post_marg, 'post') prior_text = pgm_ext.make_factor_text(prior_marg, 'prior') else: if len(evidence) == 0 and len(soft_evidence) == 0: prior_text = pgm_ext.make_factor_text(prior_marg, 'prior') show_post = kwargs.get('show_post', False) show_prior = kwargs.get('show_prior', False) show_prior = True show_post = True show_ev = evidence is not None and variable in evidence if (show_post or show_ev) and text is not None: offset_box = mpl.offsetbox.TextArea(text, textprops) artist = mpl.offsetbox.AnnotationBbox( # offset_box, (x + 5, y), xybox=(20., 5.), offset_box, (x, y + 5), xybox=(4.0, 20.0), # box_alignment=(0, 0), box_alignment=(0.5, 0), **textkw) offset_box_list.append(offset_box) artist_list.append(artist) if show_prior and prior_text is not None: offset_box2 = mpl.offsetbox.TextArea(prior_text, textprops) artist2 = mpl.offsetbox.AnnotationBbox( # offset_box2, (x - 5, y), xybox=(-20., -15.), # offset_box2, (x, y - 5), xybox=(-15., -20.), offset_box2, (x, y - 5), xybox=(-4, -20.0), # box_alignment=(1, 1), box_alignment=(0.5, 1), **textkw) offset_box_list.append(offset_box2) artist_list.append(artist2) for artist in artist_list: ax.add_artist(artist) xmin, ymin = np.array(pos_list).min(axis=0) xmax, ymax = np.array(pos_list).max(axis=0) num_annots = len(model.ttype2_cpds['name']) if num_annots > 4: ax.set_xlim((xmin - 40, xmax + 40)) ax.set_ylim((ymin - 50, ymax + 50)) fig.set_size_inches(30, 7) else: ax.set_xlim((xmin - 42, xmax + 42)) ax.set_ylim((ymin - 50, ymax + 50)) fig.set_size_inches(23, 7) fig = pt.gcf() title = 'num_names=%r, num_annots=%r' % (model.num_names, num_annots) map_assign = kwargs.get('map_assign', None) # max_marginal_list = [] # for name, marginal in marginalized_joints.items(): # states = list(ut.iprod(*marginal.statenames)) # vals = marginal.values.ravel() # x = vals.argmax() # max_marginal_list += ['P(' + ', '.join(states[x]) + ') = ' + str(vals[x])] # title += str(marginal) top_assignments = kwargs.get('top_assignments', None) if top_assignments is not None: map_assign, map_prob = top_assignments[0] if map_assign is not None: # title += '\nMAP=' + ut.repr2(map_assign, strvals=True) title += '\nMAP: ' + map_assign + ' @' + '%.2f%%' % ( 100 * map_prob, ) if kwargs.get('show_title', True): pt.set_figtitle(title, size=14) # pt.set_xlabel() def hack_fix_centeralign(): if textprops['horizontalalignment'] == 'center': logger.info('Fixing centeralign') fig = pt.gcf() fig.canvas.draw() # Superhack for centered text. Fix bug in # /usr/local/lib/python2.7/dist-packages/matplotlib/offsetbox.py # /usr/local/lib/python2.7/dist-packages/matplotlib/text.py for offset_box in offset_box_list: offset_box.set_offset z = offset_box._text.get_window_extent() (z.x1 - z.x0) / 2 offset_box._text T = offset_box._text.get_transform() A = mpl.transforms.Affine2D() A.clear() A.translate((z.x1 - z.x0) / 2, 0) offset_box._text.set_transform(T + A) hack_fix_centeralign() top_assignments = kwargs.get('top_assignments', None) if top_assignments is not None: bin_labels = ut.get_list_column(top_assignments, 0) bin_vals = ut.get_list_column(top_assignments, 1) # bin_labels = ['\n'.join(ut.textwrap.wrap(_lbl, width=30)) for _lbl in bin_labels] pt.draw_histogram( bin_labels, bin_vals, fnum=fnum, pnum=(3, 8, (2, slice(4, None))), transpose=True, use_darkbackground=False, # xtick_rotation=-10, ylabel='Prob', xlabel='assignment', ) pt.set_title('Assignment probabilities')
def show_graph( infr, graph=None, use_image=False, update_attrs=True, with_colorbar=False, pnum=(1, 1, 1), zoomable=True, pickable=False, **kwargs, ): r""" Args: infr (?): graph (None): (default = None) use_image (bool): (default = False) update_attrs (bool): (default = True) with_colorbar (bool): (default = False) pnum (tuple): plot number(default = (1, 1, 1)) zoomable (bool): (default = True) pickable (bool): (de = False) **kwargs: verbose, with_labels, fnum, layout, ax, pos, img_dict, title, layoutkw, framewidth, modify_ax, as_directed, hacknoedge, hacknode, node_labels, arrow_width, fontsize, fontweight, fontname, fontfamilty, fontproperties CommandLine: python -m wbia.algo.graph.mixin_viz GraphVisualization.show_graph --show Example: >>> # xdoctest: +REQUIRES(module:pygraphviz) >>> # ENABLE_DOCTEST >>> from wbia.algo.graph.mixin_viz import * # NOQA >>> from wbia.algo.graph import demo >>> import wbia.plottool as pt >>> infr = demo.demodata_infr(ccs=ut.estarmap( >>> range, [(1, 6), (6, 10), (10, 13), (13, 15), (15, 16), >>> (17, 20)])) >>> pnum_ = pt.make_pnum_nextgen(nRows=1, nCols=3) >>> infr.show_graph(show_cand=True, simple_labels=True, pickable=True, fnum=1, pnum=pnum_()) >>> infr.add_feedback((1, 5), INCMP) >>> infr.add_feedback((14, 18), INCMP) >>> infr.refresh_candidate_edges() >>> infr.show_graph(show_cand=True, simple_labels=True, pickable=True, fnum=1, pnum=pnum_()) >>> infr.add_feedback((17, 18), NEGTV) # add inconsistency >>> infr.apply_nondynamic_update() >>> infr.show_graph(show_cand=True, simple_labels=True, pickable=True, fnum=1, pnum=pnum_()) >>> ut.show_if_requested() """ import wbia.plottool as pt if graph is None: graph = infr.graph # kwargs['fontsize'] = kwargs.get('fontsize', 8) with warnings.catch_warnings(): warnings.simplefilter('ignore') # default_update_kw = ut.get_func_kwargs(infr.update_visual_attrs) # update_kw = ut.update_existing(default_update_kw, kwargs) # infr.update_visual_attrs(**update_kw) if update_attrs: infr.update_visual_attrs(graph=graph, **kwargs) verbose = kwargs.pop('verbose', infr.verbose) pt.show_nx( graph, layout='custom', as_directed=False, modify_ax=False, use_image=use_image, pnum=pnum, verbose=verbose, **kwargs, ) if zoomable: pt.zoom_factory() pt.pan_factory(pt.gca()) # if with_colorbar: # # Draw a colorbar # _normal_ticks = np.linspace(0, 1, num=11) # _normal_scores = np.linspace(0, 1, num=500) # _normal_colors = infr.get_colored_weights(_normal_scores) # cb = pt.colorbar(_normal_scores, _normal_colors, lbl='weights', # ticklabels=_normal_ticks) # # point to threshold location # thresh = None # if thresh is not None: # xy = (1, thresh) # xytext = (2.5, .3 if thresh < .5 else .7) # cb.ax.annotate('threshold', xy=xy, xytext=xytext, # arrowprops=dict( # alpha=.5, fc="0.6", # connectionstyle="angle3,angleA=90,angleB=0"),) # infr.graph if graph.graph.get('dark_background', None): pt.dark_background(force=True) if pickable: fig = pt.gcf() fig.canvas.mpl_connect('pick_event', ut.partial(on_pick, infr=infr))