Python misc.face函数代码示例

    def setup_method(self, method):
        im = face(gray=True)
        self.ascent_offset = np.array((256, 256))
        s = hs.signals.Signal2D(np.zeros((10, 100, 100)))
        self.scales = np.array((0.1, 0.3))
        self.offsets = np.array((-2, -3))
        izlp = []
        for ax, offset, scale in zip(
                s.axes_manager.signal_axes, self.offsets, self.scales):
            ax.scale = scale
            ax.offset = offset
            izlp.append(ax.value2index(0))
        self.izlp = izlp
        self.ishifts = np.array([(0, 0), (4, 2), (1, 3), (-2, 2), (5, -2),
                                 (2, 2), (5, 6), (-9, -9), (-9, -9), (-6, -9)])
        self.new_offsets = self.offsets - self.ishifts.min(0) * self.scales
        zlp_pos = self.ishifts + self.izlp
        for i in range(10):
            slices = self.ascent_offset - zlp_pos[i, ...]
            s.data[i, ...] = im[slices[0]:slices[0] + 100,
                                slices[1]:slices[1] + 100]
        self.signal = s

        # How image should be after successfull alignment
        smin = self.ishifts.min(0)
        smax = self.ishifts.max(0)
        offsets = self.ascent_offset + self.offsets / self.scales - smin
        size = np.array((100, 100)) - (smax - smin)
        self.aligned = im[int(offsets[0]):int(offsets[0] + size[0]),
                          int(offsets[1]):int(offsets[1] + size[1])]

    def _plot_default(self):
        # Create a GridContainer to hold all of our plots: 2 rows, 4 columns:
        container = GridContainer(fill_padding=True,
                                  bgcolor="lightgray", use_backbuffer=True,
                                  shape=(2, 4))

        arrangements = [('top left', 'h'),
                        ('top right', 'h'),
                        ('top left', 'v'),
                        ('top right', 'v'),
                        ('bottom left', 'h'),
                        ('bottom right', 'h'),
                        ('bottom left', 'v'),
                        ('bottom right', 'v')]
        orientation_name = {'h': 'horizontal', 'v': 'vertical'}

        pd = ArrayPlotData(image=face())
        # Plot some bessel functions and add the plots to our container
        for origin, orientation in arrangements:
            plot = Plot(pd, default_origin=origin, orientation=orientation)
            plot.img_plot('image')

            # Attach some tools to the plot
            plot.tools.append(PanTool(plot))
            zoom = ZoomTool(plot, tool_mode="box", always_on=False)
            plot.overlays.append(zoom)

            title = '{0}, {1}'
            plot.title = title.format(orientation_name[orientation],
                                      origin.replace(' ', '-'))

            # Add to the grid container
            container.add(plot)

        return container

def plotImage( sCells ):

    iSize, jSize = sCells.shape
    sMax = sCells.max()
    print 'The maximum value is: ',sMax

    ima = np.zeros( (iSize, jSize, 3), dtype=np.uint8)
    for i in range(iSize):
        for j in range(jSize):
            val = int( sCells[i][j] / sMax * 255)
            if ((val >= 254) or (val == 0)):
                ima[i][j][0] = 255
            else:
                ima[i][j] = val
            # if sCells[i][j]==sMax:
            #     print i,j

    f = misc.face(gray=True)
    plt.imshow(f)
    plt.title("... !!! ...")
    plt.show()

    plt.imshow(sCells,  cmap=plt.cm.gray )
    plt.title("Raw image (no filter)")
    plt.show()

    plt.imshow(ima)
    plt.title("O and >249 values set to 255 (red)")
    plt.show()

def get_image():
    # Build Image
    try:
        filename = sys.argv[1]
        image = ndimage.imread(filename, flatten=True).astype(np.float32)
    except IndexError:
        image = misc.face(gray=True).astype(np.float32)
    return image

def process_image_02():
    img = misc.face()
    plt.gray()
    plt.axis('off')  # removes the axis and the ticks
    plt.imshow(img)
    print(img.dtype)
    print(img.shape)
    print(img.max)

    plt.show()

def test_connect_regions():
    try:
        face = sp.face(gray=True)
    except AttributeError:
        # Newer versions of scipy have face in misc
        from scipy import misc
        face = misc.face(gray=True)
    for thr in (50, 150):
        mask = face > thr
        graph = img_to_graph(face, mask)
        assert_equal(ndimage.label(mask)[1], connected_components(graph)[0])

    def initMaps(self,size=49,dim=2,file="data/dice.jpg",timeStop=0.2,constant=0,**kwargs):
        self.timeStop = timeStop
        try:
            im = misc.imread(file)
        except Exception as e:
            print(e)
            im = misc.face()
        im = misc.imresize(im,(size,size))
        gray = to_gray(im)
        value = (gray/255-0.5)*2

        self.input = ConstantMap("picture",size=size,value=value)
        return [self.input]

    def test_cli(self):
        f = plt.figure(frameon=False)
        ax = f.add_subplot(111)
        plt.imshow(face(), cmap=plt.cm.gray)
        ax.set_axis_off()
        ax.autoscale_view(True, True, True)
        f.savefig("test.png", bbox_inches='tight')
        plt.close()

        import os
        os.system('magiceye_solver test.png')
        assert os.path.exists("test-solution.png")
        os.remove("test.png")
        os.remove("test-solution.png")

