예제 #1
0
파일: image.py 프로젝트: ddd332/presto
    def raster(self, filename, client):
        """Takes a filename and converts it to a raster image
        reportlab can process"""

        if not os.path.exists(filename):
            log.error("Missing image file: %s",filename)
            return missing

        try:
            # First try to rasterize using the suggested backend
            backend = self.get_backend(filename, client)[1]
            return backend.raster(filename, client)
        except:
            pass

        # Last resort: try everything

        if sys.platform[0:4] == 'java':
            try:
                from javax.imageio import ImageIO
                from java.io import File

                iis = ImageIO.createImageInputStream(File(filename))
                readers = ImageIO.getImageReaders(iis)
                if readers.hasNext():
                    reader = readers.next()
                    reader.setInput(iis, True)
                    metadata = reader.getImageMetadata(0)
                    # this means imageio can read it
                    return filename
                else:
                    log.warning("Java's ImageIO cannot read the file [%s]", filename)
            except Exception, error:
                log.warning("Could not use Java's ImageIO to read the file [%s]: %s", filename, str(error))
예제 #2
0
	def __init__(self,hostname):
		
		self.hostname=hostname
		
		JPanel.__init__(self,BorderLayout())
		self.cbActionListener=foo2(self)
		
		#imglist=os.listdir('./img')
		#try:imglist.remove('.svn')
		#except:pass
		imglist=['01-CircleOfFifths.gif','Fifths.png','circle-o-fifths.jpg','Circle_Of_Fifths.gif','Keywheel.gif','circle-of-fifths.gif','ColorFifths.jpg','cof.gif']
		
		self.cb=JComboBox(imglist,actionListener=self.cbActionListener)#
		#self.cb.addItemListener(self.cbCB)
		tb=JPanel()
		tb.setLayout(FlowLayout(FlowLayout.CENTER))
		tb.add(self.cb)
		self.add(tb,'Center')
		
		self.img=None
		if hostname[0:7]=='http://':
			self.img=ImageIO.read(URL(self.hostname+'/static/sightreadingtrainer/img/'+imglist[0]))
		else:
			self.img=ImageIO.read(File(self.hostname+'img/'+imglist[0]))
		
		icon=ImageIcon(self.img)
		self.label=JLabel(icon)
		self.add(self.label,'North')
예제 #3
0
    def save_mediafiles_into_catroid_directory_structure():
        def update_md5_hash(current_md5_name, file_path_for_update):
            resource_maps = list(sb2_project.project_code.resource_dicts_of_md5_name(current_md5_name))
            md5_name = common.md5_hash(file_path_for_update) + os.path.splitext(file_path_for_update)[1]
            for resource_map in resource_maps:
                if sb2keys.COSTUME_MD5 in resource_map:
                    resource_map[sb2keys.COSTUME_MD5] = md5_name
                elif sb2keys.SOUND_MD5 in resource_map:
                    resource_map[sb2keys.SOUND_MD5] = md5_name
                else:
                    assert False, "Unknown dict: {}".resource_map
            return md5_name

        for md5_name, src_path in sb2_project.md5_to_resource_path_map.iteritems():
            file_ext = os.path.splitext(md5_name)[1].lower()
            converted_file = False

            # TODO; extract method
            if file_ext in {".png", ".svg", ".jpg", ".gif"}:
                target_dir = images_path
#                 # WORKAROUNF: penLayerMD5 file
#                 if not resource_maps:
#                     continue
                if file_ext == ".svg":
                    # converting svg to png -> new md5 and filename
                    src_path = svgtopng.convert(src_path)
                    converted_file = True

                elif md5_name in sb2_project.background_md5_names:
                    # resize background if not matching the default resolution
                    imageFile = File(src_path)
                    pngImage = ImageIO.read(imageFile)
                    if pngImage.getWidth() > sb2.STAGE_WIDTH_IN_PIXELS or pngImage.getHeight() > sb2.STAGE_HEIGHT_IN_PIXELS:
                        resizedImage = imageresizer.resize_png(pngImage, sb2.STAGE_WIDTH_IN_PIXELS, sb2.STAGE_HEIGHT_IN_PIXELS)
                        # FIXME
                        src_path = src_path.replace(".png", "resized.png")
                        ImageIO.write(resizedImage, "png", File(src_path))
                        converted_file = True

            elif file_ext in {".wav", ".mp3"}:
                target_dir = sounds_path
                if file_ext == ".wav":
                    if not wavconverter.is_android_compatible_wav(src_path):
                        temp_path = src_path.replace(".wav", "converted.wav")
                        wavconverter.convert_to_android_compatible_wav(src_path, temp_path)
                        src_path = temp_path
                        converted_file = True

            else:
                assert file_ext in {".json"}, md5_name
                continue

            assert os.path.exists(src_path), "Not existing: {}".format(src_path)
            if converted_file:
                md5_name = update_md5_hash(md5_name, src_path)
            # if file is used multiple times: single md5, multiple filenames
            for catroid_file_name in _convert_resource_name(sb2_project, md5_name):
                shutil.copyfile(src_path, os.path.join(target_dir, catroid_file_name))
            if converted_file:
                os.remove(src_path)
예제 #4
0
    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."
예제 #5
0
    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
예제 #6
0
 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)
예제 #7
0
 def image_byte_array(self):
     baos = ByteArrayOutputStream()
     ImageIO.write(self.image(), "png", baos)
     baos.flush()
     image_bytes = baos.toByteArray()
     baos.close()
     return image_bytes
