Python Image.Image类代码示例

    def load(self):

        """ Load the image and return an :class:`Image` instance. """

        bits_per_pixel = self.get_bits_per_sample()
        height = self.get_image_length()
        samples_per_pixel = self.get_sample_per_pixel()
        width = self.get_image_width()
        photometric = self.get_photometric()
        planar_config = self.get_planar_config()
    
        is_planar = planar_config == Tiff.PLANARCONFIG_SEPARATE
        # Tiff.PLANARCONFIG_CONTIG   = 1 = Chunky format
        # Tiff.PLANARCONFIG_SEPARATE = 2 = Planar format
        
        if samples_per_pixel == 1 and bits_per_pixel == 16 and photometric == Tiff.PHOTOMETRIC_MINISBLACK:
            format_ = 'gray16'
        elif samples_per_pixel == 3 and bits_per_pixel == 8 and photometric == Tiff.PHOTOMETRIC_RGB:
            format_ = 'rgb8'
        else:
            raise NameError('Image format of %s is not supported' % (self.file_name))
    
        image = Image(format_, width, height, is_planar)
    
        image.reshape_to_linear()
        if format_ == 'gray16':
            Tiff.read_scanline_gray16(self.tif, image.buffer)
        elif format_ == 'rgb8':
            Tiff.read_scanline_rgb8(self.tif, image.buffer)
        else:
            raise NotImplementedError
        image.reshape()
    
        return image

def convert2(path):
    image=Image.open(path)
    out = os.path.splitext(path)[0] + ".png"
    non_transparent=Image.new('RGBA', image.size, (255,255,255,255))
    non_transparent.paste(image,(0,0),image)
    #non_transparent.paste(image,image)
    non_transparent.save(out)

def output(id):
	'''Renders output page with lightbox image and related photos. 
	Lightbox title is absent from the page source unless logged into 
	iStockphoto so making title flat and editable on page'''
	file_contents = get_lightbox_source(id)
	exp_imgs      = re.compile(r"file_thumbview_approve\\\/(\d+)\\\/")
#	soup          = BeautifulSoup(file_contents)
#	title         = soup.findAll(id='searchTitleCaption')
#	matches       = re.search(r'\| Lightbox: ([\b\w\s\b]+) ', file_contents)
	ubbstr        = ''
	thumbs        = []

#	if matches:
#		name = matches.group(1)
#	else:
#		name = soup.title #'Lightbox Name Goes Here'

	ids = exp_imgs.findall(file_contents)
	ids = list(set(ids)) # dedupe
	for image_id in ids:
		i = Image(None, None, None, image_id)
		ubbstr += i.get_ubb_string() + ' '
		thumbs.append({
			'id'  : image_id, 
			'src' : i.get_thumb_src(), 
			'ubb' : i.get_ubb_string()
		})
	return render_template('output.html', id=id, name='Lightbox', thumbs=thumbs, ubbstring=ubbstr)

 def getAll(self, env=None):
     imglinks = Model.getAll(self,env)
     image_model = Image()
     for imglink in imglinks:
         img = image_model.get(imglink.Imageid)
         imglink['uri'] = img.uri if img is not None else ''
     return imglinks

 def deserialize(self,serial):
     imlist = ast.literal_eval(serial)
     for k,v in imlist.iteritems():
         #print "deserializing: %s" % k
         image = Image()
         image.deserialize(v)
         #print image
         self.addimage(image, k)

def convert(path):
    from PIL import Image

    out = os.path.splitext(path)[0] + ".png"
    im = Image.open(path)
    bg = Image.new("RGB", im.size, (255,255,255))
    bg.paste(im,im)
    bg.save(out)

	def __init__(self, image):
		Box.__init__(self)
		Visible.__init__(self)
		if issubclass(image.__class__, Image):
			self.w = image.w
			self.h = image.h
			self.nativeW = image.nativeW
			self.nativeH = image.nativeH
			self._texture = image._texture
		elif issubclass(image.__class__, pygame.Surface):
		    self._texture = None
			Image.initFromSurface(self, image)

   def generateImageFromFile(file_path, output_dir):
      'Generates an image file from each slide. Returns the paths to the images.'

      presentation = PptxFile(file_path)
      no_of_slides = len(presentation.getSlides())
      presentation.destroy() #Delete extracted folder

      image = Image()

      pptx = os.path.abspath(file_path)
      output_folder = os.path.abspath(output_dir)

      image_paths = image.generateFromPpt(pptx, output_folder, no_of_slides)
      return image_paths

    def getImages(self):
        """ returns a dict of image_tag => Image instance """
        
        self.images = {}
        
        for img in self.client.images(all=True):
            tags = [ ImageTag.parse(t) for t in img["RepoTags"] ]

            image = Image(img["Id"])
            image.tags = tags
            
            for t in image.tags:
                if t:
                    self.images[t] = image
            
        return self.images