def test_connect_regions_with_grid():
    try:
        face = sp.face(gray=True)
    except AttributeError:
        # Newer versions of scipy have face in misc
        from scipy import misc
        face = misc.face(gray=True)
    mask = face > 50
    graph = grid_to_graph(*face.shape, mask=mask)
    assert_equal(ndimage.label(mask)[1], connected_components(graph)[0])

    mask = face > 150
    graph = grid_to_graph(*face.shape, mask=mask, dtype=None)
    assert_equal(ndimage.label(mask)[1], connected_components(graph)[0])

def image():
    f = misc.face()
    misc.imsave("face.png", f)

    face = misc.imread("face.png")
    print face.shape, face.dtype  # 8-bit images (0-255)

    face.tofile("face.raw")
    face_from_raw = np.fromfile("face.raw", dtype=np.uint8)
    face_from_raw.shape = (768, 1024, 3)

    import matplotlib.pyplot as plt

    plt.imshow(f)  # plt.show()

def _downsampled_face():
    try:
        face = sp.face(gray=True)
    except AttributeError:
        # Newer versions of scipy have face in misc
        from scipy import misc
        face = misc.face(gray=True)
    face = face.astype(np.float32)
    face = (face[::2, ::2] + face[1::2, ::2] + face[::2, 1::2]
            + face[1::2, 1::2])
    face = (face[::2, ::2] + face[1::2, ::2] + face[::2, 1::2]
            + face[1::2, 1::2])
    face = face.astype(np.float32)
    face /= 16.0
    return face

def framing_lena():
    lena = misc.face()
    plt.imshow(lena, cmap=plt.cm.gray)
    plt.savefig('lena.png')

    crop_lena = lena[30:-30, 30:-30]
    plt.imshow(crop_lena)
    plt.savefig('crop_lena.png')

    y, x = np.ogrid[0:512, 0:512]
    print(y.shape, x.shape)
    centerx, centery = (256, 256)
    mask = (((y - centery)/1.)**2 + ((x - centerx)/0.8)**2) > 230**2
    lena[mask] = 0
    plt.imshow(lena[30:-30, 30:-30], cmap=plt.cm.gray)
    plt.savefig('lena_mask.png')
    return

  def setUp(self):
    super(TestImageLoader, self).setUp()
    self.current_dir = os.path.dirname(os.path.abspath(__file__))
    self.tif_image_path = os.path.join(self.current_dir, "a_image.tif")

    # Create image file
    self.data_dir = tempfile.mkdtemp()
    self.face = misc.face()
    self.face_path = os.path.join(self.data_dir, "face.png")
    misc.imsave(self.face_path, self.face)
    self.face_copy_path = os.path.join(self.data_dir, "face_copy.png")
    misc.imsave(self.face_copy_path, self.face)

    # Create zip of image file
    #self.zip_path = "/home/rbharath/misc/cells.zip"
    self.zip_path = os.path.join(self.data_dir, "face.zip")
    zipf = zipfile.ZipFile(self.zip_path, "w", zipfile.ZIP_DEFLATED)
    zipf.write(self.face_path)
    zipf.close()

    # Create zip of multiple image files
    self.multi_zip_path = os.path.join(self.data_dir, "multi_face.zip")
    zipf = zipfile.ZipFile(self.multi_zip_path, "w", zipfile.ZIP_DEFLATED)
    zipf.write(self.face_path)
    zipf.write(self.face_copy_path)
    zipf.close()

    # Create zip of multiple image files, multiple_types
    self.multitype_zip_path = os.path.join(self.data_dir, "multitype_face.zip")
    zipf = zipfile.ZipFile(self.multitype_zip_path, "w", zipfile.ZIP_DEFLATED)
    zipf.write(self.face_path)
    zipf.write(self.tif_image_path)
    zipf.close()

    # Create image directory
    self.image_dir = tempfile.mkdtemp()
    face_path = os.path.join(self.image_dir, "face.png")
    misc.imsave(face_path, self.face)
    face_copy_path = os.path.join(self.image_dir, "face_copy.png")
    misc.imsave(face_copy_path, self.face)

def main():
   drone = ps_drone.Drone()
   drone.reset()
   i=0
   
   


   while (True):
       cap = misc.face()
       
           
       number=validation.classify("test/snapshot_iter_21120.caffemodel", "test/deploy.prototxt", cap, 
        "test/mean.binaryproto", "test/labels.txt")
        
       print number 
            
       time.sleep(0.5)  

       i=i+1
    
       if i>10:
           exit()

#!/usr/bin/env python

"""
Demonstrate matplotlib image operations

Copyright 2018 Zihan Chen
"""


import matplotlib.pyplot as plt
from scipy.misc import face


plt.close('all')
fig, (ax1, ax2) = plt.subplots(2,1)

# read image
img = plt.imread('mpl_basics.jpg')
ax1.imshow(img)

# gray scale images
img_gray = face(gray=True)
ax2.imshow(img_gray, cmap=plt.cm.bone)

# show images
plt.show()