예제 #8
0
def showImgWithLegend(width=None, height=None):
    """ This function shows the image and legend from current IDV window while in GUI mode. Optional arguments are width and height in pixels, they currently default to 600 and 400"""
    from java.util import Base64  ##only in java8
    from javax.imageio import ImageIO
    from java.io import ByteArrayOutputStream
    from ucar.unidata.ui.ImageUtils import resize, toBufferedImage
    import java
    import java.awt.Robot as Robot
    import java.awt.Rectangle as Rectangle
    import java.awt.Toolkit as Toolkit
    from ucar.unidata.util import Misc
    VM = idv.getViewManager()
    VMC = VM.getContents()
    VMCC = VMC.getComponent(
        1
    )  # the view and legend ; 0 is left most part of view window with controls for perspective views
    siz = VMCC.getSize()
    loc = VMCC.getLocationOnScreen()
    gc = VMCC.getGraphicsConfiguration()
    loc.x -= gc.getBounds().x
    loc.y -= gc.getBounds().y
    robotx = Robot(gc.getDevice())
    VM.toFront()
    Misc.sleep(250)
    img = robotx.createScreenCapture(
        Rectangle(loc.x, loc.y, siz.width, siz.height))
    if width != None and height != None:
        img = toBufferedImage(resize(img, width, height))
    bos = ByteArrayOutputStream()
    ImageIO.write(img, "png",
                  Base64.getEncoder().wrap(bos))
    data = bos.toString("UTF-8")
    return {"display": "image", "data": data}
예제 #9
0
def showImgWithFullWindow(width=None, height=None):
    """ This function shows the image from current IDV window while in GUI mode. optional arguments are width and height in pixels, they
    currently default to 600 and 400"""
    from java.util import Base64  ##only in java8
    from javax.imageio import ImageIO
    from java.io import ByteArrayOutputStream
    from ucar.unidata.ui.ImageUtils import resize, toBufferedImage
    import java
    import java.awt.Robot as Robot
    import java.awt.Rectangle as Rectangle
    import java.awt.Toolkit as Toolkit
    from ucar.unidata.util import Misc
    VM = idv.getViewManager()
    myframe = VM.getDisplayWindow().getComponent()
    robotx = Robot(myframe.getGraphicsConfiguration().getDevice())
    VM.toFront()
    #robotx.delay(250)
    Misc.sleep(350)
    pause()
    img = robotx.createScreenCapture(
        Rectangle(myframe.getX(), myframe.getY(), myframe.getWidth(),
                  myframe.getHeight()))
    if width != None and height != None:
        img = toBufferedImage(resize(img, width, height))
    bos = ByteArrayOutputStream()
    ImageIO.write(img, "png",
                  Base64.getEncoder().wrap(bos))
    data = bos.toString("UTF-8")
    return {"display": "image", "data": data}
예제 #10
0
 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 test_parse_svgfile_and_convert_to_png_antenna(self):
     img_proc_dir = os.path.join(helpers.APP_PATH, "test", "res", "img_proc_png")
     input_svg_path = os.path.join(img_proc_dir, "input_antenna.svg")
     expected_image_path = os.path.join(img_proc_dir, "expected_antenna.png")
     
     assert os.path.exists(input_svg_path)
     
     rotation_x, rotation_y = 53, 43
     
     output_png_path = svgtopng.convert(input_svg_path, rotation_x, rotation_y)
     
     from javax.imageio import ImageIO
     from java.io import File
     bufferd_image = ImageIO.read(File(output_png_path))
     width, height = bufferd_image.getWidth(), bufferd_image.getHeight()
     output_image_matrix = [[bufferd_image.getRGB(i, j) for j in xrange(height)] for i in xrange(width)]
     
     bufferd_image = ImageIO.read(File(expected_image_path))
     width, height = bufferd_image.getWidth(), bufferd_image.getHeight()
     expected_image_matrix = [[bufferd_image.getRGB(i, j) for j in xrange(height)] for i in xrange(width)]
     
     for i in xrange(width):
         for j in xrange(height):
             exp_rgb_val = expected_image_matrix[i][j]
             result_rgb_val = output_image_matrix[i][j]
             assert exp_rgb_val == result_rgb_val
예제 #12
0
    def test_parse_svgfile_and_convert_to_png_background(self):
        img_proc_dir = os.path.join(helpers.APP_PATH, "test", "res",
                                    "img_proc_png")
        input_svg_path = os.path.join(img_proc_dir, "input_background.svg")
        expected_image_path = os.path.join(img_proc_dir,
                                           "expected_background.png")

        assert os.path.exists(input_svg_path)

        rotation_x, rotation_y = 255, 180

        output_png_path = svgtopng.convert(input_svg_path, rotation_x,
                                           rotation_y, ns_registry_lock)

        from javax.imageio import ImageIO
        from java.io import File
        bufferd_image = ImageIO.read(File(output_png_path))
        width, height = bufferd_image.getWidth(), bufferd_image.getHeight()
        output_image_matrix = [[
            bufferd_image.getRGB(i, j) for j in xrange(height)
        ] for i in xrange(width)]

        bufferd_image = ImageIO.read(File(expected_image_path))
        width, height = bufferd_image.getWidth(), bufferd_image.getHeight()
        expected_image_matrix = [[
            bufferd_image.getRGB(i, j) for j in xrange(height)
        ] for i in xrange(width)]

        for i in xrange(width):
            for j in xrange(height):
                exp_rgb_val = expected_image_matrix[i][j]
                result_rgb_val = output_image_matrix[i][j]
                assert exp_rgb_val == result_rgb_val
