import matplotlib import matplotlib.pyplot as plt import numpy as np import seaborn as sns def plot_images(imgs, titles=None, cmaps="gray", dpi=100, pad=0.5, adaptive=True): """Plot a set of images horizontally. Args: imgs: a list of NumPy or PyTorch images, RGB (H, W, 3) or mono (H, W). titles: a list of strings, as titles for each image. cmaps: colormaps for monochrome images. adaptive: whether the figure size should fit the image aspect ratios. """ n = len(imgs) if not isinstance(cmaps, (list, tuple)): cmaps = [cmaps] * n if adaptive: ratios = [i.shape[1] / i.shape[0] for i in imgs] # W / H else: ratios = [4 / 3] * n figsize = [sum(ratios) * 4.5, 4.5] fig, ax = plt.subplots( 1, n, figsize=figsize, dpi=dpi, gridspec_kw={"width_ratios": ratios} ) if n == 1: ax = [ax] for i in range(n): ax[i].imshow(imgs[i], cmap=plt.get_cmap(cmaps[i])) ax[i].get_yaxis().set_ticks([]) ax[i].get_xaxis().set_ticks([]) ax[i].set_axis_off() for spine in ax[i].spines.values(): # remove frame spine.set_visible(False) if titles: ax[i].set_title(titles[i]) fig.tight_layout(pad=pad) return ax def plot_keypoints(kpts, colors="lime", ps=4, alpha=1): """Plot keypoints for existing images. Args: kpts: list of ndarrays of size (N, 2). colors: string, or list of list of tuples (one for each keypoints). ps: size of the keypoints as float. """ if not isinstance(colors, list): colors = [colors] * len(kpts) axes = plt.gcf().axes for a, k, c in zip(axes, kpts, colors): a.scatter(k[:, 0], k[:, 1], c=c, s=ps, alpha=alpha, linewidths=0) def plot_matches(kpts0, kpts1, color=None, lw=1.5, ps=4, indices=(0, 1), a=1.0): """Plot matches for a pair of existing images. Args: kpts0, kpts1: corresponding keypoints of size (N, 2). color: color of each match, string or RGB tuple. Random if not given. lw: width of the lines. ps: size of the end points (no endpoint if ps=0) indices: indices of the images to draw the matches on. a: alpha opacity of the match lines. """ fig = plt.gcf() ax = fig.axes assert len(ax) > max(indices) ax0, ax1 = ax[indices[0]], ax[indices[1]] fig.canvas.draw() assert len(kpts0) == len(kpts1) if color is None: color = matplotlib.cm.hsv(np.random.rand(len(kpts0))).tolist() elif len(color) > 0 and not isinstance(color[0], (tuple, list)): color = [color] * len(kpts0) if lw > 0: # transform the points into the figure coordinate system transFigure = fig.transFigure.inverted() fkpts0 = transFigure.transform(ax0.transData.transform(kpts0)) fkpts1 = transFigure.transform(ax1.transData.transform(kpts1)) fig.lines += [ matplotlib.lines.Line2D( (fkpts0[i, 0], fkpts1[i, 0]), (fkpts0[i, 1], fkpts1[i, 1]), zorder=1, transform=fig.transFigure, c=color[i], linewidth=lw, alpha=a, ) for i in range(len(kpts0)) ] # freeze the axes to prevent the transform to change ax0.autoscale(enable=False) ax1.autoscale(enable=False) if ps > 0: ax0.scatter(kpts0[:, 0], kpts0[:, 1], c=color, s=ps) ax1.scatter(kpts1[:, 0], kpts1[:, 1], c=color, s=ps) def plot_lines( lines, line_colors="orange", point_colors="cyan", ps=4, lw=2, alpha=1.0, indices=(0, 1), ): """Plot lines and endpoints for existing images. Args: lines: list of ndarrays of size (N, 2, 2). colors: string, or list of list of tuples (one for each keypoints). ps: size of the keypoints as float pixels. lw: line width as float pixels. alpha: transparency of the points and lines. indices: indices of the images to draw the matches on. """ if not isinstance(line_colors, list): line_colors = [line_colors] * len(lines) if not isinstance(point_colors, list): point_colors = [point_colors] * len(lines) fig = plt.gcf() ax = fig.axes assert len(ax) > max(indices) axes = [ax[i] for i in indices] fig.canvas.draw() # Plot the lines and junctions for a, l, lc, pc in zip(axes, lines, line_colors, point_colors): for i in range(len(l)): line = matplotlib.lines.Line2D( (l[i, 0, 0], l[i, 1, 0]), (l[i, 0, 1], l[i, 1, 1]), zorder=1, c=lc, linewidth=lw, alpha=alpha, ) a.add_line(line) pts = l.reshape(-1, 2) a.scatter(pts[:, 0], pts[:, 1], c=pc, s=ps, linewidths=0, zorder=2, alpha=alpha) def plot_color_line_matches(lines, correct_matches=None, lw=2, indices=(0, 1)): """Plot line matches for existing images with multiple colors. Args: lines: list of ndarrays of size (N, 2, 2). correct_matches: bool array of size (N,) indicating correct matches. lw: line width as float pixels. indices: indices of the images to draw the matches on. """ n_lines = len(lines[0]) colors = sns.color_palette("husl", n_colors=n_lines) np.random.shuffle(colors) alphas = np.ones(n_lines) # If correct_matches is not None, display wrong matches with a low alpha if correct_matches is not None: alphas[~np.array(correct_matches)] = 0.2 fig = plt.gcf() ax = fig.axes assert len(ax) > max(indices) axes = [ax[i] for i in indices] fig.canvas.draw() # Plot the lines for a, l in zip(axes, lines): # Transform the points into the figure coordinate system transFigure = fig.transFigure.inverted() endpoint0 = transFigure.transform(a.transData.transform(l[:, 0])) endpoint1 = transFigure.transform(a.transData.transform(l[:, 1])) fig.lines += [ matplotlib.lines.Line2D( (endpoint0[i, 0], endpoint1[i, 0]), (endpoint0[i, 1], endpoint1[i, 1]), zorder=1, transform=fig.transFigure, c=colors[i], alpha=alphas[i], linewidth=lw, ) for i in range(n_lines) ]