Python patches.PathPatch类代码示例

    def _draw(self, renderer, bboxes, ticklabels_bbox):

        renderer.open_group('coordinate_axis')

        self._update_ticks(renderer)

        self.ticks.draw(renderer)
        self.ticklabels.draw(renderer, bboxes=bboxes,
                             ticklabels_bbox=ticklabels_bbox)

        if self.grid_lines_kwargs['visible']:

            if self._grid_type == 'lines':
                self._update_grid_lines()
            else:
                self._update_grid_contour()

            if self._grid_type == 'lines':

                frame_patch = self.frame.patch
                for path in self.grid_lines:
                    p = PathPatch(path, **self.grid_lines_kwargs)
                    p.set_clip_path(frame_patch)
                    p.draw(renderer)

            elif self._grid is not None:

                for line in self._grid.collections:
                    line.set(**self.grid_lines_kwargs)
                    line.draw(renderer)

        renderer.close_group('coordinate_axis')

def draw_box_with_text(ax, x, y, width, height, text, color='black', zorder=3, text_fontsize=15,
                       text_color="black", edgecolor='black', linewidth=4, linestyle=None):

    alignment = {'horizontalalignment': 'center', 'verticalalignment': 'center'}

    font_1 = font_0.copy()
    font_1.set_size(text_fontsize)
    font_1.set_weight('bold')

    codes = [Path.MOVETO] + [Path.LINETO] * 3 + [Path.CLOSEPOLY]
    vertices = [(x, y), (x + width, y), (x + width, y - height), (x, y - height), (0, 0)]
    vertices = np.array(vertices, float)
    path = Path(vertices, codes)
    pathpatch = PathPatch(
        path, #facecolor='None',
        edgecolor=edgecolor, zorder=zorder,# lw=linewidth,
        linewidth=linewidth, linestyle=linestyle
    )
    pathpatch.set_fill(False)
    ax.text(x + width / 2.0, y - height / 2.0,
            text,
            color=text_color,
            fontproperties=font_1,
            **alignment)
    ax.add_patch(pathpatch)

def join_lines(ax, min_idx, max_idx, y, color='black'):
    codes = [Path.MOVETO] + [Path.LINETO]
    vertices = [(min_idx, y), (max_idx, y)]
    vertices = np.array(vertices, float)
    path = Path(vertices, codes)
    pathpatch = PathPatch(path, facecolor='None', edgecolor=color, zorder=3, lw=4)
    pathpatch.set_fill(False)
    ax.add_patch(pathpatch)

def draw_line_1(ax, idx, y_min, y_max, color='black', zorder=3):
    codes = [Path.MOVETO] + [Path.LINETO]
    vertices = [(idx, y_max), (idx, y_min)]
    vertices = np.array(vertices, float)
    path = Path(vertices, codes)
    pathpatch = PathPatch(path, facecolor='None', edgecolor=color, zorder=zorder, lw=4)
    pathpatch.set_fill(False)
    ax.add_patch(pathpatch)

def hash_fill_between(ax, x, y1, y2=0, **kargs):
    ''' For x, hash region between y1 and y2. Equivalent of ax.fill_between '''
    p = ax.fill_between(x, y1, y2, **kargs)
    p.set_facecolors("none")
    p.set_edgecolors("none")

    for path in p.get_paths():
        p1 = PathPatch(path, fc="none", hatch="//", alpha=1)
        ax.add_patch(p1)
        p1.set_zorder(p.get_zorder() - 0.1)

