def __init__(self, filename, width=None, height=None): """Create an image from a file, or an empty (black) image with specified dimensions.""" # Since Python does not allow constructors with different signatures, # the trick is to reuse the first argument as a filename or a width. # If it is a string, we assume they want is to open a file. # If it is an int, we assume they want us to create a blank image. if type(filename) == type(""): # is it a string? self.filename = filename # treat is a filename self.image = BufferedImage(1, 1, BufferedImage.TYPE_INT_RGB) # create a dummy image self.read(filename) # and read external image into ti elif type(filename) == type(1): # is it a int? # create blank image with specified dimensions self.filename = "Untitled" self.width = filename # holds image width (shift arguments) self.height = width # holds image height self.image = BufferedImage(self.width, self.height, BufferedImage.TYPE_INT_RGB) # holds image buffer (pixels) else: raise TypeError("Image(): first argument must a filename (string) or an blank image width (int).") # display image self.display = JFrame() # create frame window to hold image icon = ImageIcon(self.image) # wrap image appropriately for displaying in a frame container = JLabel(icon) self.display.setContentPane(container) # and place it self.display.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE) self.display.setTitle(self.filename) self.display.setResizable(False) self.display.pack() self.display.setVisible(True)
def getContentPane(): global contentPane global REMAP_WIDTH global REMAP_HEIGHT global MARGIN if not contentPane: global mainScreen global mainScreenImg mainScreen = JLabel() cursorImg = BufferedImage(16,16,BufferedImage.TYPE_INT_ARGB) blankCursor = Toolkit.getDefaultToolkit().createCustomCursor(cursorImg, Point(0,0), "blank cursor") mainScreen.setCursor(blankCursor) mainScreen.setPreferredSize( Dimension(REMAP_WIDTH + MARGIN, REMAP_HEIGHT + MARGIN)) mainScreen.setText("main screen!") image = BufferedImage(REMAP_WIDTH + MARGIN, REMAP_HEIGHT + MARGIN , BufferedImage.TYPE_INT_ARGB) g = image.createGraphics() g.setColor(Color.BLACK) g.fillRect(0, 0, REMAP_WIDTH + MARGIN, REMAP_HEIGHT + MARGIN) g.setColor(Color.WHITE) g.setFont(Font("Serif", Font.BOLD, 20)) g.drawString("Cursor will display on your device.", 50, 30) mainScreenImg = image mainScreen.setIcon(swing.ImageIcon(image)) mouseListener = ScrMouseListener() mainScreen.addMouseListener(mouseListener) mainScreen.addMouseMotionListener(mouseListener) mainScreen.addMouseWheelListener(mouseListener) keyListener = ScrKeyListener() mainScreen.addKeyListener(keyListener) mainScreen.setFocusable(True) scrPanel = JPanel() scrPanel.setLayout(BoxLayout(scrPanel, BoxLayout.Y_AXIS)) scrPanel.add(mainScreen) contentPane = JPanel() contentPane.setLayout(BorderLayout()) contentPane.add(scrPanel, BorderLayout.WEST) # contentPAne.add(controlPanel(). BorderLayout.EAST) return contentPane
def levels(src, low=0, high=1, low_out=0, high_out=1): ''' A filter which allows levels adjustment on an image. :param src: (*image*) Source image. :param low: (*float*) Low level. :param high: (*float*) High level. :param low_out: (*float*) Low output level. :param high_out: (*float*) High output level. :returns: Destination image. ''' image = __getimage(src) if image is None: return None filter = LevelsFilter() filter.setLowLevel(low) filter.setHighLevel(high) filter.setLowOutputLevel(low_out) filter.setHighOutputLevel(high_out) dst = BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB) filter.filter(image, dst) return __getreturn(src, dst)
def threshold(src, t=None, lt=127, ut=127, white=None, black=None): ''' A filter which performs a threshold operation on an image. :param src: (*image*) Source image. :param t: (*float*) Threshold. :param lt: (*float*) Lower threshold. :param ut: (*float*) Upper threshold. :param white: (*int*) The color to be used for pixels above the upper threshold. :param black: (*int*) The color to be used for pixels blow the lower threshold. :returns: Destination image. ''' image = __getimage(src) if image is None: return None if t is None: filter = ThresholdFilter() filter.setLowerThreshold(lt) filter.setUpperThreshold(ut) else: filter = ThresholdFilter(t) if not white is None: filter.setWhite(white) if not black is None: filter.setBlack(black) dst = BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB) filter.filter(image, dst) return __getreturn(src, dst)
def tritone(src, shadow=None, mid=None, high=None): ''' A filter which performs a tritone conversion on an image. Given three colors for shadows, midtones and highlights, it converts the image to grayscale and then applies a color mapping based on the colors. :param src: (*image*) Source image. :param shadow: (*int*) Shadow color. :param mid: (*int*) Midtone color. :param high: (*int*) Highlight color :returns: Destination image. ''' image = __getimage(src) if image is None: return None filter = TritoneFilter() if not shadow is None: filter.setShadowColor(shadow) if not mid is None: filter.setMidColor(mid) if not high is None: filter.setHighColor(high) dst = BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB) filter.filter(image, dst) return __getreturn(src, dst)
def run(self): try: filepath = self.makeFilePath() if os.path.exists(filepath): return x, y, k = self.coords width, height, n_layers = self.dimensions # Cube's field of view in XY fov = Rectangle(x, y, width, height) # Join the bounds of the layers r = None for b in self.bounds[k:min(k + n_layers, len(bounds))]: if r is None: r = Rectangle(b.x, b.y, b.width, b.height) else: r.add(b) if not fov.intersects(r): # Would be empty return drawImage = Graphics2D.getDeclaredMethod( "drawImage", [Image, AffineTransform, ImageObserver]) drawImage.setAccessible(True) dispose = Graphics.getDeclaredMethod("dispose", []) dispose.setAccessible(True) # Populate and write cube stack = ImageStack(width, height) for layer in self.layers[k:min(k + n_layers, len(self.layers))]: img = layer.getProject().getLoader().getFlatAWTImage( layer, fov, 1.0, -1, ImagePlus.GRAY8, Patch, None, False, Color.black) bi = BufferedImage(img.getWidth(None), img.getHeight(None), BufferedImage.TYPE_BYTE_GRAY) g = bi.createGraphics() aff = AffineTransform(1, 0, 0, 1, 0, 0) #g.drawImage(img, aff, None) # Necessary to bypass issues that result in only using 7-bits and with the ByteProcessor constructor drawImage.invoke(g, [img, aff, None]) #g.dispose() dispose.invoke(g, []) g = None img = None stack.addSlice("", ByteProcessor(bi)) bi.flush() bi = None imp = ImagePlus("x=%s y=%s k=%s" % (x, y, k), stack) Utils.ensure(filepath) FileSaver(imp).saveAsZip(filepath) imp.flush() imp = None except: e = sys.exc_info() System.out.println("Error:" + str(e[0]) + "\n" + str(e[1]) + "\n" + str(e[2])) System.out.println(traceback.format_exception(e[0], e[1], e[2]))
def run(self): try: bounds = self.layer.getMinimalBoundingBox(Patch, True) filepath = os.path.join( self.target_dir, "section-" + str(self.i).zfill(5) + "-[x=" + str(bounds.x) + "-y=" + str(bounds.y) + "-width=" + str(bounds.width) + "-height=" + str(bounds.height) + "].zip") if os.path.exists(filepath): System.out.println("Skipping: " + filepath) return # Export System.out.println("Preparing: " + os.path.split(filepath)[1]) img = self.layer.getProject().getLoader().getFlatAWTImage( self.layer, bounds, 1.0, -1, ImagePlus.GRAY8, Patch, None, False, Color.black) bi = BufferedImage(img.getWidth(None), img.getHeight(None), BufferedImage.TYPE_BYTE_GRAY) g = bi.createGraphics() g.drawImage(img, 0, 0, None) g.dispose() g = None imp = ImagePlus(str(self.layer.getZ()), ByteProcessor(bi)) FileSaver(imp).saveAsZip(filepath) bi.flush() bi = None imp.flush() imp = None ip = None System.out.println("Saved: " + os.path.split(filepath)[1]) except: import sys e = sys.exc_info() System.out.println("Error:" + str(e[0]) + "\n" + str(e[1]) + "\n" + str(e[2]))
def outputFiles(self, filename, attachLogo=False, logoText=None): rendered = self.getTarget().screenshot() if attachLogo: from java.awt.image import BufferedImage noaa = File(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'logos/noaalogo2.png')) nws = File(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'logos/nwslogo.png')) noaaImage = ImageIO.read(noaa) nwsImage = ImageIO.read(nws) height = rendered.getHeight() + noaaImage.getHeight() finalBuf = BufferedImage(rendered.getWidth(), height, BufferedImage.TYPE_INT_ARGB) graphics = finalBuf.createGraphics() graphics.drawImage(rendered, 0, 0, None) graphics.drawImage(noaaImage, 0, rendered.getHeight(), None) graphics.fillRect(noaaImage.getWidth(), rendered.getHeight(), rendered.getWidth() - noaaImage.getWidth() - nwsImage.getWidth(), rendered.getHeight()) if logoText is not None: from java.awt import Color graphics.setColor(Color.BLACK) graphics.setFont(self.getAWTFont(self.getTarget().getDefaultFont())) fm = graphics.getFontMetrics() textBounds = fm.getStringBounds(logoText, graphics) graphics.drawString(logoText, int((rendered.getWidth() - textBounds.getWidth()) / 2), \ int(rendered.getHeight() + (noaaImage.getHeight() / 2) + textBounds.getHeight() / 2)) graphics.drawImage(nwsImage, finalBuf.getWidth() - nwsImage.getWidth(), rendered.getHeight(), None) finalBuf.flush() self.outputImage(finalBuf, filename) else: self.outputImage(rendered, filename)
def emboss(src, azimuth=135, elevation=30, emboss=False, bh=1): ''' This filter will emboss an image. :param src: (*image*) Source image. :param azimuth: (*float*) Azimuth of the light source. :param elevation: (*float*) Elevation of the light source. :param emboss: (*boolean*) Emboss or not. :param bh: (*float*) Bump height. :returns: Destination image. ''' image = __getimage(src) if image is None: return None filter = EmbossFilter() azimuth = math.radians(azimuth) elevation = math.radians(elevation) filter.setAzimuth(azimuth) filter.setElevation(elevation) filter.setEmboss(emboss) filter.setBumpHeight(bh) dst = BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB) filter.filter(image, dst) return __getreturn(src, dst)
def saveImageFile(self, fileName, width=None, height=None, rawData=None): if width == None: width = self.width if height == None: height = self.height if rawData == None: rawData = self.rawData # Rend an image # Create a buffered image in which to draw # bufferedImage = BufferedImage(width, height, BufferedImage.TYPE_INT_RGB); # bufferedImage.setRGB(0, 0, width, height, rawData, 0, width); bufferedImage = BufferedImage(width, height, BufferedImage.TYPE_BYTE_INDEXED) # bufferedImage = BufferedImage(width, height, BufferedImage.TYPE_BYTE_GRAY); bufferedImage.getRaster().setDataElements(0, 0, width, height, rawData) # Create a graphics contents on the buffered image, draw something and then dispose it # g2d = bufferedImage.createGraphics(); # g2d.setColor(Color.white); # g2d.fillRect(0, 0, width, height); # g2d.setColor(Color.black); # g2d.fillOval(0, 0, width, height); # g2d.dispose(); # Save as PNG file = File(fileName) ImageIO.write(bufferedImage, "png", file) return
def light(src, height=None, shape=None, softness=None, source=None): ''' A filter which produces lighting and embossing effects. :param src: (*image*) Source image. :param height: (*float*) Bump height. :param shape: (*int*) Bump shape. :param softness: (*float*) Bump softness. :param source: (*int*) Bump source. :returns: Destination image. ''' image = __getimage(src) if image is None: return None filter = LightFilter() if not height is None: filter.setBumpHeight(height) if not shape is None: filter.setBumpShape(shape) if not softness is None: filter.setBumpSoftness(softness) if not source is None: filter.setBumpSource(source) dst = BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB) filter.filter(image, dst) return __getreturn(src, dst)
def channel_mix(src, b_g=0, r_b=0, g_r=0, to_r=0, to_g=0, to_b=0): ''' A filter which allows the red, green and blue channels of an image to be mixed into each other. :param src: (*image*) Source image. :param b_g: (*float*) Blue and green. :param r_b: (*float*) Red and blue. :param g_r: (*float*) Green and red. :param to_r: (*float*) Mix into red. :param to_g: (*float*) Mix into green. :param to_b: (*float*) Mix into blue. :returns: Destination image. ''' image = __getimage(src) if image is None: return None filter = ChannelMixFilter() filter.setBlueGreen(b_g) filter.setRedBlue(r_b) filter.setGreenRed(g_r) filter.setIntoR(to_r) filter.setIntoG(to_g) filter.setIntoB(to_b) dst = BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB) filter.filter(image, dst) return __getreturn(src, dst)
def scale_to_fill(buffered_image): raster = buffered_image.getData() width = raster.getWidth() height = raster.getHeight() #Get extreem values from the image max_x = 0 min_x = width max_y = 0 min_y = height for x in range(0, width): for y in range(0,height): color = pixel_has_color(x,y, raster) if(color): if x > max_x: max_x = x if x < min_x: min_x = x if y > max_y: max_y = y if y < min_y: min_y = y #Cut out the part of image containing colored pixels sub_image = buffered_image.getSubimage(min_x, min_y, max_x-min_x+1,max_y-min_y+1) #Scale the image resized_image = BufferedImage(width, height, BufferedImage.TYPE_BYTE_BINARY) g = resized_image.createGraphics() g.drawImage(sub_image, 0, 0, width, height, None) g.dispose() return resized_image
def average_hash_and_sizes(self): height = 0 width = 0 if isJython(): image = ImageIO.read(File(self.image_path)) height = image.getHeight() width = image.getWidth() newImage = BufferedImage(self.hash_size, self.hash_size, BufferedImage.TYPE_INT_ARGB) g = newImage.createGraphics() g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC) g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY) g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON) g.drawImage(image, 0, 0, self.hash_size, self.hash_size, None) g.dispose() allchannelpixels = [[], [], [], []] for i in range(self.hash_size): for j in range(self.hash_size): pixel = int(newImage.getRGB(i, j)) allchannelpixels[0].append((pixel >> 16) & 0xFF) allchannelpixels[1].append((pixel >> 8) & 0xFF) allchannelpixels[2].append((pixel) & 0xFF) allchannelpixels[3].append((pixel >> 24) & 0xFF) elif isIronPython(): srcImage = Bitmap(self.image_path) height = srcImage.Height width = srcImage.Width newImage = Bitmap(self.hash_size, self.hash_size) gr = Graphics.FromImage(newImage) gr.SmoothingMode = Drawing2D.SmoothingMode.AntiAlias gr.InterpolationMode = Drawing2D.InterpolationMode.HighQualityBicubic gr.PixelOffsetMode = Drawing2D.PixelOffsetMode.HighQuality gr.DrawImage(srcImage, Rectangle(0, 0, self.hash_size, self.hash_size)) allchannelpixels = [[], [], [], []] for i in range(self.hash_size): for j in range(self.hash_size): pixel = newImage.GetPixel(i, j) allchannelpixels[0].append(int(pixel.R)) allchannelpixels[1].append(int(pixel.G)) allchannelpixels[2].append(int(pixel.B)) allchannelpixels[3].append(int(pixel.A)) else: self.image = Image.open(self.image_path) width, height = self.image.size image = self.image.resize((self.hash_size, self.hash_size), Image.ANTIALIAS) # image.show() allchannelpixels = [ list(channel.getdata()) for channel in image.split() ] bits = [] for pixels in allchannelpixels: bits.append(self.getBitString(pixels)) return bits, width, height
def setValue(self, value): if value == "": img = BufferedImage(16, 16, BufferedImage.TYPE_INT_ARGB) g = img.getGraphics() g.setColor(Color.RED) g.fillOval(2, 2, 10, 10) self.setIcon(ImageIcon(img)) else: self.setIcon(value)
def __init__(self, obj, filename, res, ulx=0, uly=0): self.obj = obj self.name = "" self.img = None self.ulx = ulx self.uly = uly res = res.lower() li = res.split("x") isOk = True try: self.width = int(li[0].strip()) self.height = int(li[1].strip()) except: isOk = False if (not isOk) or ((self.width, self.height) not in resolutions): print "Illegal resolution:", res print "Supported:", VideoRecorder.getSupportedResolutions() return self.enc = SequenceEncoder(File(File(filename).getAbsolutePath())) if str(type(obj)) == "<type 'ch.aplu.turtle.Turtle'>": self.name = "Turtle" self.traceBuf = obj.getPlayground().getTraceBuffer() self.turtleBuf = obj.getPlayground().getTurtleBuffer() self.img = BufferedImage(self.width, self.height, BufferedImage.TYPE_INT_ARGB) self.g2D = self.img.createGraphics() elif str(type(obj)) == "<class 'gturtle.TurtleFrame'>": self.name = "TurtleFrame" self.traceBuf = obj.getPlayground().getTraceBuffer() self.turtleBuf = obj.getPlayground().getTurtleBuffer() self.img = BufferedImage(self.width, self.height, BufferedImage.TYPE_INT_ARGB) self.g2D = self.img.createGraphics() elif str(type(obj)) == "<type 'ch.aplu.util.GPanel'>": self.name = "GPanel" self.img = BufferedImage(self.width, self.height, BufferedImage.TYPE_INT_ARGB) self.g2D = self.img.createGraphics() self.panelBuf = obj.getWindow().getBufferedImage() elif str(type(obj)) == "<type 'ch.aplu.jgamegrid.GameGrid'>": self.name = "GameGrid" self.img = BufferedImage(self.width, self.height, BufferedImage.TYPE_INT_ARGB) self.g2D = self.img.createGraphics()
def getIcon(self): """Set the layer icon. """ if self.iconf is not None: return self.iconf else: img = BufferedImage(16, 16, BufferedImage.TYPE_INT_ARGB) g = img.getGraphics() g.setColor(Color.RED) g.fillOval(2, 2, 10, 10) return ImageIcon(img)
def updateProduct(self, *args): try: value = self.lstProducts.getSelectedValue() except: return if value == None: return #try: if True: width = 150 height = 150 #gvSIGPath = Utilities.TEMPDIRECTORYPATH gvSIGPath = "/home/osc/temp" outputPath = os.path.join( gvSIGPath, value.getName() + "_%sx%s.jpg" % (width, height)) #Utilities.TEMPDIRECTORYPATH if os.path.exists(outputPath) == False: url = value.getPreviewLink() f = download(url) total_size = int(f.headers["Content-Length"]) MB_size = round(total_size / 1048576, 2) block_size = 1024 * 1024 outputPathFull = gvSIGPath + value.getName() + ".jpg" with open(outputPath, "wb") as file: while True: block = f.read(block_size) dSize = round( int(os.stat(outputPath).st_size) / 1048576, 2) print "(" + str(dSize) + "/" + str( MB_size) + " MB) " + url + "Downloading" if not block: break file.write(block) img = ImageIO.read(outputPathFull) tmp = img.getScaledInstance(width, height, Image.SCALE_SMOOTH) resized = BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB) g2d = resized.createGraphics() g2d.drawImage(tmp, 0, 0, None) g2d.dispose() ImageIO.write(resized, "jpg", outputPath) else: print "already downloaded" myPicture = ImageIcon(ImageIO.read(File(outputPath))) self.txtInfo.setText(value.getInfoString()) self.tabInfo.updateUI() self.lstProducts.updateUI() self.lstProducts.revalidate() self.lstProducts.repaint() #except: # myPicture = ImageIcon() self.lblPreview.setIcon(myPicture)
def image(self): w = self.getWidth() h = self.getHeight() non_black_withe_image = BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB) self.paint(non_black_withe_image.getGraphics()) raster = non_black_withe_image.getRaster() bi = BufferedImage(w, h, BufferedImage.TYPE_BYTE_BINARY) write_raster = bi.getRaster() c = array.zeros('i', 4) on = wc = array.zeros('i', 1) off = array.zeros('i', 1) off[0] = 1 for x in range(w): for y in range(h): c = raster.getPixel(x, y, c) if sum(c) != 1020: write_raster.setPixel(x, y, on) else: write_raster.setPixel(x, y, off) return bi
def saveToPNG(p, filename): from java.awt.image import BufferedImage from javax.imageio import ImageIO from java.io import File bi = BufferedImage(p.size.width, p.size.height, BufferedImage.TYPE_INT_ARGB) g = bi.createGraphics() p.invalidate() p.validate() p.paint(g) g.dispose() ImageIO.write(bi, "png", File(filename))
def snapshot(frame, box): bi = BufferedImage(box.width, box.height, BufferedImage.TYPE_INT_RGB) g = bi.createGraphics() g.translate(-box.x, -box.y) #all black! # frame.paintAll(g) #only swing components! # frame.paint(g) #only swing components! # frame.update(g) #together, also only swing and with errors ##frame.update(g) ##frame.paint(g) # locks the entire graphics machinery # frame.printAll(g) # Finally, the right one: SwingUtilities.invokeAndWait(PrintAll(frame, g)) return bi
def save_as_png(p, filename): """ saves plot window (G2Dialog) created by newPlot(title) method as a png graphics file """ from java.awt.image import BufferedImage from javax.imageio import ImageIO from java.io import File bi = BufferedImage(p.size.width, p.size.height, BufferedImage.TYPE_INT_ARGB) g = bi.createGraphics() p.invalidate() p.validate() p.paint(g) g.dispose() ImageIO.write(bi, "png", File(filename))
def find_shape_sizes(self, shape): shapeSizeInDocument = shape.getShapeRenderer().getSizeInPoints() width = shapeSizeInDocument.x # The width of the shape. height = shapeSizeInDocument.y # The height of the shape. shapeRenderedSize = shape.getShapeRenderer().getSizeInPixels(1.0, 96.0) image = BufferedImage(shapeRenderedSize.width, shapeRenderedSize.height, BufferedImage.TYPE_INT_RGB) gr = image.getGraphics() # Render shape onto the graphics object using the RenderToScale or RenderToSize methods of ShapeRenderer class. gr.dispose()
def gray_scale(src): ''' A filter which converts an image to grayscale using the NTSC brightness calculation. :param src: (*image*) Source image. :returns: Destination image. ''' image = __getimage(src) if image is None: return None filter = GrayscaleFilter() dst = BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB) filter.filter(image, dst) return __getreturn(src, dst)
def gray(src): ''' A filter which 'grays out' an image by averaging each pixel with white. :param src: (*image*) Source image. :returns: Destination image. ''' image = __getimage(src) if image is None: return None filter = GrayFilter() dst = BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB) filter.filter(image, dst) return __getreturn(src, dst)
def sharpen(src): ''' A filter which performs a simple 3x3 sharpening operation. :param src: (*image*) Source image. :returns: Destination image. ''' image = __getimage(src) if image is None: return None filter = SharpenFilter() dst = BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB) filter.filter(image, dst) return __getreturn(src, dst)
def solarize(src): ''' A filter which solarizes an image. :param src: (*image*) Source image. :returns: Destination image. ''' image = __getimage(src) if image is None: return None filter = SolarizeFilter() dst = BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB) filter.filter(image, dst) return __getreturn(src, dst)
def invert(src): ''' A filter which inverts the RGB channels of an image. :param src: (*image*) Source image. :returns: Destination image. ''' image = __getimage(src) if image is None: return None filter = InvertFilter() dst = BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB) filter.filter(image, dst) return __getreturn(src, dst)
def invert_alpha(src): ''' A Filter to invert the alpha channel of an image. :param src: (*image*) Source image. :returns: Destination image. ''' image = __getimage(src) if image is None: return None filter = InvertAlphaFilter() dst = BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB) filter.filter(image, dst) return __getreturn(src, dst)
def run(self): System.out.println("run") # zero-pad up to 10 digits bi = None try: title = str(self.i) while len(title) < 10: title = '0' + title bi = BufferedImage(self.bounds.width, self.bounds.height, BufferedImage.TYPE_INT_RGB) g = bi.createGraphics() g.drawImage(self.borders, 0, 0, None) g.drawImage(self.img, self.insets.left, self.insets.top, None) FileSaver(ImagePlus(title, ColorProcessor(bi))).saveAsTiff(self.dir + title + '.tif') except Exception, e: print e e.printStackTrace()