def image_print(m, name='lines.png'):
    shape = m3d.shape(m)
    im = Image.new('RGB', shape)

    for j in xrange(shape[0]):
        for i in xrange(shape[1]):
            im.putpixel((i,j), m[j][i])
    im.save(name)    

 def getImage(self, name):
     """ returns an Image for the given name, or None if not found """
     
     retVal = None
     
     img_data = self.client.inspect_image(name)
     
     if img_data:
         img_cfg = img_data.get("config", {})
         
         retVal = Image(img_data["id"])
         retVal.tags = [ name if isinstance(name, ImageTag) else ImageTag.parse(name) ]
         
         retVal.entrypoint = img_cfg.get("Entrypoint", [None])
         retVal.command = img_cfg.get("Cmd", [None])
     
     return retVal

 def Create_Instance(self,instance_name,image_id,flavor_id):
     
     image = Image()
     image_href = image.get_anactiveimagehref()
     flavor = Flavor()
     flavor_href = flavor.get_specificflavorhref(flavor_id)
     
     instance = { "server": { "name": instance_name, "imageRef": image_href, "flavorRef": flavor_href} }
     params = json.dumps(instance)
     headers = { "X-Auth-Token":self.apitoken, "Content-type":"application/json" }
     conn = httplib.HTTPConnection(self.apiurlt[1])
     conn.request("POST", "%s/servers" % self.apiurlt[2], params, headers)
     request = conn.getresponse()
     instance_metadata = request.read()
     instance_metadata = json.loads(instance_metadata)
     conn.close()
     return instance_metadata

    def compute(self):
        im = self.get_input("Input Image")

        #check for input PixelType
        if self.has_input("Input PixelType"):
            inPixelType = self.get_input("Input PixelType")
        else:
            inPixelType = im.getPixelType()

        #check for dimension
        if self.has_input("Dimension"):
            dim = self.get_input("Dimension")
        else:
            dim = im.getDim()

        #setup filter
        inImgType = itk.Image[inPixelType._type, dim]
        up = self.get_input("Upper Value")
        lo = self.get_input("Lower Value")

        self.filter_ = itk.ThresholdImageFilter[inImgType].New(im.getImg())

        self.filter_.SetUpper(up)
        self.filter_.SetLower(lo)
#       self.filter_.ThresholdAbove(up)
        self.filter_.Update()

        #setup output image
        outIm = Image()
        outIm.setImg(self.filter_.GetOutput())
        outIm.setPixelType(inPixelType)
        outIm.setDim(dim)

        self.set_output("Output Image", outIm)

 def loadImage(self,name):
     '''Open image with given name in viewer'''    
     if self.image: del self.image
     self.image = Image(name)
     if not self.image:
         return False
     
     self.flushImage()
     return True

    def compute(self):
        im = self.get_input("Input Image")

        #check for input PixelType
        if self.has_input("Input PixelType"):
            inPixelType = self.get_input("Input PixelType")
        else:
            inPixelType = im.getPixelType()

        #check for output PixelType
        if self.has_input("Output PixelType"):
            outPixelType = self.get_input("Output PixelType")
        else:
            outPixelType = inPixelType

        #check for dimension
        if self.has_input("Dimension"):
            dim = self.get_input("Dimension")
        else:
            dim = im.getDim()

        #set up filter
        inImgType = itk.Image[inPixelType._type, dim]
        outImgType = itk.Image[outPixelType._type, dim]

        if self.has_input("Upper Threshold"):
            upper_threshold = self.get_input("Upper Threshold")
        else:
            upper_threshold = 255

        lower_threshold = self.get_input("Lower Threshold")

        if self.has_input("Outside Value"):
            outside_value = self.get_input("Outside Value")
        else:
            outside_value = 0

        if self.has_input("Inside Value"):
            inside_value = self.get_input("Inside Value")
        else:
            inside_value = 255

        self.filter_ = itk.BinaryThresholdImageFilter[inImgType, outImgType].New(im.getImg())
        self.filter_.SetUpperThreshold(upper_threshold)
        self.filter_.SetLowerThreshold(lower_threshold)
        self.filter_.SetOutsideValue(outside_value)
        self.filter_.SetInsideValue(inside_value)
        self.filter_.Update()

        #setup output image
        outIm = Image()
        outIm.setImg(self.filter_.GetOutput())
        outIm.setPixelType(outPixelType)
        outIm.setDim(dim)

        #set results
        self.set_output("Output Image", outIm)
        self.set_output("Filter", self)
        self.set_output("Output PixelType", outPixelType)