def make_path(d, style):
    items = []
    for c in d.split():
        if c.upper() in codemap:
            items.append(c)
        else:
            x, y = (float(v) for v in c.split(","))
            items.append((x, y))
    codes = []
    vertices = []            
    i = 0
    lx, ly = 0, 0
    last_code = "M"
    while i < len(items):
        code = items[i]
        if not isinstance(code, str):
            code = last_code
        else:
            i += 1
        ucode = code.upper()
        if code.isupper():
            relative = False
        else:
            relative = True
        if ucode in ("M", "L"):
            x, y = items[i]
            i += 1
            if relative:
                x += lx
                y += ly
            codes.append(codemap[ucode])
            vertices.append((x, y))
            lx, ly = x, y
        if ucode == "C":
            if not relative:
                points = items[i:i+3]
            else:
                points = [(_x + lx, _y + ly) for _x, _y in items[i:i+3]]
            codes.extend([codemap[ucode]]*3)
            vertices.extend(points)
            lx, ly = points[-1]
            i += 3
        if ucode == "Z":
            break
        last_code = code
        
    codes[0] = Path.MOVETO
    patch = PathPatch( Path(vertices, codes) )
    patch.set_linewidth( get_number(style.get("stroke-width", "1px") ) )
    fill =  style.get("fill", "none")
    if fill == "none":
        patch.set_fill( None )
    else:
        patch.set_facecolor( fill )
    edge = style.get("stroke", "none")
    patch.set_edgecolor(edge)

    return patch

