def resize(self, image, width, height):
bi = BufferedImage(width, height, BufferedImage.TRANSLUCENT)
g2d = bi.createGraphics()
g2d.addRenderingHints(RenderingHints(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY))
g2d.drawImage(image, 0, 0, width, height, None)
g2d.dispose()
return bi;
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 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 get_font_metrics(font_name, font_size):
from java.awt.image import BufferedImage
from java.awt import Font
tmp_img = BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB)
g = tmp_img.createGraphics()
return g.getFontMetrics((Font(font_name, Font.PLAIN, int(font_size))))
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 getScreenPanel():
global mainScreen
global scrPanel
if not scrPanel:
mainScreen = JButton()
cursorImg = BufferedImage(16,16,BufferedImage.TYPE_INT_ARGB)
blankCursor = Toolkit.getDefaultToolkit().createCustomCursor(cursorImg, Point(0,0), "blank cursor")
mainScreen.setCursor(blankCursor)
mainScreen.setPreferredSize(
Dimension(700, 700))
image = BufferedImage(700, 700, BufferedImage.TYPE_INT_ARGB)
g = image.createGraphics()
g.setColor(Color.BLACK)
g.fillRect(0, 0, 700, 700)
g.setColor(Color.WHITE)
g.setFont(Font("Serif", Font.BOLD, 20))
g.drawString("Move your mouse here to controlfocused device.", 50, 30)
mainScreenImg = image
mainScreen.setIcon(swing.ImageIcon(image))
mouseListener = ScrMouseListener()
mainScreen.addMouseListener(mouseListener)
mainScreen.addMouseMotionListener(mouseListener)
mainScreen.addMouseWheelListener(mouseListener)
mainScreen.setFocusable(True)
keyListener = ScrKeyListener()
mainScreen.addKeyListener(keyListener)
scrPanel = JPanel()
scrPanel.setLayout(BoxLayout(scrPanel, BoxLayout.Y_AXIS))
scrPanel.add(mainScreen)
scrPanel.setFocusable(True)
return scrPanel
def outputFiles(self, filename, attachLogo=False, logoText=None):
rendered = self.getTarget().screenshot()
if attachLogo:
from java.awt.image import BufferedImage
from com.raytheon.uf.common.localization import PathManagerFactory
noaa = 'pyViz/logos/noaalogo2.png'
nws = 'pyViz/logos/nwslogo.png'
pathMgr = PathManagerFactory.getPathManager()
noaa = pathMgr.getStaticFile(noaa)
nws = pathMgr.getStaticFile(nws)
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
from com.raytheon.uf.viz.core.font import FontAdapter
graphics.setColor(Color.BLACK)
graphics.setFont(FontAdapter.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 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 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 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 resizeImage(self, fullSizeImage):
bufferedImage = BufferedImage(SwingingMonkeyCommander._preferredWidth, SwingingMonkeyCommander._preferredHeight, BufferedImage.TRANSLUCENT)
graphics2d = bufferedImage.createGraphics()
graphics2d.addRenderingHints(RenderingHints(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY))
graphics2d.drawImage(fullSizeImage, 0, 0, SwingingMonkeyCommander._preferredWidth, SwingingMonkeyCommander._preferredHeight, None)
graphics2d.dispose()
SwingingMonkeyCommander._widthScale = float(fullSizeImage.getWidth()) / float(bufferedImage.getWidth())
SwingingMonkeyCommander._heightScale = float(fullSizeImage.getHeight()) / float(bufferedImage.getHeight())
return bufferedImage
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 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 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 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 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 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 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 render_shape_to_graphics(self, shape):
r = shape.getShapeRenderer()
# Find the size that the shape will be rendered to at the specified scale and resolution.
shapeSizeInPixels = r.getSizeInPixels(1.0, 96.0)
# Rotating the shape may result in clipping as the image canvas is too small. Find the longest side
# and make sure that the graphics canvas is large enough to compensate for this.
maxSide = Math.max(shapeSizeInPixels.width, shapeSizeInPixels.height)
image = BufferedImage(int(maxSide * 1.25), int(maxSide * 1.25), BufferedImage.TYPE_INT_ARGB)
# Rendering to a graphics object means we can specify settings and transformations to be applied to
# the shape that is rendered. In our case we will rotate the rendered shape.
gr = image.getGraphics()
# Clear the shape with the background color of the document.
gr.setBackground(shape.getDocument().getPageColor())
gr.clearRect(0, 0, image.getWidth(), image.getHeight())
# Center the rotation using translation method below
gr.translate(image.getWidth() / 8, image.getHeight() / 2)
# Rotate the image by 45 degrees.
gr.rotate(45 * Math.PI / 180)
# Undo the translation.
gr.translate(-image.getWidth() / 8, -image.getHeight() / 2)
# Render the shape onto the graphics object.
r.renderToSize(gr, 0, 0, shapeSizeInPixels.width, shapeSizeInPixels.height)
ImageIO.write(image, "png", File(self.dataDir + "TestFile.RenderToGraphics.png"))
gr.dispose()
print "Shape rendered to Graphics successfully."
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 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 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 main(self, args):
width = 400;
height = 400;
im = BufferedImage(width,height,BufferedImage.TYPE_BYTE_BINARY);
raster = im.getRaster();
for h in range(height):
for w in range(width):
if (h / 50 + w / 50) % 2 == 0:
raster.setSample(w,h,0,0);
else:
raster.setSample(w,h,0,1);
try:
ImageIO.write(im,"PNG", File("checkboard.png"));
except IOException:
print "can not open the file"
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 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 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 get_image(self):
"""Generate a BufferedImage representing the current environment, for use in
interactivemode display."""
# copy map
bitmap = BufferedImage(self.map.getColorModel(), self.map.copyData(None), False, None);
# draw agent
graphics = bitmap.createGraphics()
graphics.setColor(Color.orange)
agentsize = 0.2
x, y = self.pt_to_pixel((self.state[0] - agentsize / 2, self.state[1] + agentsize / 2))
graphics.fillRect(x, y, int(agentsize * bitmap.getWidth() / self.imgsize[0]), int(agentsize * bitmap.getHeight() / self.imgsize[1]))
return bitmap
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 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 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()
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 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 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()
class PyColorButton(JButton):
def __init__(self, color, action=None):
JButton.__init__(self)
self._image = BufferedImage(70, 12, BufferedImage.TYPE_INT_ARGB)
g = self._image.createGraphics()
g.setColor(color)
g.fillRect(0, 0, self._image.width, self._image.height)
self._icon = ImageIcon(self._image)
self.icon = self._icon
if action is not None:
self.actionPerformed = action
def set_color(self, color):
g = self._image.createGraphics()
g.setColor(color)
g.fillRect(0, 0, self._image.width, self._image.height)
self._icon = ImageIcon(self._image)
self.icon = self._icon
def makeImage(self) : #Draw something to indicate copy tool. #Currently drawing an X self.image = BufferedImage(32,32,BufferedImage.TYPE_INT_ARGB) g = self.image.getGraphics() g.setColor(Color(0,0,0)) g.drawLine(3,3,30,3) g.drawLine(30,3,30,16) g.drawLine(3,3,3,29) g.drawLine(3,16,30,16)
def addSS(self,event):
clipboard = Toolkit.getDefaultToolkit().getSystemClipboard()
try:
image = clipboard.getData(DataFlavor.imageFlavor)
except:
self.popup("Clipboard not contains image")
return
vulnPath = self.projPath.getText() + "/" + self.clearStr(self.vulnName.getText())
if not os.path.exists(vulnPath):
os.makedirs(vulnPath)
name = self.clearStr(self.vulnName.getText()) + str(random.randint(1, 99999))+".jpg"
fileName = self.projPath.getText()+"/"+ self.clearStr(self.vulnName.getText()) + "/" + name
file = File(fileName)
bufferedImage = BufferedImage(image.getWidth(None), image.getHeight(None), BufferedImage.TYPE_INT_RGB);
g = bufferedImage.createGraphics();
g.drawImage(image, 0, 0, bufferedImage.getWidth(), bufferedImage.getHeight(), Color.WHITE, None);
ImageIO.write(bufferedImage, "jpg", file)
self.addVuln(self)
self.ssList.setSelectedValue(name,True)
def get_image(self):
"""Generate a BufferedImage representing the current environment, for
use in interactivemode display."""
# copy map
bitmap = BufferedImage(self.map.getColorModel(),
self.map.copyData(None), False, None)
# draw agent
graphics = bitmap.createGraphics()
graphics.setColor(Color.orange)
agentsize = 0.2
x, y = self.pt_to_pixel(
(self.state[0] - agentsize / 2, self.state[1] + agentsize / 2))
graphics.fillRect(
x, y, int(agentsize * bitmap.getWidth() / self.imgsize[0]),
int(agentsize * bitmap.getHeight() / self.imgsize[1]))
return bitmap
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 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 getListCellRendererComponent(self, list_, value, index, isSelected, cellHasFocus):
""" generated source for method getListCellRendererComponent """
setHorizontalAlignment(JLabel.LEFT)
if isSelected:
setBackground(list_.getSelectionBackground())
setForeground(list_.getSelectionForeground())
else:
setBackground(list_.getBackground())
setForeground(list_.getForeground())
if value == None:
return self
presence = self.thePresenceManager.getPresence(value.__str__())
status = presence.getStatus()
if status != None:
status = status.lower()
iconSize = 20
img = BufferedImage(iconSize, iconSize, BufferedImage.TYPE_INT_RGB)
g = img.getGraphics()
g.setColor(getBackground())
g.fillRect(0, 0, iconSize, iconSize)
if status == None:
g.setColor(Color.GRAY)
elif status == "available":
g.setColor(Color.GREEN)
elif status == "busy":
g.setColor(Color.ORANGE)
elif status == "error":
g.setColor(Color.BLACK)
else:
g.setColor(Color.MAGENTA)
g.fillOval(3, 3, iconSize - 6, iconSize - 6)
textLabel = presence.getHost() + ":" + presence.getPort()
if presence.__name__ != None:
textLabel = presence.__name__ + " (" + textLabel + ")"
if self.maxLabelLength > len(textLabel):
textLabel = textLabel.substring(0, self.maxLabelLength - 3) + "..."
setIcon(ImageIcon(img))
setText(textLabel)
setFont(list_.getFont())
return self
def makeImage(self) : #Draw something to indicate copy tool. #Currently drawing an X self.image = BufferedImage(32,32,BufferedImage.TYPE_INT_ARGB) g = self.image.getGraphics() g.setColor(Color(0,0,0)) g.drawLine(7,6,10,3) g.drawLine(10,3,22,3) g.drawLine(22,3,25,6) g.drawLine(7,6,7,26) g.drawLine(7,26,10,30) g.drawLine(10,30,22,30) g.drawLine(22,30,25,27)
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 split_image(image, length):
piece_width = image.getWidth() / length
piece_height = image.getHeight() / length
images = []
for i in range(length):
for j in range(length):
split = BufferedImage(piece_width, piece_height, image.getType())
g = split.createGraphics()
g.drawImage(image, 0, 0 ,\
piece_width,\
piece_height,\
piece_width * j,\
piece_height * i,\
piece_width * j + piece_width,\
piece_height * i + piece_height,\
None);
g.dispose();
images.append(split)
return images;
def makeImage(self) : self.image = BufferedImage(32,32,BufferedImage.TYPE_INT_ARGB) g = self.image.getGraphics() g.setColor(Color(0,0,0)) g.drawLine(16,0,16,32) g.drawLine(0,16,32,16) g.drawLine(16,0,10,6) g.drawLine(16,0,22,6) g.drawLine(0,16,6,10) g.drawLine(0,16,6,22) g.drawLine(16,32,10,26) g.drawLine(16,32,22,26) g.drawLine(32,16,26,10) g.drawLine(32,16,26,22)
def init(self):
""" generated source for method init """
setSize(500, 500)
addMouseListener(self)
addMouseMotionListener(self)
# initialize the biped to a valid state:
state = [
0.463, 0.98, 0.898, -0.229, 0.051, 0.276, -0.221, -1.430, -0.217,
0.086, 0.298, -3.268, -0.601, 3.167, 0.360, 0.697, 0.241, 3.532
]
self.bip7.setState(state)
delay = 1
# milliseconds
taskPerformer = ActionListener()
self.timer = Timer(delay, taskPerformer)
self.timer.start()
self.tempBuffer = BufferedImage(500, 500, BufferedImage.TYPE_INT_RGB)
initComponents()
self.con = Controller()
self.con.addWalkingController()
self.con.addRunningController()
self.con.addCrouchWalkController()
self.addKeyListener(self)
self.requestFocus()
def makeImage(self) : self.image = BufferedImage(32,32,BufferedImage.TYPE_INT_ARGB) g = self.image.getGraphics() g.setColor(Color(209,149,12)) g.drawLine(20,0,0,25) g.drawLine(25,0,5,25) g.drawLine(25,0,27,5) g.drawLine(20,0,25,0) g.drawLine(27,5,8,27) g.setColor(Color(0,0,0)) g.drawLine(0,25,5,32) g.drawLine(5,25,5,32) g.drawLine(5,25,0,25) g.drawLine(8,27,0,25) g.drawLine(8,27,5,32)
def __init__(self, *arg):
"""
Return Surface that is subclassed from java.awt.image.BufferedImage.
Alternative arguments:
* Size (w,h) of surface, optional second argument of flags (SRCALPHA)
* Bufferedimage to convert to Surface
Module initialization places pyj2d.Surface in module's namespace.
"""
try:
width, height = arg[0]
try:
if arg[1] & (BufferedImage.TYPE_INT_ARGB | Const.SRCALPHA):
BufferedImage.__init__(self, width, height,
BufferedImage.TYPE_INT_ARGB)
else:
BufferedImage.__init__(self, width, height,
BufferedImage.TYPE_INT_RGB)
except IndexError:
BufferedImage.__init__(self, width, height,
BufferedImage.TYPE_INT_ARGB)
graphics2D = self.createGraphics()
graphics2D.setColor(Color(0,0,0))
graphics2D.fillRect(0, 0, width, height)
graphics2D.dispose()
except TypeError:
try:
cm = arg[0].getColorModel()
raster = arg[0].getRaster()
isRasterPremultiplied = arg[0].isAlphaPremultiplied()
properties = Hashtable()
keys = arg[0].getPropertyNames()
if keys != None:
for key in keys:
properties.put(key, arg[0].getProperty(key))
except AttributeError:
cm, raster, isRasterPremultiplied, properties = arg
BufferedImage.__init__(self, cm, raster,
isRasterPremultiplied, properties)
self._display = None #display surface
self._super_surface = None
self._offset = (0,0)
self._colorkey = None
self._nonimplemented_methods()
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 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 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 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 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 get_render(self):
if self.db_image is None or self.size_changed:
size = Dimension(Component.getWidth(), Component.getHeight())
self.set_size(size)
Component.setPreferredSize(size)
Component.setMinimumSize(size)
Component.setMaximumSize(size)
self.size_changed = False
try:
self.db_image = BufferedImage(Component.getWidth(), Component.getHeight(), BufferedImage.TYPE_INT_RGB)
except JavaException as e:
self.db_image = None
System.out.println("Render Error: %s" % e)
System.out.println("Render Error: Buffer not initialized properly")
System.out.println("Render Error: Resolving...")
def __init__(self, *arg):
"""
Return Surface that is subclassed from java.awt.image.BufferedImage.
Alternative arguments:
* Size (w,h) of surface, optional second argument of flags (SRCALPHA)
* Bufferedimage to convert to Surface
Module initialization places pyj2d.Surface in module's namespace.
"""
try:
width, height = arg[0]
try:
if arg[1] & (BufferedImage.TYPE_INT_ARGB | Const.SRCALPHA):
BufferedImage.__init__(self, width, height, BufferedImage.TYPE_INT_ARGB)
else:
BufferedImage.__init__(self, width, height, BufferedImage.TYPE_INT_RGB)
except IndexError:
BufferedImage.__init__(self, width, height, BufferedImage.TYPE_INT_ARGB)
graphics2D = self.createGraphics()
graphics2D.setColor(Color(0,0,0))
graphics2D.fillRect(0, 0, width, height)
graphics2D.dispose()
except TypeError:
try:
cm = arg[0].getColorModel()
raster = arg[0].getRaster()
isRasterPremultiplied = arg[0].isAlphaPremultiplied()
properties = Hashtable()
keys = arg[0].getPropertyNames()
if keys != None:
for key in keys:
properties.put(key,arg[0].getProperty(key))
except AttributeError:
cm, raster, isRasterPremultiplied, properties = arg
BufferedImage.__init__(self, cm, raster, isRasterPremultiplied, properties)
self._display = None #display surface
self._super_surface = None
self._offset = (0,0)
self._colorkey = None
self._nonimplemented_methods()
class PanTool(Tool) : def __init__(self, clientState = None) : self.client_state = clientState self.start_point = None self.makeImage() def makeImage(self) : self.image = BufferedImage(32,32,BufferedImage.TYPE_INT_ARGB) g = self.image.getGraphics() g.setColor(Color(0,0,0)) g.drawLine(16,0,16,32) g.drawLine(0,16,32,16) g.drawLine(16,0,10,6) g.drawLine(16,0,22,6) g.drawLine(0,16,6,10) g.drawLine(0,16,6,22) g.drawLine(16,32,10,26) g.drawLine(16,32,22,26) g.drawLine(32,16,26,10) g.drawLine(32,16,26,22) def mousePressed(self, locationOnScreen, g) : self.last_point = locationOnScreen return "" def mouseHovered(self, locationOnScreen, g) : return "" def mouseDragged(self, locationOnScreen, g) : dx = -(locationOnScreen.x - self.last_point.x) dy = -(locationOnScreen.y - self.last_point.y) self.last_point = locationOnScreen return "%d,%d" % (dx, dy) def mouseReleased(self, locationOnScreen, g) : dx = -(locationOnScreen.x - self.last_point.x) dy = -(locationOnScreen.y - self.last_point.y) self.last_point = None return "%d,%d" % (dx, dy) def draw(self, s, g) : return None def getIcon(self) : return self.image def getToolName(self) : return "Pan" def getTooltip(self) : return "move to a new section of the canvas defined by the starting point and the point at which the mouse was released" def getToolID(self) : return 'pan'
