Python _png.read_png函数代码示例

def save_diff_image(expected, actual, output):
    expectedImage = _png.read_png(expected)
    actualImage = _png.read_png(actual)
    actualImage, expectedImage = crop_to_same(
        actual, actualImage, expected, expectedImage)
    expectedImage = np.array(expectedImage).astype(np.float)
    actualImage = np.array(actualImage).astype(np.float)
    assert expectedImage.ndim == actualImage.ndim
    assert expectedImage.shape == actualImage.shape
    absDiffImage = abs(expectedImage - actualImage)

    # expand differences in luminance domain
    absDiffImage *= 255 * 10
    save_image_np = np.clip(absDiffImage, 0, 255).astype(np.uint8)
    height, width, depth = save_image_np.shape

    # The PDF renderer doesn't produce an alpha channel, but the
    # matplotlib PNG writer requires one, so expand the array
    if depth == 3:
        with_alpha = np.empty((height, width, 4), dtype=np.uint8)
        with_alpha[:, :, 0:3] = save_image_np
        save_image_np = with_alpha

    # Hard-code the alpha channel to fully solid
    save_image_np[:, :, 3] = 255

    _png.write_png(save_image_np.tostring(), width, height, output)

 def __init__(self, color, figName, 
              path= None):
     
     if path == None:
         try:
             path1= wx.GetApp().installDir
         except:
             path1= sys.argv[0]
             path1= path1.decode( sys.getfilesystemencoding())
             
         IMAGESPATH= os.path.join( path1, 'nicePlot','images')
         self.original_image = read_png( str( os.path.relpath(
                     os.path.join(IMAGESPATH, "barplot", figName + '.png'))))
     else:
         self.original_image = read_png( str(os.path.relpath(
                     os.path.join(path, figName + '.png'))))
     
     self.cut_location = 70
     self.b_and_h= self.original_image[:,:,2]
     self.color=   self.original_image[:,:,2] - self.original_image[:,:,0]
     self.alpha=   self.original_image[:,:,3]
     self.nx=      self.original_image.shape[1]
     
     rgb= matplotlib.colors.colorConverter.to_rgb(color)
     im=  np.empty(self.original_image.shape,
                   self.original_image.dtype)
     im[:,:,:3]  = self.b_and_h[:,:,np.newaxis]
     im[:,:,:3] -= self.color[:,:,np.newaxis]*(1.-np.array(rgb))
     im[:,:,3]   = self.alpha
     self.im = im

def save_diff_image(expected, actual, output):
    expectedImage = _png.read_png(expected)
    actualImage = _png.read_png(actual)
    actualImage, expectedImage = crop_to_same(
        actual, actualImage, expected, expectedImage)
    expectedImage = np.array(expectedImage).astype(float)
    actualImage = np.array(actualImage).astype(float)
    if expectedImage.shape != actualImage.shape:
        raise ImageComparisonFailure(
            "Image sizes do not match expected size: {0} "
            "actual size {1}".format(expectedImage.shape, actualImage.shape))
    absDiffImage = np.abs(expectedImage - actualImage)

    # expand differences in luminance domain
    absDiffImage *= 255 * 10
    save_image_np = np.clip(absDiffImage, 0, 255).astype(np.uint8)
    height, width, depth = save_image_np.shape

    # The PDF renderer doesn't produce an alpha channel, but the
    # matplotlib PNG writer requires one, so expand the array
    if depth == 3:
        with_alpha = np.empty((height, width, 4), dtype=np.uint8)
        with_alpha[:, :, 0:3] = save_image_np
        save_image_np = with_alpha

    # Hard-code the alpha channel to fully solid
    save_image_np[:, :, 3] = 255

    _png.write_png(save_image_np, output)

 def createMovie(self):
     '''
     open all movie-template-*.png's and create a movie out of it
     '''
     print "createMovie(): writing image data"
     
     frameSizeImage = read_png(''.join([self.templateMovDataDirectory,'/.screenShot',str(0),'.png']))
     frameSize = (np.shape(frameSizeImage)[1],np.shape(frameSizeImage)[0])
     
     try:   FFMpegWriter = animation.writers['mencoder']
     except: print "ERROR: Visualisation3D.createMovie(): mencoder libary is not installed, could not create movie!"; return
             
     try:
         fileName = ''.join([self.movieSaveDirectory,'/',self.networkName,'_',str(self.movieNumber),self.movieFileType])
         imageName = ''.join(['mf://',self.templateMovDataDirectory,'/.screenShot%d.png'])
         imageType = ''.join(['type=png:w=',str(frameSize[0]),':h=',str(frameSize[1]),':fps=24'])
         command = ('mencoder',
                    imageName,
                    '-mf',
                    imageType,
                    '-ovc',
                    'lavc',
                    '-lavcopts',
                    'vcodec=mpeg4',
                    '-oac',
                    'copy',
                    '-o',
                    fileName)
         os.spawnvp(os.P_WAIT, 'mencoder', command)
         self.movieNumber = self.movieNumber+1
         print "createMovie(): created movie sucessfull"
     except:
         print "ERROR: Visualisation3D.createMovie(): mencoder libary is not installed, could not create movie!"; return