def draw(fig, h, heid, row):
    ax = plt.subplot2grid(shape=(2,5), loc=(row,0), colspan=2)
    lbls = labels_count if row==1 else [_]
    ax.set_xticklabels(lbls)
    for t in ax.xaxis.get_major_ticks():
        t.label.set_rotation(30)
    rplt.hist(h, axes=ax)
    npass = sum(list(h)[2:])
    p = plt.fill_between([1.5,4.5],[npass,npass], [0.01,0.01])
    p.set_facecolors('none')
    for path in p.get_paths():
        p1 = PathPatch(path, fc='none', hatch='\\\\\\', color='blue')
        ax.add_patch(p1)
        p1.set_zorder(p.get_zorder()-0.1)
    ax.set_yscale('log')
    ylim((0.01,3*h.GetMaximum()))
    text(0.9, 0.75,'charge skim', fontsize=12, color='blue',
         transform=ax.transAxes, horizontalalignment='right', verticalalignment='bottom')
    text(0.9, 0.68, '%.1f'%(100*npass)+'$\%$', fontsize=14, color='blue',
         transform=ax.transAxes, horizontalalignment='right', verticalalignment='top')
    
    ax = plt.subplot2grid(shape=(2,5), loc=(row,2), colspan=3)
    lbls = labels_eid if row==1 else [_]
    ax.set_xticklabels(lbls)
    for t in ax.xaxis.get_major_ticks():
        t.label.set_rotation(30)
    rplt.hist(heid, axes=ax)
    X = [0.5,6.5]
    Y1 = [npass,npass]
    Y2 = [heid.GetMinimum(), heid.GetMinimum()]
    # plot(X, Y2, 'r-.')
    p = plt.fill_between([0.5,1.5],[npass,npass])
    p.set_facecolors('none')
    for path in p.get_paths():
        p1 = PathPatch(path, fc='none', hatch='\\\\\\', color='blue')
        ax.add_patch(p1)
        p1.set_zorder(p.get_zorder()-0.1)
    p = plt.fill_between([5.5,6.5],Y2)
    p.set_facecolors('none')
    for path in p.get_paths():
        p1 = PathPatch(path, fc='none', hatch='xxx', color='green')
        ax.add_patch(p1)
        p1.set_zorder(p.get_zorder()-0.1)
    ylim((0.5*heid.GetMinimum(),1.1*heid.GetMaximum()))
    text(0.95, 0.75, 'refined electron\nidentification', fontsize=12, color='green',
         transform=ax.transAxes, horizontalalignment='right', verticalalignment='bottom')
    text(0.95, 0.68, '%.1f'%(100*heid.GetMinimum())+'$\%$', fontsize=14, color='green',
         transform=ax.transAxes, horizontalalignment='right', verticalalignment='top')
    
    # subplots_adjust(bottom=0.5, wspace=0.6, hspace=0.1)
    subplots_adjust(left=0.1, bottom=0.15, wspace=0.6, hspace=0.1)
    if row==1: # text(0,-0.0025,'selection criteria', fontsize=12)
        text(0.5,0,'selection criteria', fontsize=12, transform=fig.transFigure, horizontalalignment='center')
        text(0, 0.5, 'events per trigger', fontsize=12, transform=fig.transFigure, verticalalignment='center', rotation=90)

    def getResPatchInPrb(self, n__PRB:int):
        """
        get pathPatches for plot res in dedicate Prb
        :return:
        """
        codes = []
        vertices = []
        for re in self.prb(n__PRB)().res:
            codes += re().codes
            vertices += re().vertices

        path = Path(vertices, codes)
        pathPatch = PathPatch(path, facecolor='white', edgecolor='black', linewidth=0.2, linestyle='dotted', fill='none')
        pathPatch.set_zorder(9)
        return pathPatch

    def getResPatchInReg(self, k___singleQuote:int, l___singleQuote:int):
        """
        get pathPatches for plot res in dedicate Prb
        :return:
        """
        codes = []
        vertices = []
        for re in self.reg(k___singleQuote,l___singleQuote).res:
            codes += re().codes
            vertices += re().vertices

        path = Path(vertices, codes)
        patch = PathPatch(path, facecolor='white', edgecolor='black', linewidth=0.2, linestyle='dotted', fill='none')
        patch.set_zorder(90)
        return patch

    def _initPatch(self):
        """
        get pathPatches for plotting res for CRS of dedicate port
        :return:
        """
        codes = []
        vertices = []
        for re in self.res:
            codes += re().codes
            vertices += re().vertices

        path = Path(vertices, codes)
        patch = PathPatch(path, facecolor='white', edgecolor='black', linewidth=0.2,  fill='none')
        patch.set_zorder(90)
        return patch, codes, vertices

    def _initPatch(self, n__s:int, subFrameTypeName:str):
        """
        generate path patch for this PRB
        :param n__s:
        :param subFrameTypeName:
        :return:
        """
        vertices = []
        codes = []
        bottom = 0
        left = 0
        width = 0
        height = 0
        if subFrameTypeName == 'D':
            bottom = self.n__PRB * conf.N__sc___RB_DL
            left  = 0
            width = conf.N__symb___DL
            height = conf.N__sc___RB_DL

        if subFrameTypeName == 'U':
            bottom = self.n__PRB * conf.N__sc___RB_UL
            left  = 0
            width = conf.N__symb___UL
            height = conf.N__sc___RB_UL

        if subFrameTypeName == 'S':
            if n__s %1 == 0:
                bottom = self.n__PRB * conf.N__sc___RB_DL
                left  = 0
                width = conf.N__symb___DwPTS
                height = conf.N__sc___RB_DL

            if n__s %1 == 1:
                bottom = self.n__PRB * conf.N__sc___RB_UL
                left  = conf.N__symb___UpPTS
                width = conf.N__symb___UL - conf.N__symb___DwPTS
                height = conf.N__sc___RB_UL

        codes = [Path.MOVETO] + [Path.LINETO]*3 + [Path.CLOSEPOLY]
        vertices = [(left,bottom),
                    (left,bottom+height),
                    (left+width,bottom+height),
                    (left+width,bottom),
                    (0,0)]
        path = Path(vertices, codes)
        patch = PathPatch(path, facecolor='white', edgecolor='black', linewidth=2.0, fill='none' )
        patch.set_zorder(80)
        return patch, codes, vertices