예제 #13
0
파일: jythonrc.py 프로젝트: suvarchal/JyIDV
def showImgWithLegend(width=None,height=None):
    """ This function shows the image and legend from current IDV window while in GUI mode. Optional arguments are width and height in pixels, they currently default to 600 and 400"""
    from java.util import Base64 ##only in java8
    from javax.imageio import ImageIO
    from java.io import ByteArrayOutputStream
    from ucar.unidata.ui.ImageUtils import resize,toBufferedImage
    import java
    import java.awt.Robot as Robot
    import java.awt.Rectangle as Rectangle
    import java.awt.Toolkit as Toolkit
    from ucar.unidata.util import Misc
    VM=idv.getViewManager()
    VMC=VM.getContents()
    VMCC=VMC.getComponent(1) # the view and legend ; 0 is left most part of view window with controls for perspective views
    siz=VMCC.getSize()
    loc= VMCC.getLocationOnScreen()
    gc= VMCC.getGraphicsConfiguration()
    loc.x -= gc.getBounds().x
    loc.y -= gc.getBounds().y
    robotx=Robot(gc.getDevice())
    VM.toFront()
    Misc.sleep(250)
    img = robotx.createScreenCapture(Rectangle(loc.x, loc.y,siz.width, siz.height))
    if width != None and height != None:
        img=toBufferedImage(resize(img,width,height));
    bos=ByteArrayOutputStream();
    ImageIO.write(img, "png", Base64.getEncoder().wrap(bos));
    data = bos.toString("UTF-8");
    return {"display":"image","data":data}
예제 #14
0
 def image_byte_array(self):
     baos = ByteArrayOutputStream();
     ImageIO.write( self.image(), "png", baos );
     baos.flush();
     image_bytes = baos.toByteArray();
     baos.close()
     return image_bytes
예제 #15
0
def save_editable_image_as_png_to_disk(editable_image, path, overwrite=False):
    assert isinstance(
        editable_image,
        BufferedImage), "No *editable* image (instance of ImageIO) given!"
    assert overwrite == True or os.path.isfile(
        path) == False, "File already exists"
    ImageIO.write(editable_image, "png", File(path))
예제 #16
0
    def test_parse_svgfile_and_convert_to_png_hat_q4(self):
        img_proc_dir = os.path.join(helpers.APP_PATH, "test", "res",
                                    "img_proc_png")
        input_svg_path = os.path.join(img_proc_dir, "input_hat.svg")

        assert os.path.exists(input_svg_path)

        rotation_x, rotation_y = 97, -51

        expected_image_path = os.path.join(
            img_proc_dir, "expected_hat" + "_rotX_" + str(rotation_x) +
            "_rotY_" + str(rotation_y) + ".png")

        output_png_path = svgtopng.convert(input_svg_path, rotation_x,
                                           rotation_y)

        from javax.imageio import ImageIO
        from java.io import File
        bufferd_image = ImageIO.read(File(output_png_path))
        width, height = bufferd_image.getWidth(), bufferd_image.getHeight()
        output_image_matrix = [[
            bufferd_image.getRGB(i, j) for j in xrange(height)
        ] for i in xrange(width)]

        bufferd_image = ImageIO.read(File(expected_image_path))
        width, height = bufferd_image.getWidth(), bufferd_image.getHeight()
        expected_image_matrix = [[
            bufferd_image.getRGB(i, j) for j in xrange(height)
        ] for i in xrange(width)]

        for i in xrange(width):
            for j in xrange(height):
                exp_rgb_val = expected_image_matrix[i][j]
                result_rgb_val = output_image_matrix[i][j]
                assert exp_rgb_val == result_rgb_val
예제 #17
0
파일: jythonrc.py 프로젝트: suvarchal/JyIDV
def showImgWithFullWindow(width=None,height=None):
    """ This function shows the image from current IDV window while in GUI mode. optional arguments are width and height in pixels, they
    currently default to 600 and 400"""
    from java.util import Base64 ##only in java8
    from javax.imageio import ImageIO
    from java.io import ByteArrayOutputStream
    from ucar.unidata.ui.ImageUtils import resize,toBufferedImage
    import java
    import java.awt.Robot as Robot
    import java.awt.Rectangle as Rectangle
    import java.awt.Toolkit as Toolkit
    from ucar.unidata.util import Misc
    VM=idv.getViewManager()
    myframe=VM.getDisplayWindow().getComponent()
    robotx = Robot(myframe.getGraphicsConfiguration().getDevice())
    VM.toFront();
    #robotx.delay(250)
    Misc.sleep(350)
    pause()
    img=robotx.createScreenCapture(Rectangle( myframe.getX(),myframe.getY(),myframe.getWidth(),myframe.getHeight()))
    if width != None and height != None:
        img=toBufferedImage(resize(img,width,height));
    bos=ByteArrayOutputStream();
    ImageIO.write(img, "png", Base64.getEncoder().wrap(bos));
    data = bos.toString("UTF-8");
    return {"display":"image","data":data}