def paste_image(filename):
    # annotate plot and paste image
    fig, ax = plt.subplots()

    xy = (0.5, 0.7)
    ax.plot(xy[0], xy[1], ".r")

    fn = get_sample_data(filename, asfileobj=False)
    arr_lena = read_png(fn)

    imagebox = OffsetImage(arr_lena, zoom=0.2)

    ab = AnnotationBbox(imagebox, xy,
                        xybox=(120., -80.),
                        xycoords='data',
                        boxcoords="offset points",
                        pad=0.5,
                        arrowprops=dict(arrowstyle="->", connectionstyle="angle,angleA=0,angleB=90,rad=3")
                        )

    ax.add_artist(ab)

    ax.set_xlim(0, 1)
    ax.set_ylim(0, 1)

    plt.draw()
    plt.show()

    def __init__(self, ax, n):
        self.ax = ax

        dir=os.path.abspath(os.path.dirname(sys.argv[0]))

        ax.axis([0,1,0,1])
        ax.axes.get_xaxis().set_visible(False)
        ax.axes.get_yaxis().set_visible(False)
        ax.set_frame_on=True

        ax.plot( [ 0.1, 0.2], [0.96, 0.96], color='blue',  linewidth=2 )
        ax.plot( [ 0.1, 0.2], [0.91, 0.91], color='green', linewidth=2 )
        ax.plot( [ 0.1, 0.2], [0.86, 0.86], color='red',   linewidth=1 )

        self.text1 = ax.text( 0.3, self.ypos(2), '%d' % n )

        fn = get_sample_data("%s/coolr-logo-poweredby-48.png" % dir, asfileobj=False)
        arr = read_png(fn)
        imagebox = OffsetImage(arr, zoom=0.4)
        ab = AnnotationBbox(imagebox, (0, 0),
                            xybox=(.75, .12),
                            xycoords='data',
                            boxcoords="axes fraction",
                            pad=0.5)
        ax.add_artist(ab)

def rna_draw(seq, struct, name, out_type = 'svg'):
    lines = '{0}\n{1}\n'.format(seq,struct)
    if out_type == 'png':
        outfile = cfg.dataPath('rnafold/{0}.png'.format(name))
        rprc = spc.Popen('RNAplot -o svg; convert rna.svg {0}'.format(outfile), shell = True,
                         stdin = spc.PIPE, stdout = spc.PIPE)
        
        out = rprc.communicate(input = lines)[0].splitlines()
  
        from matplotlib._png import read_png
        image = read_png(outfile)
    elif out_type== 'svg':
        outfile = cfg.dataPath('rnafold/{0}.svg'.format(name))
        
        tempdir = 'tmp_{0}'.format(name);
        rprc = spc.Popen('mkdir {1}; cd {1}; RNAplot -o svg; mv rna.svg {0}; cd ..; rm -r {1};'.format(outfile, tempdir), shell = True,
                         stdin = spc.PIPE, stdout = spc.PIPE)
        
        out = rprc.communicate(input = lines)[0].splitlines()
        
        
        struct_svg =  open(outfile).read()
        data = xparse.parse(struct_svg)
        arr = svg.get_polys(data)[0]

    else:
        raise Exception()
    
    return arr

def main():
    # load sample data
    data = np.loadtxt("distmat799.txt", delimiter=",")
    dists = data / np.amax(data)

    # load images
    img_files = [img for img in os.listdir("799_patch") if re.search(r"\.png", img)]

    # mds
    mds = MDS(n_components=2, dissimilarity="precomputed")
    results = mds.fit(dists)

    # plot
    fig, ax = plt.subplots()
    for i, img_file in enumerate(img_files):
        img_file = os.path.join("799_patch", img_file)
        img = read_png(img_file)
        imagebox = OffsetImage(img, zoom=2.0)
        coords = results.embedding_[i, :]
        xy = tuple(coords)
        ab = AnnotationBbox(imagebox, xy)
        ax.add_artist(ab)
    ax.set_xlim(-1.0, 1.0)
    ax.set_ylim(-1.0, 1.0)
    plt.show()