def create_24_tachogram(gs1, row_number, timing, des1,
                    start_hour=None, stop_hour=None,
                    slice_color="black"):

    max_timing = np.max(timing)

    ax_24_tachogram = plt.subplot(gs1[row_number, :])
    ax_24_tachogram.set_color_cycle(['blue'])
    ax_24_tachogram.plot(timing, des1)
    ax_24_tachogram.ticklabel_format(style='sci', axis='x', scilimits=(0, max_timing))
    ax_24_tachogram.xaxis.set_ticks(np.arange(0, int(max_timing) + 1, 1))
    ax_24_tachogram.set_xlim(0, max_timing)

    font_1 = font_0.copy()
    font_1.set_size('11')
    font_1.set_weight('bold')

    y_lim = ax_24_tachogram.get_ylim()[1]
    if not start_hour == None:
        codes = [Path.MOVETO] + [Path.LINETO] * 3 + [Path.CLOSEPOLY]
        vertices = [(start_hour, y_lim - 20),
                    (stop_hour, y_lim - 20),
                    (stop_hour, 0),
                    (start_hour, 0), (0, 0)]
        vertices = np.array(vertices, float)
        path = Path(vertices, codes)
        pathpatch = PathPatch(path, facecolor='None', edgecolor=slice_color, zorder=3, lw=3)
        pathpatch.set_fill(False)
        ax_24_tachogram.add_patch(pathpatch)

    leg = ax_24_tachogram.legend(['$\mathbf{%s}$' % ("RR")], loc='upper left')
    #change legend font properties
    plt.setp(leg.get_texts(), fontsize='large')
    plt.setp(leg.get_texts(), fontweight='bold')

    ax_24_tachogram.set_xlabel(u"Czas [godziny]", fontproperties = font_1)
    ax_24_tachogram.set_ylabel(u"RR [ms]", fontproperties = font_1)

    tachogram_label_pos = 18
    font_1 = font_0.copy()
    font_1.set_size('18')
    font_1.set_weight('bold')
    ax_24_tachogram.text(tachogram_label_pos, y_lim - 200,
                      u"Tachogram - 24 godziny", fontproperties = font_1)
    bold_ticks_labels(ax_24_tachogram)


    return row_number + 1

 def __init__(self, canvas, color, x, y0=None, y1=None, line_width=1.0, picker_width=5, line_style='-'):
     """
     Init the marker.
     :param canvas: A MPL canvas.
     :param color: An MPL colour value
     :param x: The x coordinate (data) of the marker.
     :param y0: The y coordinate (data) of the bottom end of the marker. Default is None which means dynamically
         set it to the current lowest y value displayed.
     :param y1: The y coordinate (data) of the top end of the marker. Default is None which means dynamically
         set it to the current highest y value displayed.
     :param line_width: The line width (pixels).
     :param picker_width: The picker sensitivity (pixels).
     :param line_style: An MPL line style value.
     """
     super(VerticalMarker, self).__init__()
     self.ax = canvas.figure.get_axes()[0]
     self.x = x
     self.y0 = y0
     self.y1 = y1
     y0, y1 = self._get_y0_y1()
     path = Path([(x, y0), (x, y1)], [Path.MOVETO, Path.LINETO])
     self.patch = PathPatch(path, facecolor='None', edgecolor=color, picker=picker_width,
                            linewidth=line_width, linestyle=line_style, animated=True)
     self.ax.add_patch(self.patch)
     self.is_moving = False

    def _draw(self, renderer, bboxes):

        renderer.open_group('coordinate_axis')

        self._update_ticks(renderer)
        self._update_grid()
        self.ticks.draw(renderer)
        self.ticklabels.draw(renderer, bboxes=bboxes)

        if self.grid_lines_kwargs['visible']:
            for path in self.grid_lines:
                p = PathPatch(path, **self.grid_lines_kwargs)
                p.set_clip_path(self.frame.path, Affine2D())
                p.draw(renderer)

        renderer.close_group('coordinate_axis')

 def initPatch(self):
     """
     plot based on matplotlib
     :return:
     """
     vertices = []
     codes = []
     codes = [Path.MOVETO] + [Path.LINETO]*3 + [Path.CLOSEPOLY]
     vertices = [(self.l,self.k),
                 ((self.l),(self.k+1)),
                 ((self.l+1),(self.k+1)),
                 ((self.l+1),(self.k)),
                 (0,0)]
     path = Path(vertices, codes)
     patch = PathPatch(path, facecolor='white', edgecolor='black')
     patch.set_zorder(100)
     return patch, codes,vertices