예제 #18
0
파일: uxtst.py 프로젝트: egroise/uxtest
def _screenshot(name):
    name = name.replace("<","-").replace(">","-").replace(":","-").replace("|","-").replace("*","-").replace("\"","-").replace("/","-").replace("\\","-")
    from java.awt import Toolkit,Robot,Rectangle
    from javax.imageio import ImageIO
    from java.io import File  
    screenRect = Rectangle(Toolkit.getDefaultToolkit().getScreenSize())
    capture = Robot().createScreenCapture(screenRect)
    ImageIO.write(capture, "png", File(_UXTST_OUTPUT_PATH_ + name+".png"))
예제 #19
0
def jpg2bmp(src):
	# load jpg
	
	b = bmp_name(src)
	f = File(src)
	image = ImageIO.read(f)
	output = File(b)
	ImageIO.write(image,"bmp",output)
예제 #20
0
파일: jythonrc.py 프로젝트: suvarchal/JyIDV
def BufferedImgToNotebook(img):
    from java.io import ByteArrayOutputStream
    from java.util import Base64 ##only in java8
    from javax.imageio import ImageIO
    bos=ByteArrayOutputStream();
    ImageIO.write(img, "png", Base64.getEncoder().wrap(bos));
    data = bos.toString("UTF-8");
    return {"display":"image","data":data}
예제 #21
0
def convert(input_svg_path, rotation_x, rotation_y, ns_registry_lock):
    assert isinstance(input_svg_path, (str, unicode))
    assert os.path.splitext(input_svg_path)[1] == ".svg"

    input_file_name = os.path.splitext(input_svg_path)[0]
    output_png_path = "{}_rotX_{}_rotY_{}.png".format(input_file_name, rotation_x, rotation_y)
    _log.info("      converting '%s' to Pocket Code compatible png '%s'", input_svg_path, output_png_path)


    output_svg_path = input_svg_path.replace(".svg", "_modified.svg")
    output_svg_URI = Paths.get(output_svg_path).toUri().toURL().toString()

    if os.path.exists(output_png_path):
        _log.error("      '%s' already exists", output_png_path)
        #assert False # "Still a Duplicate?"
        # remove temporary files
        if os.path.exists(output_svg_path):
            os.remove(output_svg_path)
        return output_png_path # avoid duplicate conversions!

    png_ostream = None
    error = None
    try:
        _parse_and_rewrite_svg_file(input_svg_path, output_svg_path, ns_registry_lock)
        command = "svg2png"
        out = subprocess.check_output([command, output_svg_path, "-o", output_png_path])
        _log.info("      converting '%s' to Pocket Code compatible png '%s'",
                  input_svg_path, output_png_path)
        assert os.path.exists(output_png_path)

        final_image = _translation(output_png_path, rotation_x, rotation_y)

        if final_image is None:
            raise RuntimeError("...")

        from javax.imageio import ImageIO
        from java.io import File
        ImageIO.write(final_image, "PNG", File(output_png_path))
        return output_png_path
    except BaseException as err:
        import traceback
        import sys
        exc_info = sys.exc_info()
        _log.error(err)
        _log.error(traceback.format_exc())
        _log.error(exc_info)
        error = common.ScratchtobatError("SVG to PNG conversion call failed for: %s" % input_svg_path)
    finally:
        # free resources
        if png_ostream != None:
            png_ostream.flush()
            png_ostream.close()
        # remove temporary files
        if os.path.exists(output_svg_path):
            os.remove(output_svg_path)

    if error != None:
        raise error
예제 #22
0
파일: imagetool.py 프로젝트: bkap/MICT
	def getimage(self) :
		if not os.path.exists('tools/image.png') :
			imagedata = 'iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJ\nbWFnZVJlYWR5ccllPAAAAyJpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tldCBiZWdp\nbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1ldGEgeG1sbnM6\neD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUuMC1jMDYwIDYxLjEz\nNDc3NywgMjAxMC8wMi8xMi0xNzozMjowMCAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJo\ndHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlw\ndGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAv\nIiB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyIgeG1sbnM6c3RS\nZWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9zVHlwZS9SZXNvdXJjZVJlZiMiIHhtcDpD\ncmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHhtcE1NOkluc3RhbmNl\nSUQ9InhtcC5paWQ6MzZDNTFCOUZGNUQ5MTFERkE0Mzk4NUE5OTMzRTQwNzkiIHhtcE1NOkRvY3Vt\nZW50SUQ9InhtcC5kaWQ6MzZDNTFCQTBGNUQ5MTFERkE0Mzk4NUE5OTMzRTQwNzkiPiA8eG1wTU06\nRGVyaXZlZEZyb20gc3RSZWY6aW5zdGFuY2VJRD0ieG1wLmlpZDozNkM1MUI5REY1RDkxMURGQTQz\nOTg1QTk5MzNFNDA3OSIgc3RSZWY6ZG9jdW1lbnRJRD0ieG1wLmRpZDozNkM1MUI5RUY1RDkxMURG\nQTQzOTg1QTk5MzNFNDA3OSIvPiA8L3JkZjpEZXNjcmlwdGlvbj4gPC9yZGY6UkRGPiA8L3g6eG1w\nbWV0YT4gPD94cGFja2V0IGVuZD0iciI/Pms/CZAAAAECSURBVHjaYtRe+JiBloCJgcZg1IIhZYHV\ntzNARKoFLESqY/3/p+DNHCDjtKzBb0YW6vvA9/Numd/Pgcj/007qBxHfvy9p75ZC2CnvlwO5VLYg\n7d0Svr+foZb9/QzkUtMC1Z/3A1CDBcgFClLNgqK3s5j+/0PR8/8fUJA6Fth+PaX//RqmOFAQKEWp\nBcCkmft2Hi5ZoBRQAUUWRHzcCEyXuGSBUkAF5Fsg+udtwvtV+DUDFQCVkWlB9ruFnP9+4NcMVABU\nRo4FwFTo9vkgMXEIVIY/yWIvVTR+3dnI505kQgQqvs2uSJoF/nltxOdVVQaGzfNdRyucUQtGLRi1\ngAIAEGAAimxsT0J9RpkAAAAASUVORK5CYII=\n'
			actual_image = base64.b64decode(imagedata) 
			from java.io import ByteArrayInputStream
			stream = ByteArrayInputStream(actual_image)
			self._image = ImageIO.read(stream);
		else :
			self._image = ImageIO.read(File('tools/image.png'))