def getPic(pic):

    for filename in os.listdir("./stimuli/"):
        if filename.startswith(pic):
            print filename
            picture = read_png('./stimuli/'+str(filename))

    return picture

 def get_grey(self, tex, fontsize=None, dpi=None):
     """returns the alpha channel"""
     key = tex, self.get_font_config(), fontsize, dpi
     alpha = self.grey_arrayd.get(key)
     if alpha is None:
         pngfile = self.make_png(tex, fontsize, dpi)
         X = read_png(os.path.join(self.texcache, pngfile))
         self.grey_arrayd[key] = alpha = X[:, :, -1]
     return alpha

def add_logo_on_map(imagepath, ax, position, zoom, zorder):
    logo2plot = read_png(imagepath)
    imagebox = OffsetImage(logo2plot, zoom=zoom)
    # coordinates to position this image

    ab = AnnotationBbox(imagebox, position, xybox=(0.0, 0.0), xycoords="data", pad=0.0, boxcoords="offset points")
    ab.zorder = zorder

    ax.add_artist(ab)

 def get_grey(self, tex, fontsize=None, dpi=None):
     """Return the alpha channel."""
     from matplotlib import _png
     key = tex, self.get_font_config(), fontsize, dpi
     alpha = self.grey_arrayd.get(key)
     if alpha is None:
         pngfile = self.make_png(tex, fontsize, dpi)
         X = _png.read_png(os.path.join(self.texcache, pngfile))
         self.grey_arrayd[key] = alpha = X[:, :, -1]
     return alpha

	def logo_box(self):
		
		logo_offset_image = OffsetImage(read_png(get_sample_data(logo_location, asfileobj=False)), zoom=0.25, resample=1, dpi_cor=1)
		text_box = TextArea(logo_text, textprops=dict(color='#444444', fontsize=50, weight='bold'))

		logo_and_text_box = HPacker(children=[logo_offset_image, text_box], align="center", pad=0, sep=25)

		anchored_box = AnchoredOffsetbox(loc=2, child=logo_and_text_box, pad=0.8, frameon=False, borderpad=0.)

		return anchored_box

def save_diff_image(expected, actual, output):
    '''
    Parameters
    ----------
    expected : str
        File path of expected image.
    actual : str
        File path of actual image.
    output : str
        File path to save difference image to.
    '''
    # Drop alpha channels, similarly to compare_images.
    from matplotlib import _png
    expected_image = _png.read_png(expected)[..., :3]
    actual_image = _png.read_png(actual)[..., :3]
    actual_image, expected_image = crop_to_same(
        actual, actual_image, expected, expected_image)
    expected_image = np.array(expected_image).astype(float)
    actual_image = np.array(actual_image).astype(float)
    if expected_image.shape != actual_image.shape:
        raise ImageComparisonFailure(
            "Image sizes do not match expected size: {} "
            "actual size {}".format(expected_image.shape, actual_image.shape))
    abs_diff_image = np.abs(expected_image - actual_image)

    # expand differences in luminance domain
    abs_diff_image *= 255 * 10
    save_image_np = np.clip(abs_diff_image, 0, 255).astype(np.uint8)
    height, width, depth = save_image_np.shape

    # The PDF renderer doesn't produce an alpha channel, but the
    # matplotlib PNG writer requires one, so expand the array
    if depth == 3:
        with_alpha = np.empty((height, width, 4), dtype=np.uint8)
        with_alpha[:, :, 0:3] = save_image_np
        save_image_np = with_alpha

    # Hard-code the alpha channel to fully solid
    save_image_np[:, :, 3] = 255

    _png.write_png(save_image_np, output)

	def initUI(self):

		# layout		
		vbox = QtGui.QVBoxLayout()
		self.setLayout(vbox)
		
		# set up canvas
		self.figure = plt.figure(figsize=(10,5),facecolor='None',edgecolor='None')
		self.canvas = FigureCanvas(self.figure)
		vbox.addWidget(self.canvas)

		# image parameters, axes refer to setup axes
		self.x_max = 2
		self.y_max = 4

		self.mologram = read_png('./images/mologram.png')
		self.mologram_turned = read_png('./images/mologram_turned.png')

		# initial display
		self.initDisplay()	

		cid = self.figure.canvas.mpl_connect('button_press_event', self.onclick)