Ejemplo n.º 1
0
	def draw_rectangle(self, lower, upper, node):
		r = Rectangle(lower, upper[0] - lower[0], upper[1]-lower[1], 
			edgecolor='k',
			facecolor = (0,0,0))
		self.ax.add_patch(r)
		if node.is_leaf():
			rx, ry = r.get_xy()
			cx = rx + r.get_width()/2.0
			cy = ry + r.get_height()/2.0
			r.set_facecolor( node.get_colour())
			self.ax.annotate(node.get_weight(), (cx, cy), color=(0,0,0), fontsize = 10, ha='center', va='center')
			print node.name, rx, ry, cx, cy
Ejemplo n.º 2
0
def add_box(ax,box_bounds,clrs, fill = False, linewidth = 2):
    
    # lonmin,lonmax, latmin, latmax 
    from matplotlib.patches import Rectangle
    for ii, box in enumerate(box_bounds): 
        p = Rectangle(
        (box[0], box[2]), box[1]-box[0], box[3]-box[2],
        linewidth=linewidth,fill=False,color=clrs[ii], zorder = 3)

        ax.add_patch(p)
        rx, ry = p.get_xy()
        cx = rx + p.get_width()/2.0
        cy = ry + p.get_height()/2.0
    def demo(self):
        model = self.model()
        model.load_weights('./checkpoints/model')

        test_dataset = self.database.get_tf_dataset(partition='test',
                                                    batch_size=1,
                                                    all_info=True)
        for i, item in enumerate(test_dataset):
            img, annot, orig_img, y1, y2, x1, x2 = item
            x1 = x1[0, ...].numpy()
            x2 = x2[0, ...].numpy()
            y1 = y1[0, ...].numpy()
            y2 = y2[0, ...].numpy()

            prediction = model.predict(img)
            prediction = 1 / (1 + np.exp(prediction))

            prediction = prediction[0, 0]
            if annot == 1:
                prediction = 1 - prediction
                text = f'with_mask\n{prediction:0.2f}'
            else:
                text = f'no_mask\n{prediction:0.2f}'

            if prediction > 0.5:
                color = 'g'
            else:
                color = 'r'

            rect = Rectangle((y1, x1),
                             y2 - y1,
                             x2 - x1,
                             fill=False,
                             linewidth=4,
                             edgecolor=color)

            position = list(rect.get_xy())
            position[0] += rect.get_width() / 2
            position[1] -= 20
            plt.imshow(orig_img[0, ...])
            plt.gca().add_patch(rect)
            plt.gca().annotate(text,
                               position,
                               color='w',
                               weight='bold',
                               fontsize=18,
                               ha='center',
                               va='center')

            plt.show()
Ejemplo n.º 4
0
def draw_trip(base_line, start, duration, color, text):
    rect_w = duration * 0.1
    rect_h = 0.08
    x = start * 0.1
    y = base_line + 0.1
    rect = Rectangle((x, y), rect_w, rect_h, alpha=1, facecolor=color)
    rx, ry = rect.get_xy()
    cx = rx + rect.get_width() / 2.0
    cy = ry + rect.get_height() / 2.0
    currentAxis.annotate(str(start), (cx, cy),
                         color='w',
                         weight='bold',
                         fontsize=6,
                         ha='center',
                         va='center')
    currentAxis.add_patch(rect)
Ejemplo n.º 5
0
def draw_days(base_line, number):
    rect_w = 0.1
    rect_h = 0.08
    for day in range(0, number):
        x = day * 0.1
        y = base_line
        rect = Rectangle((x, y), rect_w, rect_h, alpha=1, fill=None)
        rx, ry = rect.get_xy()
        cx = rx + rect.get_width() / 2.0
        cy = ry + rect.get_height() / 2.0
        currentAxis.annotate(day, (cx, cy),
                             color='b',
                             weight='bold',
                             fontsize=6,
                             ha='center',
                             va='center')
        currentAxis.add_patch(rect)
Ejemplo n.º 6
0
    def draw_rectangle(self, lower, upper, node):
        r = Rectangle(lower,
                      upper[0] - lower[0],
                      upper[1] - lower[1],
                      edgecolor='k',
                      facecolor=node.get_color(),
                      label=node.name)
        self.ax.add_patch(r)

        rx, ry = r.get_xy()
        rw = r.get_width()
        rh = r.get_height()
        cx = rx + rw / 2.0
        cy = ry + rh / 2.0
        if isinstance(node, PathNode):
            t = node.name
            if rw * 3 < rh:
                t += ", "
            else:
                t += "\n"
            t += str(node.size) + ", " + node.stype
            c = 'w'
            if rw < rh:
                o = "vertical"
            else:
                o = "horizontal"

        else:
            t = node.name
            if node.isfile:
                c = 'k'
                o = 45
            else:
                return
        self.ax.annotate(t, (cx, cy),
                         color=c,
                         weight='bold',
                         ha='center',
                         va='center',
                         rotation=o)
Ejemplo n.º 7
0
    def draw_rectangle(self, lower, upper, node):
        r = Rectangle( lower, upper[0]-lower[0], upper[1] - lower[1],
                   edgecolor='k',
                   facecolor= node.get_color(),
                   label=node.name)
        self.ax.add_patch(r)

        rx, ry = r.get_xy()
        rw = r.get_width()
        rh = r.get_height()
        cx = rx + rw/2.0
        cy = ry + rh/2.0
        if isinstance(node, PathNode):
            t = node.name
            if rw * 3 < rh:
                t += ", "
            else:
                t += "\n"
            t += str(node.size) + ", " + node.stype
            c='w'
            if rw < rh:
                o = "vertical"
            else:
                o = "horizontal"

        else:
            t = node.name
            if node.isfile:
                c='k'
                o = 45
            else:
                return
        self.ax.annotate(
                t,
                (cx,cy),
                color=c,
                weight='bold', ha='center', va='center',
                rotation=o
                )
Ejemplo n.º 8
0
def plot_rectangle(startTime, endTime, low, high, color, text):
    #print("plot rectangle: startTime {} endTime {} low {} high {} color {}".format(startTime, endTime, low, high, color))
    from matplotlib.patches import Rectangle
    #convert to matplotlib date representation
    start = mdates.date2num(startTime)
    end = mdates.date2num(endTime)
    width = (end - start)
    height = high - low

    rect = Rectangle((start, low), width, height, color=color, alpha=0.4)
    rx, ry = rect.get_xy()
    cx = rx + rect.get_width() / 2.0
    cy = ry + rect.get_height() / 2.0
    ax = plt.gca()
    ax.annotate(text, (cx, cy),
                color='w',
                weight='bold',
                fontsize=6,
                ha='center',
                va='center')

    ax.add_patch(rect)