예제 #23
0
	def __output_image(self, f):
		out = io.FileOutputStream(f)
		size = self.preferredSize
		im = image.BufferedImage(size.width, size.height, image.BufferedImage.TYPE_INT_RGB)
		g2d = im.getGraphics()
		self.paint(g2d)
		ImageIO.write(im,'png',out)
		out.close()
		gui_status_bar.show_message("Image saved.")
예제 #24
0
def BufferedImgToNotebook(img):
    from java.io import ByteArrayOutputStream
    from java.util import Base64  ##only in java8
    from javax.imageio import ImageIO
    bos = ByteArrayOutputStream()
    ImageIO.write(img, "png",
                  Base64.getEncoder().wrap(bos))
    data = bos.toString("UTF-8")
    return {"display": "image", "data": data}
예제 #25
0
 def convertPNG(self, isStageCostume, costume_info, costume_src_path,
                costume_dest_path):
     import java.io.File
     new_image = svgtopng._translation(costume_src_path,
                                       costume_info["rotationCenterX"],
                                       costume_info["rotationCenterY"])
     ImageIO.write(new_image, "png", java.io.File(costume_dest_path))
     if JsonKeys.COSTUME_RESOLUTION in costume_info:
         self.resize_png(costume_dest_path, costume_dest_path,
                         costume_info[JsonKeys.COSTUME_RESOLUTION])
예제 #26
0
 def outputImage(self, bufferedImage, filename):
     if not filename.endswith(SUPPORTED_FORMATS):
         filename += SUPPORTED_FORMATS[0]
     imageType = filename[-3:]        
     from java.io import ByteArrayOutputStream, File
     from javax.imageio import ImageIO
     bytes = ByteArrayOutputStream()
     ImageIO.write(bufferedImage, imageType, bytes)
     f = File(filename)
     from com.raytheon.uf.common.util import FileUtil
     FileUtil.bytes2File(bytes.toByteArray(), f)
예제 #27
0
 def outputImage(self, bufferedImage, filename):
     if not filename.endswith(SUPPORTED_FORMATS):
         filename += SUPPORTED_FORMATS[0]
     imageType = filename[-3:]        
     from java.io import ByteArrayOutputStream, File
     from javax.imageio import ImageIO
     bytes = ByteArrayOutputStream()
     ImageIO.write(bufferedImage, imageType, bytes)
     f = File(filename)
     from com.raytheon.uf.common.util import FileUtil
     FileUtil.bytes2File(bytes.toByteArray(), f)
예제 #28
0
    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 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));
예제 #30
0
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))
예제 #31
0
파일: gif.py 프로젝트: ecor/geoscript-py
    def animated(images, file=None, delay=300, loop=False):
        """
     Generates an anmiated GIF. 

     The *images* parameter is a sequence of objects that can be read as 
     GIF images, such as an array of bytes.

     The *file* parameter specifies the file to generate. When omitted the 
     resulting animated GIF is returned from this function as an array byte. 

     The *delay* specifies the frame rate in milliseconds. 

     The *loop* parameter specifies whether the animated GIF should loop 
     continously.
     """
        from com.sun.media.imageioimpl.plugins.gif import GIFImageWriter
        from com.sun.media.imageioimpl.plugins.gif import GIFImageWriterSpi

        out = ByteArrayOutputStream() if file is None else util.toFile(file)
        ios = ImageIO.createImageOutputStream(out)
        w = GIFImageWriter(GIFImageWriterSpi())
        w.setOutput(ios)
        w.prepareWriteSequence(None)

        wp = w.getDefaultWriteParam()
        wp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT)
        wp.setCompressionType('LZW')
        wp.setCompressionQuality(0.75)

        for img in images:
            iis = ImageIO.createImageInputStream(util.toInputStream(img))
            ri = ImageIO.read(iis)

            md = w.getDefaultImageMetadata(ImageTypeSpecifier(ri), wp)
            t = IIOMetadataTree(md)
            t.set('GraphicControlExtension', delayTime=delay / 10)
            if loop is True:
                n = t.set('ApplicationExtensions',
                          'ApplicationExtension',
                          applicationID='NETSCAPE',
                          authenticationCode='2.0')
                n.setUserObject(jarray.array([0x1, 0, 0], 'b'))
            t.commit()

            w.writeToSequence(IIOImage(ri, None, md), wp)

        w.endWriteSequence()
        ios.flush()
        ios.close()

        if file is None:
            return out.toByteArray()
    def enlargeimage(self,image,imagewidth,imageheight):
        imageFile = open(image);
        ###j make image bigger for easier reading
        i = ImageIO.read(imageFile)
        largeimage = i.getScaledInstance(imagewidth, imageheight, awt.Image.SCALE_SMOOTH)
        bImage = awt.image.BufferedImage(largeimage.getWidth(),largeimage.getHeight(),awt.image.BufferedImage.TYPE_INT_ARGB)
        g = bImage.createGraphics()
        g.drawImage(largeimage,0,0,None)
        g.dispose()
        outputfile = File(image)
        ImageIO.write(bImage, "png", outputfile)
 
        return re.sub("[^a-zA-Z0-9\.\- ]","", Image.text(image))
예제 #33
0
	def cbCB(self,e):
		try:
			item=self.cb.getSelectedItem()
			if DEBUG:print item
			if self.hostname[0:7]=='http://':
				self.img=ImageIO.read(URL(self.hostname+'/static/sightreadingtrainer/img/'+item))
			else:
				self.img=ImageIO.read(File(self.hostname+'img/'+item))
			
			if DEBUG:print self.img
			icon=ImageIcon(self.img)
			self.label.setIcon(icon)
		except Exception,e:
			if DEBUG:print e
예제 #34
0
파일: gif.py 프로젝트: bakk/geoscript-py
   def animated(images, file=None, delay=300, loop=False):
     """
     Generates an anmiated GIF. 

     The *images* parameter is a sequence of objects that can be read as 
     GIF images, such as an array of bytes.

     The *file* parameter specifies the file to generate. When omitted the 
     resulting animated GIF is returned from this function as an array byte. 

     The *delay* specifies the frame rate in milliseconds. 

     The *loop* parameter specifies whether the animated GIF should loop 
     continously.
     """
     from com.sun.media.imageioimpl.plugins.gif import GIFImageWriter
     from com.sun.media.imageioimpl.plugins.gif import GIFImageWriterSpi

     out = ByteArrayOutputStream() if file is None else util.toFile(file)
     ios = ImageIO.createImageOutputStream(out)
     w = GIFImageWriter(GIFImageWriterSpi())
     w.setOutput(ios)
     w.prepareWriteSequence(None)

     wp = w.getDefaultWriteParam()
     wp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT)
     wp.setCompressionType('LZW')
     wp.setCompressionQuality(0.75)

     for img in images:   
       iis = ImageIO.createImageInputStream(util.toInputStream(img))
       ri = ImageIO.read(iis)

       md = w.getDefaultImageMetadata(ImageTypeSpecifier(ri),wp)
       t = IIOMetadataTree(md)
       t.set('GraphicControlExtension', delayTime=delay/10)
       if loop is True:
         n = t.set('ApplicationExtensions', 'ApplicationExtension', 
           applicationID='NETSCAPE', authenticationCode='2.0')
         n.setUserObject(jarray.array([0x1,0, 0], 'b'))
       t.commit()

       w.writeToSequence(IIOImage(ri, None, md), wp)

     w.endWriteSequence()
     ios.flush()
     ios.close()

     if file is None:
       return out.toByteArray()
예제 #35
0
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));
예제 #36
0
def showImg(width=400,height=300):
    """ This function shows the image from current IDV frame, optional arguments are width and height in pixels, they
    currently default to 400 and 300"""
    from java.util import Base64 ##only in java8
    from javax.imageio import ImageIO
    from java.io import ByteArrayOutputStream
    from ucar.unidata.ui.ImageUtils import resize,toBufferedImage
    pause()
    img=getImage() 
    img=toBufferedImage(resize(img,width,height));
    bos=ByteArrayOutputStream();
    ImageIO.write(img, "png", Base64.getEncoder().wrap(bos));
    data = bos.toString("UTF-8");
    return {"display":"image","data":data}
예제 #37
0
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))
예제 #38
0
    def save_screenshot_to(self, path):
        """Saves a screenshot to the specified file.

        The directory holding the file must exist or an exception is raised.
        """
        path = os.path.abspath(path.replace('/', os.sep))
        if not os.path.exists(os.path.dirname(path)):
            raise RuntimeError("Directory '%s' where to save the screenshot does "
                            "not exist" % os.path.dirname(path))
        screensize = Toolkit.getDefaultToolkit().getScreenSize()
        rectangle = Rectangle(0, 0, screensize.width, screensize.height)
        image = Robot().createScreenCapture(rectangle)
        ImageIO.write(image, "jpg", File(path))
        print "Screenshot saved to '%s'" % path
        return path
예제 #39
0
 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"
예제 #40
0
파일: jythonrc.py 프로젝트: suvarchal/JyIDV
def showImg(width=None,height=None):
    """ This function shows the image from current IDV frame, optional arguments are width and height in pixels, they
    currently default to 400 and 300"""
    from java.util import Base64 ##only in java8
    from javax.imageio import ImageIO
    from java.io import ByteArrayOutputStream
    from ucar.unidata.ui.ImageUtils import resize,toBufferedImage
    pause()
    #imgx=getImage() currently not working with new changes to idv
    img=idv.getViewManager().getMaster().getImage(True)
    if width != None and height != None:
        img=toBufferedImage(resize(img,width,height));
    bos=ByteArrayOutputStream();
    ImageIO.write(img, "png", Base64.getEncoder().wrap(bos));
    data = bos.toString("UTF-8");
    return {"display":"image","data":data}