Ejemplo n.º 9
0
def run_sim(scenario_str):
    # see second answer of https://stackoverflow.com/questions/25175530/can-rpy2-code-be-run-in-parallel on why it starts different 
    # R instances

    print ("Working on scenario " + scenario_str)
    all_data = {}
    scenario = scenarios[scenario_str]

    for dp in departements:
        all_data[dp] = DeptData()


    r_source = robjects.r['source']
    r_options = robjects.r['options']
    r_options(warn=-1)
    robjects.r('scenario     <- "' + scenario_str + '"')
    robjects.r('nsim         <- '  + str(nsim))
    robjects.r('t_vacc_start <- list()')
    robjects.r('t_vacc_end <- list()')
    robjects.r('p1d_reg <- list()')
    robjects.r('r_v_year <- list()')


    for dp in departements:
        robjects.r('t_vacc_start${} <- "'.format(dp.replace('-','_')) + str(scenario.t_vacc_start[dp]) + '"')
        robjects.r('t_vacc_end${}   <- "'.format(dp.replace('-','_')) + str(scenario.t_vacc_end[dp]) + '"')
        robjects.r('p1d_reg${}     <- '.format(dp.replace('-','_'))  + str(scenario.p1d_reg[dp]))
        robjects.r('r_v_year${}     <- '.format(dp.replace('-','_'))  + str(scenario.r_v_year[dp]))
    robjects.r('cases_ext    <- '  + str(scenario.ve))
    r_source('scripts/forecast_all_dept.R')
    temp = robjects.r['sim_stochastic']
    
    for dp in departements:
        for comp in compartments:
            all_data[dp].q05[comp] = temp[temp['variable'] == comp + dp.replace('-','_')][temp['isdata']=='simulation']['q05'].values
            all_data[dp].q50[comp] = temp[temp['variable'] == comp + dp.replace('-','_')][temp['isdata']=='simulation']['q50'].values
            all_data[dp].q95[comp] = temp[temp['variable'] == comp + dp.replace('-','_')][temp['isdata']=='simulation']['q95'].values


    all_data['Ouest'].q05['cases'][:datetime.date(2017,6,10)] = np.nan
    all_data['Ouest'].q50['cases'][:datetime.date(2017,6,10)] = np.nan
    all_data['Ouest'].q95['cases'][:datetime.date(2017,6,10)] = np.nan

    print ("Finished run of scenario " + scenario_str)
    
    # Save results
    dir_name = 'output/Results/' + scenario_str + '/'
    try:
        os.makedirs(dir_name)    
        print("Directory " , dir_name ,  " Created ")
    except FileExistsError:
        print("Directory " , dir_name ,  " already exists, writing into.")
    save_result(all_data, scenario_str, folder_name = dir_name)
    
    # Do figure
    ti = input_parameters['t_start']
    tf = t_for

    fig, axes = plt.subplots((len(all_data))//2, 2, figsize=(15,15), squeeze = True, dpi = 200)
    fig.patch.set_facecolor('white')

    axes = axes.flat
    for i, dp in enumerate(departements):
        axt =  axes[i].twinx()
        axes[i].plot(cases[dp][t_start:][ti:tf], marker='.', linestyle='-',color='black', linewidth=0, markersize=3 ) 
        axes[i].fill_between(all_data[dp].q05['cases'][ti:tf].index, all_data[dp].q05['cases'][ti:tf], all_data[dp].q95['cases'][ti:tf], alpha = .5, color = 'darkblue', linewidth = 0)
        axes[i].plot(all_data[dp].q50['cases'][ti:tf], alpha = 1,linestyle='-', linewidth = 2, color = 'darkblue')
        axt.bar(pd.date_range(ti,tf, freq='W-SAT').date, rain[dp].resample('W-SAT').sum()[ti:tf], label = r'Rainfall', color = 'darkblue', width=7, alpha = 1)

        axes[i].set_title(dp)
        axes[i].set_ylim(0, 500)
        axt.set_ylim(1000, 0)
        #axt.set_ylim(4*max(rain[dp].resample('W-SAT').sum()[t_start:t_for]),0) # check if only reverse y
        axes[i].set_xlim(ti, tf)
        if i%5 == 4:
            axt.set_ylabel('Rainfall [mm/week]')
            axes[i].get_yaxis().set_visible(False)
        
        elif i%5 == 0:
            axes[i].set_ylabel('Reported cholera cases')
        if i%5 != 4:
            axt.get_yaxis().set_visible(False)

        if (dp not in scenario.not_dep) and (scenario_str != 'S0'):
            # convert to matplotlib date representation
            start = mdates.date2num(scenario.t_vacc_start[dp])
            end = mdates.date2num(scenario.t_vacc_end[dp])
            width = end - start
            rect = Rectangle((start, 0), width, 1000, color='orange', alpha= 0.1)
            axes[i].add_patch(rect) 
            axes[i].add_artist(rect)
            rx, ry = rect.get_xy()
    
    for ax in axes:
        ax.label_outer()

    fig.autofmt_xdate()
    fig.tight_layout()

    plt.savefig('output/Results/' + scenario_str + '.png', bbox_inches='tight')
Ejemplo n.º 10
0
def plot_peptides(pm,
                  ax,
                  wrap=None,
                  color=True,
                  labels=False,
                  cbar=False,
                  intervals='corrected',
                  cmap='jet',
                  **kwargs):
    """

    TODO: needs to be checked if intervals (start, end) are still accurately taking inclusive, exclusive into account
    Plots peptides as rectangles in the provided axes

    Parameters
    ----------
    pm
    wrap
    ax
    color
    labels
    cmap
    kwargs

    Returns
    -------

    """

    wrap = wrap or autowrap(pm.data['start'], pm.data['end'])
    rect_kwargs = {'linewidth': 1, 'linestyle': '-', 'edgecolor': 'k'}
    rect_kwargs.update(kwargs)

    cmap = mpl.cm.get_cmap(cmap)
    norm = mpl.colors.Normalize(vmin=0, vmax=1)
    i = -1

    for p_num, e in enumerate(pm.data):
        if i < -wrap:
            i = -1

        if color:
            c = cmap(norm(e['rfu']))
        else:
            c = '#707070'

        if intervals == 'corrected':
            start, end = 'start', 'end'
        elif intervals == 'original':
            start, end = '_start', '_end'
        else:
            raise ValueError(
                f"Invalid value '{intervals}' for keyword 'intervals', options are 'corrected' or 'original'"
            )

        width = e[end] - e[start]
        rect = Rectangle((e[start] - 0.5, i),
                         width,
                         1,
                         facecolor=c,
                         **rect_kwargs)
        ax.add_patch(rect)
        if labels:
            rx, ry = rect.get_xy()
            cy = ry
            cx = rx
            ax.annotate(str(p_num), (cx, cy),
                        color='k',
                        fontsize=6,
                        va='bottom',
                        ha='right')

        i -= 1

    if cbar:
        scalar_mappable = mpl.cm.ScalarMappable(norm=norm, cmap=cmap)
        plt.colorbar(scalar_mappable, label='Percentage D')

    ax.set_ylim(-wrap, 0)
    end = pm.interval[1]
    ax.set_xlim(0, end)
    ax.set_yticks([])
Ejemplo n.º 11
0
class RectangleInteractor(QObject):

    epsilon = 5
    showverts = True
    mySignal = pyqtSignal(str)
    modSignal = pyqtSignal(str)
    
    def __init__(self,ax,corner,width,height=None,angle=0.):
        super().__init__()
        from matplotlib.patches import Rectangle
        from matplotlib.lines import Line2D
        # from matplotlib.artist import Artist
        # To avoid crashing with maximum recursion depth exceeded
        import sys
        sys.setrecursionlimit(10000) # 10000 is 10x the default value

        if height is None:
            self.type = 'Square'
            height = width
        else:
            self.type = 'Rectangle'
        self.ax = ax
        self.angle  = angle/180.*np.pi
        self.width  = width
        self.height = height
        self.rect = Rectangle(corner,width,height,edgecolor='Lime',facecolor='none',angle=angle,fill=False,animated=True)
        self.ax.add_patch(self.rect)
        self.canvas = self.rect.figure.canvas
        x,y = self.compute_markers()
        self.line = Line2D(x, y, marker='o', linestyle=None, linewidth=0., markerfacecolor='g', animated=True)
        self.ax.add_line(self.line)
        self.cid = self.rect.add_callback(self.rectangle_changed)
        self._ind = None  # the active point
        self.connect()
        self.aperture = self.rect
        self.press = None
        self.lock = None

    def compute_markers(self):

        theta0 = self.rect.angle / 180.*np.pi
        w0 = self.rect.get_width()
        h0 = self.rect.get_height()
        x0,y0 = self.rect.get_xy()
        c, s = np.cos(-theta0), np.sin(-theta0)
        R = np.matrix('{} {}; {} {}'.format(c, s, -s, c))

        x = [0.5*w0, w0, 0.5*w0]
        y = [0.5*h0, 0.5*h0, h0]

        self.xy = []
        x_ = []
        y_ = []
        for dx,dy in zip(x,y):
            (dx_,dy_), = np.array(np.dot(R,np.array([dx,dy])))
            self.xy.append((dx_+x0,dy_+y0))
            x_.append(dx_+x0)
            y_.append(dy_+y0)

        return x_,y_

    def connect(self):
        self.cid_draw = self.canvas.mpl_connect('draw_event', self.draw_callback)
        self.cid_press = self.canvas.mpl_connect('button_press_event', self.button_press_callback)
        self.cid_release = self.canvas.mpl_connect('button_release_event', self.button_release_callback)
        self.cid_motion = self.canvas.mpl_connect('motion_notify_event', self.motion_notify_callback)
        self.cid_key = self.canvas.mpl_connect('key_press_event', self.key_press_callback)
        self.canvas.draw_idle()
        
    def disconnect(self):
        self.canvas.mpl_disconnect(self.cid_draw)
        self.canvas.mpl_disconnect(self.cid_press)
        self.canvas.mpl_disconnect(self.cid_release)
        self.canvas.mpl_disconnect(self.cid_motion)
        self.canvas.mpl_disconnect(self.cid_key)
        self.rect.remove()
        self.line.remove()
        self.canvas.draw_idle()
        self.aperture = None
        
    def draw_callback(self, event):
        self.background = self.canvas.copy_from_bbox(self.ax.bbox)
        self.ax.draw_artist(self.rect)
        self.ax.draw_artist(self.line)

    def rectangle_changed(self, rect):
        'this method is called whenever the polygon object is called'
        # only copy the artist props to the line (except visibility)
        vis = self.line.get_visible()
        Artist.update_from(self.line, rect)
        self.line.set_visible(vis)  
        
    def get_ind_under_point(self, event):
        'get the index of the point if within epsilon tolerance'

        x, y = zip(*self.xy)
        d = np.hypot(x - event.xdata, y - event.ydata)
        indseq, = np.nonzero(d == d.min())
        ind = indseq[0]

        if d[ind] >= self.epsilon:
            ind = None

        return ind

    def button_press_callback(self, event):
        'whenever a mouse button is pressed'
        if not self.showverts:
            return
        if event.inaxes is None:
            return
        if event.button != 1:
            return
        self._ind = self.get_ind_under_point(event)
        x0, y0 = self.rect.get_xy()
        w0, h0 = self.rect.get_width(), self.rect.get_height()
        theta0 = self.rect.angle/180*np.pi
        self.press = x0, y0, w0, h0, theta0, event.xdata, event.ydata
        self.xy0 = self.xy

        self.lock = "pressed"

    def key_press_callback(self, event):
        'whenever a key is pressed'
        if not event.inaxes:
            return
        if event.key == 't':
            self.showverts = not self.showverts
            self.line.set_visible(self.showverts)
            if not self.showverts:
                self._ind = None
        elif event.key == 'd':
            #self.disconnect()
            #self.rect = None
            #self.line = None
            self.mySignal.emit('rectangle deleted')
        self.canvas.draw_idle()

    def button_release_callback(self, event):
        'whenever a mouse button is released'
        if not self.showverts:
            return
        if event.button != 1:
            return
        self._ind = None
        self.press = None
        self.lock = "released"
        self.background = None
        # To get other aperture redrawn
        self.canvas.draw_idle()

    def motion_notify_callback(self, event):
        'on mouse movement'
        if not self.showverts:
            return
        if self._ind is None:
            return
        if event.inaxes is None:
            return
        if event.button != 1:
            return
        x0, y0, w0, h0, theta0, xpress, ypress = self.press
        self.dx = event.xdata - xpress
        self.dy = event.ydata - ypress
        self.update_rectangle()

        # Redraw rectangle and points
        self.canvas.restore_region(self.background)
        self.ax.draw_artist(self.rect)
        self.ax.draw_artist(self.line)
        self.canvas.update()
        self.canvas.flush_events()

        # Notify callback
        self.modSignal.emit('rectangle modified')

    def update_rectangle(self):

        x0, y0, w0, h0, theta0, xpress, ypress = self.press
        dx, dy = self.dx, self.dy
        
        if self.lock == "pressed":
            if self._ind == 0:
                self.lock = "move"
            else:
                self.lock = "resizerotate"
        elif self.lock == "move":
            if x0+dx < 0:
                xn = x0
                dx = 0
            else:
                xn = x0+dx
            if y0+dy < 0:
                yn = y0
                dy = 0
            else:
                yn = y0+dy
            self.rect.set_xy((xn,yn))
            # update line
            self.xy = [(i+dx,j+dy) for (i,j) in self.xy0]
            # Redefine line
            self.line.set_data(zip(*self.xy))
        # otherwise rotate and resize
        elif self.lock == 'resizerotate':
            xc,yc = self.xy0[0] # center is conserved in the markers
            dtheta = np.arctan2(ypress+dy-yc,xpress+dx-xc)-np.arctan2(ypress-yc,xpress-xc)
            theta_ = (theta0+dtheta) * 180./np.pi
            c, s = np.cos(theta0), np.sin(theta0)
            R = np.matrix('{} {}; {} {}'.format(c, s, -s, c))
            (dx_,dy_), = np.array(np.dot(R,np.array([dx,dy])))

            # Avoid to pass through the center            
            if self._ind == 1:
                w_ = w0+2*dx_  if (w0+2*dx_) > 0 else w0
                if self.type == 'Square':
                    h_ = w_
                else:
                    h_ = h0
            elif self._ind == 2:
                h_ = h0+2*dy_  if (h0+2*dy_) > 0 else h0
                if self.type == 'Square':
                    w_ = h_
                else:
                    w_ = w0
            # update rectangle
            self.rect.set_width(w_)
            self.rect.set_height(h_)
            self.rect.angle = theta_
            # update markers
            self.updateMarkers()

    def updateMarkers(self):
        # update points
        x,y = self.compute_markers()
        self.line.set_data(x,y)
Ejemplo n.º 12
0
def handle_event():
    global command
    global command_meta
    global main_pic
    global history
    global patch
    global patches
    global click_handlers
    global G


    if command=="horizontal_line" or command=="vertical_line":
        h,w = main_pic.shape[:2]
        if patch is not None:
            w1,h1 = patch.get_xy()
            if command=="horizontal_line":
                line = Line(0,int(h1),w,int(h1), int(patch.get_height()), magenta)
            else:
                line = Line(int(w1),0,int(w1),h, int(patch.get_width()), magenta)
            main_pic = draw_line_on_picture(main_pic, line)
            patch=None
        else:
            if command=="horizontal_line":
                patch = Rectangle((0,0), w, 1, edgecolor='magenta', alpha=1)
            else:
                patch = Rectangle((0,0), 1, h, edgecolor='magenta', alpha=1)

    if command=="needle" or command=="angle_needle":
        G["needle"]["active"] = True
        just_added_patch = False
        if "pt1" in G["needle"] and "pt2" in G["needle"]: 
            if patch is None:
                print "Drawing needle patch"
                pt1 = G["needle"]["pt1"]
                pt2 = G["needle"]["pt2"]
                if command=="needle":
                    patch = Rectangle((pt1[0], pt1[1]), abs(pt2[0]-pt1[0]), abs(pt2[1]-pt1[1]), edgecolor='magenta', alpha=1, facecolor='magenta')
                else:
                    patch = Polygon(np.array([pt1, pt2, p(pt1), p(pt2)]), closed=False,
                            edgecolor='magenta', alpha=1, facecolor='magenta')
                    angle = get_angle(pt1, pt2)
                    print ("Angle :{}".format(angle)) 
                    # how to add text?
                just_added_patch = True

        if patch is not None and not just_added_patch:
            if isinstance(patch, Polygon):
                patches.append(patch)
                patch=None
            else:
                print "finalize"
                w1,h1 = patch.get_xy()
                w = patch.get_width()
                h = patch.get_height()

                if w>h:
                    print("horizontal patch")
                    line = Line(int(w1),int(h1),int(w1+w),int(h1), 3, magenta)
                else:
                    line = Line(int(w1),int(h1),int(w1),int(h1+h), 3, magenta)

                main_pic = draw_line_on_picture(main_pic, line)
            G["needle"] = {}

    if command == "divide":
        divide(command_meta.xdata, command_meta.ydata)
    if command == "brighten":
        main_pic = do_brighten(main_pic)
    if command == "mirror":
	main_pic = np.fliplr(main_pic)
    if command == "zoom":
        click_handlers = not click_handlers
    if command == "darken":
        main_pic = do_darken(main_pic)
    if command == "edge":
        main_pic = edge_detect(main_pic)
    if command == "resize_patch":
        if patch is not None:
            h = patch.get_height()
            w = patch.get_width()
            patch.set_width(int(w * 0.9))
            patch.set_height(int(h * 0.9))

    if command == "crop":
        if patch is not None:
            # apply patch
            # crop main_pic
            h = patch.get_height()
            w = patch.get_width()
            w1,h1 = patch.get_xy()
            main_pic = main_pic[slice(h1,h1+h),slice(w1,w1+w),slice(None)]
            patch=None

        else:
            # create patch
            # TODO: can read this from settings :))
            portrait_ratio = 14.8/20.8
            if orientation=="portrait":
                w_to_h = portrait_ratio
            else:
                w_to_h = 1.0/portrait_ratio
            shape = main_pic.shape
            border = 15
            hp = shape[0] - border
            wp = shape[1] - border

            if w_to_h * hp >wp:
                tw = wp
                th = wp / w_to_h 
            else:
                th = hp
                tw = w_to_h * hp
            print th,tw
            patch = Rectangle((0,0), tw, th, edgecolor='magenta', alpha=1, facecolor='none')
    if command == "undo":
        print "Undoing"
        print len(history)
        if len(history)>=2:
            main_pic,cmd = history[-2]
            print cmd
            history = history[:-1]

    if command!="undo":
        history.append((np.copy(main_pic),command))
    if command not in ["crop","horizontal_line","vertical_line","needle","angle_needle","resize_patch"]:
        patch = None
    command = None
    command_meta = None
    plot(patch=patch, click_handlers=click_handlers)
    if command is not None:
        handle_event()
Ejemplo n.º 13
0
class PixelInteractor(QObject):

    epsilon = 10
    showverts = True
    mySignal = pyqtSignal(str)
    modSignal = pyqtSignal(str)

    
    def __init__(self,ax,corner,width,angle=0.):
        super().__init__()
        from matplotlib.patches import Rectangle
        from matplotlib.lines import Line2D
        # from matplotlib.artist import Artist
        # To avoid crashing with maximum recursion depth exceeded
        import sys
        sys.setrecursionlimit(10000) # 10000 is 10x the default value

        self.type = 'Pixel'
        height = width
        self.ax = ax
        self.angle  = angle
        self.width  = width
        self.height = width
        # print('corner is ', corner)
        self.rect = Rectangle(corner,width,height,edgecolor='Lime',facecolor='none',angle=angle,fill=False,animated=True)
        self.ax.add_patch(self.rect)
        self.canvas = self.rect.figure.canvas

        x,y = self.compute_markers()
        self.line = Line2D(x, y, marker='s', linestyle=None, linewidth=0., markerfacecolor='g', animated=True)
        self.ax.add_line(self.line)

        self.cid = self.rect.add_callback(self.rectangle_changed)
        self._ind = None  # the active point

        self.connect()

        self.aperture = self.rect
        self.press = None
        self.lock = None


    def compute_markers(self):

        # theta0 = self.rect.angle / 180.*np.pi
        w0 = self.rect.get_width()
        # h0 = self.rect.get_height()
        x0,y0 = self.rect.get_xy()
        angle0 = self.rect.angle

        x = [x0+w0/np.sqrt(2.)*np.sin((45.-angle0)*np.pi/180.)]
        y = [y0+w0/np.sqrt(2.)*np.cos((45.-angle0)*np.pi/180.)]

        self.xy = [(x,y)]
        return x, y

    def connect(self):
        self.cid_draw = self.canvas.mpl_connect('draw_event', self.draw_callback)
        self.cid_press = self.canvas.mpl_connect('button_press_event', self.button_press_callback)
        self.cid_release = self.canvas.mpl_connect('button_release_event', self.button_release_callback)
        self.cid_motion = self.canvas.mpl_connect('motion_notify_event', self.motion_notify_callback)
        self.cid_key = self.canvas.mpl_connect('key_press_event', self.key_press_callback)
        self.canvas.draw_idle()

        
    def disconnect(self):
        self.canvas.mpl_disconnect(self.cid_draw)
        self.canvas.mpl_disconnect(self.cid_press)
        self.canvas.mpl_disconnect(self.cid_release)
        self.canvas.mpl_disconnect(self.cid_motion)
        self.canvas.mpl_disconnect(self.cid_key)
        self.rect.remove()
        self.line.remove()
        self.canvas.draw_idle()
        self.aperture = None
        
    def draw_callback(self, event):
        self.background = self.canvas.copy_from_bbox(self.ax.bbox)
        self.ax.draw_artist(self.rect)
        self.ax.draw_artist(self.line)


    def rectangle_changed(self, rect):
        'this method is called whenever the polygon object is called'
        # only copy the artist props to the line (except visibility)
        vis = self.line.get_visible()
        Artist.update_from(self.line, rect)
        self.line.set_visible(vis)  

        
    def get_ind_under_point(self, event):
        'get the index of the point if within epsilon tolerance'

        x, y = self.xy[0]
        d = np.hypot(x - event.xdata, y - event.ydata)

        if d >= self.epsilon:
            ind = None
        else:
            ind = 0
            
        return ind

    def button_press_callback(self, event):
        'whenever a mouse button is pressed'
        if not self.showverts:
            return
        if event.inaxes is None:
            return
        if event.button != 1:
            return
        self._ind = self.get_ind_under_point(event)
        x0, y0 = self.rect.get_xy()
        w0, h0 = self.rect.get_width(), self.rect.get_height()
        theta0 = self.rect.angle/180*np.pi
        self.press = x0, y0, w0, h0, theta0, event.xdata, event.ydata
        self.xy0 = self.xy

        self.lock = "pressed"


    def key_press_callback(self, event):
        'whenever a key is pressed'
        if not event.inaxes:
            return

        if event.key == 't':
            self.showverts = not self.showverts
            self.line.set_visible(self.showverts)
            if not self.showverts:
                self._ind = None
        elif event.key == 'd':
            self.mySignal.emit('rectangle deleted')

        self.canvas.draw_idle()

    def button_release_callback(self, event):
        'whenever a mouse button is released'
        if not self.showverts:
            return
        if event.button != 1:
            return
        self._ind = None
        self.press = None
        self.lock = "released"
        self.background = None
        # To get other aperture redrawn
        self.canvas.draw_idle()
        

    def motion_notify_callback(self, event):
        'on mouse movement'

        if not self.showverts:
            return
        if self._ind is None:
            return
        if event.inaxes is None:
            return
        if event.button != 1:
            return

        x0, y0, w0, h0, theta0, xpress, ypress = self.press
        self.dx = event.xdata - xpress
        self.dy = event.ydata - ypress
        self.update_rectangle()

        # Redraw rectangle and points
        self.canvas.restore_region(self.background)
        self.ax.draw_artist(self.rect)
        self.ax.draw_artist(self.line)
        self.canvas.update()
        self.canvas.flush_events()
        
        # alternative (slower)
        # self.canvas.draw_idle()

        # Notify callback
        self.modSignal.emit('rectangle modified')

    def update_rectangle(self):

        x0, y0, w0, h0, theta0, xpress, ypress = self.press
        dx, dy = self.dx, self.dy
        
        if self.lock == "pressed":
            self.lock = "move"
        elif self.lock == "move":
            if x0+dx < 0:
                xn = x0
                dx = 0
            else:
                xn = x0+dx
            if y0+dy < 0:
                yn = y0
                dy = 0
            else:
                yn = y0+dy
            self.rect.set_xy((xn,yn))
            # update line
            self.xy = [(i+dx,j+dy) for (i,j) in self.xy0]
            # Redefine line
            self.line.set_data(zip(*self.xy))
            self.updateMarkers()

    def updateMarkers(self):
        # update points
        x,y = self.compute_markers()
        self.line.set_data(x,y)
Ejemplo n.º 14
0
 def get_xy(self):
     xy = Rectangle.get_xy(self)
     return xy[0] + self.d / 2, xy[1] + self.d / 2
Ejemplo n.º 15
0
class usb1Windows(QWidget):
    def __del__(self):
        if hasattr(self, "camera"):
            self.camera.release()  # 释放资源

    def init_fun(self):
        self.window = Ui_Form()
        self.window.setupUi(self)

        self.timer = QTimer()  # 定义一个定时器对象
        self.timer.timeout.connect(self.timer_fun)  #计时结束调用方法

        # 1. open usb and show
        self.window.pushButton_2.clicked.connect(self.timer_start)
        # 2. catch one picture
        self.window.pushButton.clicked.connect(self.catch_picture)

        self.window.comboBox.currentIndexChanged.connect(
            self.set_width_and_height)
        self.window.checkBox.clicked.connect(self.get_faces_flag_fun)

        self.window.pushButton_5.clicked.connect(self.preview_picture)
        self.window.pushButton_4.clicked.connect(self.save_picture)

        self.window.pic_figure.canvas.mpl_connect('button_press_event',
                                                  self.on_press)
        self.window.pic_figure.canvas.mpl_connect('button_release_event',
                                                  self.on_release)

        self.getface_flag = False

        fm = open("./identiffun/faces.conf", 'r')
        self.names = fm.read().split(";")
        fm.close()
        self.my_get_face = Get_Faces(self.names)

    def on_press(self, event):
        self.on_x0 = event.xdata
        self.on_y0 = event.ydata
        if not hasattr(self, "rectload"):
            self.rectload = Rectangle((0, 0),
                                      0,
                                      0,
                                      linestyle='solid',
                                      fill=False,
                                      edgecolor='red')
            self.window.pic_figaxes.add_patch(self.rectload)

    def on_release(self, event):
        self.on_x1 = event.xdata
        self.on_y1 = event.ydata
        x_start = int(min(self.on_x0, self.on_x1))
        x_end = int(max(self.on_x0, self.on_x1))
        y_start = int(min(self.on_y0, self.on_y1))
        y_end = int(max(self.on_y0, self.on_y1))
        self.rectload.set_xy((x_start, y_start))
        self.rectload.set_height(y_end - y_start + 1)
        self.rectload.set_width(x_end - x_start + 1)
        self.window.pic_figaxes.figure.canvas.draw()

    def save_picture(self):
        if hasattr(self, 'preview_res'):
            tmp_save_picture = self.preview_res
        else:
            if hasattr(self, 'raw_frame'):
                tmp_save_picture = self.raw_frame
            else:
                return  # no pic
        cv2.imwrite("./image/save.jpg", tmp_save_picture)
        if hasattr(self, "rectload"):
            x, y = self.rectload.get_xy()
            w = self.rectload.get_width()
            h = self.rectload.get_height()
            cv2.imwrite("./image/ret.jpg", tmp_save_picture[y:y + h, x:x + w])
        # filename, filetype = QFileDialog.getSaveFileName(self, "save", "jpg Files(*.jpg)::All Files(*)")
        # if filename:
        #     cv2.imwrite(filename, tmp_save_picture)

    def preview_picture(self):
        if hasattr(self, 'raw_frame'):
            width = self.window.spinBox.value()
            height = self.window.spinBox_2.value()
            # self.raw_frame.reszie((width, height))
            self.preview_res = cv2.resize(self.raw_frame, (width, height),
                                          interpolation=cv2.INTER_CUBIC)
            self.showimg2figaxes2(self.preview_res)

    def get_faces_flag_fun(self):
        if self.window.checkBox.isChecked():
            self.getface_flag = True
        else:
            self.getface_flag = False
        # print(self.getface_flag)

    def set_width_and_height(self):
        # print(self.window.comboBox.currentText())
        width, height = self.window.comboBox.currentText().split('*')
        if hasattr(self, "camera"):
            self.camera.set(cv2.CAP_PROP_FRAME_WIDTH, int(width))
            self.camera.set(cv2.CAP_PROP_FRAME_HEIGHT, int(height))

    def catch_picture(self):
        if hasattr(self, "camera") and self.camera.isOpened():
            ret, frame = self.camera.read()
            if ret:
                self.raw_frame = copy.deepcopy(frame)
                if hasattr(self, 'preview_res'):
                    del self.preview_res
                self.showimg2figaxes2(frame)
            else:
                pass  # get faild

    def timer_fun(self):
        ret, frame = self.camera.read()
        if ret:
            self.showimg2figaxes(frame)
        else:
            self.timer.stop()

    def timer_start(self):
        if hasattr(self, "camera"):
            if not self.camera.isOpened():
                self.camera.open(0)
                # self.camera = cv2.VideoCapture(0)
        else:
            self.camera = cv2.VideoCapture(0)
        if self.camera.isOpened():
            pass
        else:
            self.camera.open(0)
        # get
        width = self.camera.get(cv2.CAP_PROP_FRAME_WIDTH)
        print(width)
        height = self.camera.get(cv2.CAP_PROP_FRAME_HEIGHT)
        print(int(height))
        self.window.comboBox.setCurrentText("%d*%d" %
                                            (int(width), int(height)))

        fps = self.camera.get(cv2.CAP_PROP_FPS)
        if fps == float('inf'):
            pass
        else:
            print(fps)

        brightness = self.camera.get(cv2.CAP_PROP_BRIGHTNESS)
        if brightness == float('inf'):
            self.window.doubleSpinBox_2.setValue(0.0)
        else:
            self.window.doubleSpinBox_2.setValue(brightness)

        contrast = self.camera.get(cv2.CAP_PROP_CONTRAST)
        if contrast == float('inf'):
            self.window.doubleSpinBox.setValue(0.0)
        else:
            self.window.doubleSpinBox.setValue(contrast)

        hue = self.camera.get(cv2.CAP_PROP_HUE)
        if hue == float('inf'):
            self.window.doubleSpinBox_3.setValue(0.0)
        else:
            self.window.doubleSpinBox_3.setValue(hue)

        exposure = self.camera.get(cv2.CAP_PROP_EXPOSURE)
        if exposure == float('inf'):
            self.window.doubleSpinBox_4.setValue(0.0)
        else:
            self.window.doubleSpinBox_4.setValue(exposure)  # inf

        saturation = self.camera.get(cv2.CAP_PROP_SATURATION)
        if saturation == float('inf'):
            self.window.doubleSpinBox_5.setValue(0.0)
        else:
            self.window.doubleSpinBox_5.setValue(saturation)  # inf

        self.timer.start(101)  #设置计时间隔并启动

    def showimg2figaxes2(self, frame):
        b, g, r = cv2.split(frame)
        imgret = cv2.merge([r, g, b])
        if hasattr(self, "rectload"):
            self.rectload.remove()
            del self.rectload
        self.window.pic_figaxes.clear()
        self.window.pic_figaxes.imshow(imgret)
        self.window.pic_figure.canvas.draw()

    def showimg2figaxes(self, img):
        if self.getface_flag:
            tmp_img = self.my_get_face.get_face_fun(img)
        else:
            tmp_img = img
        b, g, r = cv2.split(tmp_img)
        imgret = cv2.merge([r, g, b])  # 这个就是前面说书的,OpenCV和matplotlib显示不一样,需要转换
        self.window.video_figaxes.clear()
        self.window.video_figaxes.imshow(imgret)
        self.window.video_figure.canvas.draw()
Ejemplo n.º 16
0
class InteractiveCanvas(FigureCanvas):
    """An interactive matplotlib figure that allows for the plotting of data
    on a log-log axis with interactive matplotlib.patches.Rectangle drawing

    """
    def __init__(self, xdata, ydata, parent=None,
                 xlabel='x label', ylabel='y label',
                 linestyle='--', marker='o',
                 dpi=150, hold=False, alpha=0.5, colors=None):
        """Initialization method. Executes every time initialization occurs

        Parameters
        ----------
        xdata: `np.array.float64`
            Array of the input data to be plotted on the x-axis
        ydata: np.array.float64
            Array of the input data to be plotted on the y-axis
        parent: None
            Parent object of the class
        xlabel: str
            Label for the x-axis of the plot
        ylabel: str
            Label for the y-axis of the plot
        linestyle: str
            Matplotlib linestyle to be used to draw the line on the graph
        marker: str
            Matplotlib marker type to be used to draw the points on the graph
        dpi: int
            Dots per inch of the desired figure
        hold: bool
            Boolean that desides whether or not the plot should hold on
            the axes during instantiation/drawing
        alpha: float
            Transparency level of the rectangles that are drawn onto the
            figure canvas
        colors: list
            List of matplotlib acceptable color keys to be used in generation
            of the rectangles. Typically matches the table rows

        Notes
        -----
        This class implements the matplotlib Qt5 backend to allow for insertion
        of the resultant figure into a Qt application. The class allows for
        interactive generation of rectangles over a log/log axes plot.

        """
        # Save figure input parameters as class properties
        self.xdata = xdata
        self.ydata = ydata
        self.xlabel = xlabel
        self.ylabel = ylabel
        self.linestyle = linestyle
        self.marker = marker
        self.dpi = dpi
        self.hold = hold
        self.alpha = alpha
        self.colors = colors

        # Initialize empty list to store mpl rectangles and their coordinates
        self.rectCoordinates = []
        self.mplRectangles = []

        # Initialize a figure, axis, and axes
        self.fig = Figure(dpi=self.dpi)
        self.ax = plt.gca()
        self.ax.set_xlabel(xlabel)
        self.ax.set_ylabel(ylabel)
        self.axes = self.fig.add_subplot(111)
        self.axes.hold(self.hold)

        # Initialize a FigureCanvas from the figure
        FigureCanvas.__init__(self, self.fig)
        self.setParent(self.ax.figure.canvas)

        self.initFigure(self.xdata, self.ydata)

        # Allow the FigureCanvas to adjust with Main window using mpl Qt5 API
        FigureCanvas.setSizePolicy(
            self, QSizePolicy.Expanding, QSizePolicy.Expanding)
        FigureCanvas.updateGeometry(self)

        # Connect the mouse/trackpad to the FigureCanvas
        self.ax.figure.canvas.mpl_connect(
            'button_press_event', self.onPress)
        self.ax.figure.canvas.mpl_connect(
            'button_release_event', self.onRelease)

        # Super from the class for Qt
        super(InteractiveCanvas, self).__init__(self.fig)


    def initFigure(self, xdata, ydata):
        """Initialize the figure

        Parameters
        ----------
        xdata: `np.array`
            A flat numpy array of x values for the plot
        ydata: `np.array`
            A flat numpy array of y values for the plot

        Notes
        -----
        The plot will not have a tight layout until data has been passed in.
        This is currently the source of the semi-unsightly bug of misaligned
        axes on start up. Plotting the data "fixes" the bug.

        """
        if xdata is None or ydata is None:
            return

        # Currently ydata is longer than xdata with schlumberger, so handle
        #   that if it makes it this far into the program
        if len(xdata) != len(ydata):
            if len(ydata) > len(xdata):
                xdata = xdata[:len(ydata)]
            else:
                ydata = ydata[:len(xdata)]

        # Set up an empty rectangle for drawing and plot the x/y data
        self.rect = Rectangle(
            (0, 0), 0, 0, alpha=self.alpha, color='grey')
        self.addPointsAndLine(xdata, ydata, draw=False)

        # Create an mpl axis and set the labels, add the rectangle
        self.ax = plt.gca()
        self.ax.set_xlabel(self.xlabel)
        self.ax.set_ylabel(self.ylabel)
        self.ax.add_patch(self.rect)
        self.ax.figure.canvas.draw()

        # Draw extant rectangles if applicable
        if self.mplRectangles:
            self.drawRectangles()

        # Update the figure object/property
        self.fig = plt.gcf()

        self.fig.tight_layout()

    def drawRectangles(self):
        """Adds rectangles to the plot if they are currently stored"""
        # Iterate through the mpl Rectangles to draw them with the proper color
        for i, rectangle in enumerate(self.rectCoordinates):

            color = self.colors[i * 4]
            xy, width, height = rectangle

            rect = Rectangle(
                xy, width, height, alpha=self.alpha, color=color)

            self.ax.add_patch(rect)


    def addPointsAndLine(self, xdata, ydata, color='#003366', draw=True):
        """Adds the points and a line to the figure

        Parameters
        ----------
        xdata: `np.array`
            A flat numpy array of x values for the plot
        ydata: `np.array`
            A flat numpy array of y values for the plot
        color: str
            Hex code or other matplotlib accepted color key for the points/line
        draw: bool
            If True, the plot will be drawn. If False, it will not. Mainly a
            product of the test code

        """
        # Currently ydata is longer than xdata with schlumberger, so handle
        #   that if it makes it this far into the program
        if len(xdata) != len(ydata):
            if len(ydata) > len(xdata):
                xdata = xdata[:len(ydata)]
            else:
                ydata = ydata[:len(xdata)]

        # log/log plot of x and y data
        plt.loglog(
            xdata, ydata, linestyle=self.linestyle,
            marker=self.marker, color=color)

        # Draw the updates
        if draw:
            self.fig.tight_layout()
            self.ax.figure.canvas.draw()


    def onPress(self, event):
        """Handle mouse press events on the matplotlib figure cavas

        Parameters
        ----------
        event: matplotlib.event
            The matplotlib event definition. In this case, a mouse click.

        """
        self.x0 = event.xdata
        self.y0 = event.ydata


    def onRelease(self, event):
        """Handles release of mouse button events on the matplotlib canvas

        Parameters
        ----------
        event: matplotlib.event
            The matplotlib event definition. In this case, a mouse release.

        """
        try:
            self.x1 = event.xdata
            self.y1 = event.ydata

            # Create a rectangle on the plot
            self.rect.set_width(self.x1 - self.x0)
            self.rect.set_height(self.y1 - self.y0)
            self.rect.set_xy((self.x0, self.y0))

            self.ax.figure.canvas.draw()

            # Store and return the rectangle attributes as a tuple
            self.rectxy = (
                self.rect.get_xy(), self.rect._width, self.rect._height)

            return self.rectxy

        except TypeError:
            pass
Ejemplo n.º 17
0
def handle_event():
    global command
    global command_meta
    global main_pic
    global history
    global patch
    global patches
    global click_handlers
    global G

    if command == "horizontal_line" or command == "vertical_line":
        h, w = main_pic.shape[:2]
        if patch is not None:
            w1, h1 = patch.get_xy()
            if command == "horizontal_line":
                line = Line(0, int(h1), w, int(h1), int(patch.get_height()),
                            magenta)
            else:
                line = Line(int(w1), 0, int(w1), h, int(patch.get_width()),
                            magenta)
            main_pic = draw_line_on_picture(main_pic, line)
            patch = None
        else:
            if command == "horizontal_line":
                patch = Rectangle((0, 0), w, 1, edgecolor='magenta', alpha=1)
            else:
                patch = Rectangle((0, 0), 1, h, edgecolor='magenta', alpha=1)

    if command == "needle" or command == "angle_needle":
        G["needle"]["active"] = True
        just_added_patch = False
        if "pt1" in G["needle"] and "pt2" in G["needle"]:
            if patch is None:
                print "Drawing needle patch"
                pt1 = G["needle"]["pt1"]
                pt2 = G["needle"]["pt2"]
                if command == "needle":
                    patch = Rectangle((pt1[0], pt1[1]),
                                      abs(pt2[0] - pt1[0]),
                                      abs(pt2[1] - pt1[1]),
                                      edgecolor='magenta',
                                      alpha=1,
                                      facecolor='magenta')
                else:
                    patch = Polygon(np.array([pt1, pt2,
                                              p(pt1), p(pt2)]),
                                    closed=False,
                                    edgecolor='magenta',
                                    alpha=1,
                                    facecolor='magenta')
                    angle = get_angle(pt1, pt2)
                    print("Angle :{}".format(angle))
                    # how to add text?
                just_added_patch = True

        if patch is not None and not just_added_patch:
            if isinstance(patch, Polygon):
                patches.append(patch)
                patch = None
            else:
                print "finalize"
                w1, h1 = patch.get_xy()
                w = patch.get_width()
                h = patch.get_height()

                if w > h:
                    print("horizontal patch")
                    line = Line(int(w1), int(h1), int(w1 + w), int(h1), 3,
                                magenta)
                else:
                    line = Line(int(w1), int(h1), int(w1), int(h1 + h), 3,
                                magenta)

                main_pic = draw_line_on_picture(main_pic, line)
            G["needle"] = {}

    if command == "divide":
        divide(command_meta.xdata, command_meta.ydata)
    if command == "brighten":
        main_pic = do_brighten(main_pic)
    if command == "mirror":
        main_pic = np.fliplr(main_pic)
    if command == "zoom":
        click_handlers = not click_handlers
    if command == "darken":
        main_pic = do_darken(main_pic)
    if command == "edge":
        main_pic = edge_detect(main_pic)
    if command == "resize_patch":
        if patch is not None:
            h = patch.get_height()
            w = patch.get_width()
            patch.set_width(int(w * 0.9))
            patch.set_height(int(h * 0.9))

    if command == "crop":
        if patch is not None:
            # apply patch
            # crop main_pic
            h = patch.get_height()
            w = patch.get_width()
            w1, h1 = patch.get_xy()
            main_pic = main_pic[slice(h1, h1 + h),
                                slice(w1, w1 + w),
                                slice(None)]
            patch = None

        else:
            # create patch
            # TODO: can read this from settings :))
            portrait_ratio = 14.8 / 20.8
            if orientation == "portrait":
                w_to_h = portrait_ratio
            else:
                w_to_h = 1.0 / portrait_ratio
            shape = main_pic.shape
            border = 15
            hp = shape[0] - border
            wp = shape[1] - border

            if w_to_h * hp > wp:
                tw = wp
                th = wp / w_to_h
            else:
                th = hp
                tw = w_to_h * hp
            print th, tw
            patch = Rectangle((0, 0),
                              tw,
                              th,
                              edgecolor='magenta',
                              alpha=1,
                              facecolor='none')
    if command == "undo":
        print "Undoing"
        print len(history)
        if len(history) >= 2:
            main_pic, cmd = history[-2]
            print cmd
            history = history[:-1]

    if command != "undo":
        history.append((np.copy(main_pic), command))
    if command not in [
            "crop", "horizontal_line", "vertical_line", "needle",
            "angle_needle", "resize_patch"
    ]:
        patch = None
    command = None
    command_meta = None
    plot(patch=patch, click_handlers=click_handlers)
    if command is not None:
        handle_event()