예제 #41
0
    def _read_image(self, fp):
        if sys.platform[0:4] == "java":
            from javax.imageio import ImageIO

            return ImageIO.read(fp)
        else:
            return Image.open(fp)
예제 #42
0
    def save_screenshot_to(self, path):
        """Saves a screenshot to the specified file.

        The directory holding the file must exist or an exception is raised.
        """
        path = os.path.abspath(path.replace('/', os.sep))
        if not os.path.exists(os.path.dirname(path)):
            raise RuntimeError(
                "Directory '%s' where to save the screenshot does "
                "not exist" % os.path.dirname(path))
        screensize = Toolkit.getDefaultToolkit().getScreenSize()
        rectangle = Rectangle(0, 0, screensize.width, screensize.height)
        image = Robot().createScreenCapture(rectangle)
        ImageIO.write(image, "jpg", File(path))
        print "Screenshot saved to '%s'" % path
        return path
예제 #43
0
    def read(self, filename):
        """Read an image from a .png, .gif, or .jpg file. as 2D list of RGB pixels."""

        # JEM working directory fix (see above)
        filename = fixWorkingDirForJEM(filename)  # does nothing if not in JEM

        # ***
        #print "fixWorkingDirForJEM( filename ) =", filename

        file = File(filename)  # read file from current directory
        self.image = ImageIO.read(file)
        self.width = self.image.getWidth(None)
        self.height = self.image.getHeight(None)

        pixels = []  # initialize list of pixels

        # load pixels from image
        for row in range(self.height):
            pixels.append([])  # add another empty row
            for col in range(self.width):  # now, populate row with pixels
                color = Color(self.image.getRGB(col, row))  # get pixel's color
                RGBlist = [color.getRed(),
                           color.getGreen(),
                           color.getBlue()
                           ]  # create list of RGB values (0-255)
                pixels[-1].append(
                    RGBlist)  # add a pixel as (R, G, B) values (0-255, each)

        # now, pixels have been loaded from image file, so create an image
        self.setPixels(pixels)
예제 #44
0
def loadImage(filepath):

    fp = open(filepath, 'r')
    image = ImageIO.read(fp)
    fp.close()
    
    return image
예제 #45
0
 def readImg(filename):
     from java.io import File
     from javax.imageio import ImageIO
     import sys, os
     scriptDir = os.path.dirname(sys.argv[0])
     return ImageIO.read(
         File(os.path.join(scriptDir, "stateDetectionImages", filename)))
예제 #46
0
파일: image.py 프로젝트: HenryStevens/jes
   def read(self, filename): 
      """Read an image from a .png, .gif, or .jpg file. as 2D list of RGB pixels."""
      
      # JEM working directory fix (see above)
      filename = fixWorkingDirForJEM( filename )   # does nothing if not in JEM
	  
      # ***
      #print "fixWorkingDirForJEM( filename ) =", filename

      file = File(filename)    # read file from current directory
      self.image = ImageIO.read(file)
      self.width  = self.image.getWidth(None)
      self.height = self.image.getHeight(None)
      
      pixels = []   # initialize list of pixels
      
      # load pixels from image
      for row in range(self.height):
         pixels.append( [] )   # add another empty row
         for col in range(self.width):   # now, populate row with pixels
            color = Color(self.image.getRGB(col, row))  # get pixel's color
            RGBlist = [color.getRed(), color.getGreen(), color.getBlue()]  # create list of RGB values (0-255)
            pixels[-1].append( RGBlist )   # add a pixel as (R, G, B) values (0-255, each)

      # now, pixels have been loaded from image file, so create an image
      self.setPixels(pixels)
예제 #47
0
 def gui_open(path):
     label = JLabel(ImageIcon(ImageIO.read(File(URL(path).getFile()))))
     frame = JFrame()
     frame.getContentPane().add(label)
     frame.pack()
     frame.setLocation(200, 200)
     frame.setVisible(True)
예제 #48
0
def getColorFormImage(fn):
    f = jf.File(fn) 
    img =  IIO.read(f)
    x = img.getWidth()/2
    y = img.getHeight()/2
    #print "gk "+str(x) +str(y)
    return JColor(img.getRGB(x,y))
예제 #49
0
파일: utils.py 프로젝트: jjesquea/wms
 def _read_image(self,fp):
     if sys.platform[0:4] == 'java':
         from javax.imageio import ImageIO
         return ImageIO.read(fp)
     else:
         import PIL.Image
         return PIL.Image.open(fp)
예제 #50
0
   def _encode(self, img, g, size, **opts):
      file = opts['file'] if opts.has_key('file') else None
      if file:
        # write out to file
        ImageIO.write(img, self.format, util.toFile(file))
      else:
        # write to byte array
        out = ByteArrayOutputStream()
        ImageIO.write(img, self.format, out)
        bytes = out.toByteArray()

        # check for strencode flag to check whether to return result as raw 
        # bytes or as string
        if opts.has_key('strencode'):
          return str(String(bytes, 0, 0, len(bytes)))
        return out.toByteArray()
예제 #51
0
파일: image.py 프로젝트: ecor/geoscript-py
    def _encode(self, img, g, size, **opts):
        file = opts['file'] if opts.has_key('file') else None
        if file:
            # write out to file
            ImageIO.write(img, self.format, util.toFile(file))
        else:
            # write to byte array
            out = ByteArrayOutputStream()
            ImageIO.write(img, self.format, out)
            bytes = out.toByteArray()

            # check for strencode flag to check whether to return result as raw
            # bytes or as string
            if opts.has_key('strencode'):
                return str(String(bytes, 0, 0, len(bytes)))
            return out.toByteArray()
예제 #52
0
def json_encoded_values(im_paths):
    import simplejson as json
    
    list_of_dicts = []
    list_of_names = ('string', 'base64', 'hash')
    
    for im_pth in im_paths:
        im = ImageIO.read(File(im_pth))
        
        list_of_dicts.append(dict(
            color_layout=dict(
                zip(list_of_names,
                    test_color_layout(im, silence=True))),
            
            edge_histogram=dict(
                zip(list_of_names,
                    test_edge_histogram(im, silence=True))),
            
            phog=dict(
                zip(list_of_names,
                   test_PHOG(im, silence=True))),
            
            opponent_histogram=dict(
                zip(list_of_names,
                    test_opponent_histogram(im, silence=True))),
            
            # jcd=dict(
            #     zip(list_of_names,
            #        test_JCD(im, silence=True))),
        ))
    
    print json.dumps(list_of_dicts, indent=4)
예제 #53
0
def readable_values(im_paths):
    from os.path import basename
    
    for im_pth in im_paths:
        im = ImageIO.read(File(im_pth))
        print ""
        print "-" * 120
        print ""
        print "IMAGE: %s" % basename(im_pth)
        
        for histoval in test_color_layout(im):
            print histoval
        
        for histoval in test_edge_histogram(im):
            print histoval
        
        for histoval in test_PHOG(im):
           print histoval
        
        for histoval in test_opponent_histogram(im):
            print histoval
        
        #for histoval in test_JCD(im):
        #   print histoval
        
        print ""
예제 #54
0
파일: __init__.py 프로젝트: uleming/Indigo
    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
예제 #55
0
def showImg(width=None, height=None):
    """ This function shows the image from current IDV frame, optional arguments are width and height in pixels, they
    currently default to 400 and 300"""
    from java.util import Base64  ##only in java8
    from javax.imageio import ImageIO
    from java.io import ByteArrayOutputStream
    from ucar.unidata.ui.ImageUtils import resize, toBufferedImage
    pause()
    #imgx=getImage() currently not working with new changes to idv
    img = idv.getViewManager().getMaster().getImage(True)
    if width != None and height != None:
        img = toBufferedImage(resize(img, width, height))
    bos = ByteArrayOutputStream()
    ImageIO.write(img, "png",
                  Base64.getEncoder().wrap(bos))
    data = bos.toString("UTF-8")
    return {"display": "image", "data": data}
 def _read_image(self, fp):
     if sys.platform[0:4] == 'java':
         from javax.imageio import ImageIO
         from java.io import ByteArrayInputStream
         input_stream = ByteArrayInputStream(fp.read())
         return ImageIO.read(input_stream)
     elif PILImage:
         return PILImage.open(fp)
예제 #57
0
    def __init__(self,
                 actions,
                 mapname,
                 colormap,
                 name="PlaceCellEnvironment",
                 imgsize=(1.0, 1.0),
                 dx=0.01,
                 placedev=0.1,
                 num_places=None):
        """Initialize environment variables.

        :param actions: actions available to the system
            :type actions: list of tuples (action_name,action_vector)
        :param mapname: name of file describing environment map
        :param colormap: dict mapping pixel colours to labels
        :param name: name for environment
        :param imgsize: width of space represented by the map image
        :param dx: distance agent moves each timestep
        :param placedev: standard deviation of gaussian place cell activations
        :param num_places: number of placecells to use (if None it will attempt
            to fill the space)
        """

        EnvironmentTemplate.__init__(self, name, 2, actions)

        # parameters
        self.colormap = colormap
        self.rewardamount = 0  # number of timesteps spent in reward

        # number of timesteps to spend in reward before agent is reset
        # note: convenient to express this as time_in_reward / dt
        self.rewardresetamount = 0.6 / 0.001

        self.num_actions = len(actions)
        self.imgsize = [float(x) for x in imgsize]
        self.dx = dx
        self.placedev = placedev
        self.num_places = num_places
        self.optimal_move = None
        self.defaultreward = -0.075

        # load environment
        self.map = ImageIO.read(File(HRLutils.datafile(mapname)))

        # generate place cells
        self.gen_placecells(min_spread=1.0 * placedev)

        # initial conditions
        self.state = self.random_location(avoid=["wall", "target"])
        self.place_activations = [0 for _ in self.placecells]

        self.create_origin("place", lambda: self.place_activations)

        # note: making the value small, so that the noise node will give us
        # some random exploration as well
        self.create_origin(
            "optimal_move", lambda:
            [0.1 if self.optimal_move == a[0] else 0.0 for a in self.actions])
예제 #58
0
    def create_icon(self, path):
        try:
            im = ImageIO.read(File(path))
        except:
            raise

        im = im.getScaledInstance(32, 32, Image.SCALE_SMOOTH)
        icon = ImageIcon(im)
        return icon
예제 #59
0
 def next(self):
     image_file_name = self.iterator.next()
     #Find example label
     label = image_file_name[0:image_file_name.index('_')]
     #Get the image as an image buffer
     image_file = File(dir_path, image_file_name)
     image_is = FileInputStream(image_file)
     buffered_image = ImageIO.read(image_is)
     #Return label and image tuple
     return (label, buffered_image)