/** constructor */
 public DanceQueuePanel() {
   //	flow layout
   setLayout(new FlowLayout());
   //	uses buffer	to	draw arrows	based	on	queues in an array
   myImage = new BufferedImage(600, 600, BufferedImage.TYPE_INT_RGB);
   myBuffer = myImage.getGraphics();
   // uses timer to queue buffer changes
   time = 0;
   timer = new Timer(5, new Listener());
   timer.start();
   setFocusable(true);
   // picks instructions	based	on	song & level
   if (Danceoff.getSong() == -1 && Danceoff.getDifficulty() == 0) {
     arrows = new Arrow[] {new UpArrow(1000), new DownArrow(2000), new LeftArrow(3000)};
   }
   // setBorder(BorderFactory.createTitledBorder(BorderFactory.createLineBorder(Color.BLACK, 3),
   //	"DanceQueuePanel"));
   // load images for arrows
   rightArrowImg = null;
   leftArrowImg = null;
   upArrowImg = null;
   downArrowImg = null;
   try {
     rightArrowImg = ImageIO.read(new File("arrowB right.png"));
     leftArrowImg = ImageIO.read(new File("arrowB left.png"));
     upArrowImg = ImageIO.read(new File("arrowB up copy.png"));
     downArrowImg = ImageIO.read(new File("arrowB down.png"));
   } catch (IOException e) {
     warn("YOU FAIL", e);
     System.exit(2);
   }
 }
  /**
   * Testing TIFF capabilities.
   *
   * @throws IOException If an error occured while writting the image.
   */
  @Test
  public void testTIFFWrite() throws IOException {
    assertTrue("Assertions should be enabled.", ImageWorker.class.desiredAssertionStatus());
    // Get the image of the world with transparency.
    final ImageWorker worker = new ImageWorker(worldImage);
    show(worker, "Input file");

    // /////////////////////////////////////////////////////////////////////
    // tiff deflated untiled
    // /////////////////////////////////////////////////////////////////////
    final File outFile = TestData.temp(this, "temp.tiff");
    worker.writeTIFF(outFile, "Deflate", 0.75f, -1, -1);
    final ImageWorker readWorker = new ImageWorker(ImageIO.read(outFile));
    show(readWorker, "Tiff untiled");

    // /////////////////////////////////////////////////////////////////////
    // tiff deflated compressed tiled
    // /////////////////////////////////////////////////////////////////////
    worker.setImage(worldImage);
    worker.writeTIFF(outFile, "Deflate", 0.75f, 32, 32);
    readWorker.setImage(ImageIO.read(outFile));
    show(readWorker, "Tiff jpeg compressed, tiled");

    outFile.delete();
  }
 /**
  * Convert a source to a BufferedImage. Source supported:
  * File,BufferedImage,InputStream,URL,ImageInputStream, byte[]
  *
  * @param imageType the ImageType to use
  * @param source source to generate BufferedImage from
  * @return Enhanced BufferedImage
  * @throws NullPointerException _
  * @throws IOException _
  * @throws UnsupportedOperationException throws this is the source is of unsupported type
  */
 public static <T> BufferedImage convertImageType(final ImageType imageType, final T source)
     throws NullPointerException, IOException, UnsupportedOperationException {
   if (verifyNotNull(imageType, source)) {
     BufferedImage target = null;
     if (source instanceof File) {
       target = convert(ImageIO.read((File) source), imageType);
     } else if (source instanceof BufferedImage) {
       target = convert((BufferedImage) source, imageType);
     } else if (source instanceof InputStream) {
       target = convert(ImageIO.read((InputStream) source), imageType);
     } else if (source instanceof URL) {
       target = convert(ImageIO.read((URL) source), imageType);
     } else if (source instanceof ImageInputStream) {
       target = convert(ImageIO.read((ImageInputStream) source), imageType);
     } else if (source instanceof byte[]) {
       final InputStream streamOfInput = new ByteArrayInputStream((byte[]) source);
       target = convert(ImageIO.read(streamOfInput), imageType);
     } else {
       throw new UnsupportedOperationException("%s is not supported. Read JavaDoc.");
     }
     if (verifyNotNull(target)) {
       LOGGER.info(
           String.format(
               "Returning requested converted object<%s> as target", target.getClass().getName()));
       return target;
     }
     throw new NullPointerException("Return value was null.");
   }
   throw new NullPointerException("Nilled param detected. Please verify your params!");
 }
  /**
   * Salva BufferedImage no arquivo informado na prop<br>
   *
   * <p><b>Exemplo:><br>
   * <code>salvarImagem(img)</code>
   *
   * @param img BufferedImage a ser salva
   * @author roberto
   */
  private void salvarImagem(BufferedImage img) {

    ImageWriter writer = null;
    Iterator<ImageWriter> iter = ImageIO.getImageWritersByFormatName(formatoImagem);

    if (iter.hasNext()) {

      writer = (ImageWriter) iter.next();
    }

    ImageOutputStream ios;
    try {

      ios = ImageIO.createImageOutputStream(new File(prop.getProp("dirImg")));
      writer.setOutput(ios);

      ImageWriteParam param = new JPEGImageWriteParam(java.util.Locale.getDefault());
      param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
      param.setCompressionQuality(1);

      writer.write(null, new IIOImage(img, null, null), param);

    } catch (IOException e) {
      e.printStackTrace();
    }
  }
  public static void main(String[] args) {
    try {
      System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

      File input = new File("traffic_signal.jpg");
      BufferedImage image = ImageIO.read(input);

      byte[] data = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
      Mat mat = new Mat(image.getHeight(), image.getWidth(), CvType.CV_8UC3);
      mat.put(0, 0, data);

      Mat mat1 = new Mat(image.getHeight(), image.getWidth(), CvType.CV_8UC1);
      Imgproc.cvtColor(mat, mat1, Imgproc.COLOR_RGB2GRAY);

      byte[] data1 = new byte[mat1.rows() * mat1.cols() * (int) (mat1.elemSize())];
      mat1.get(0, 0, data1);
      BufferedImage image1 =
          new BufferedImage(mat1.cols(), mat1.rows(), BufferedImage.TYPE_BYTE_GRAY);
      image1.getRaster().setDataElements(0, 0, mat1.cols(), mat1.rows(), data1);

      File ouptut = new File("output\\grayscale_" + new Date().getTime() + ".jpg");
      ImageIO.write(image1, "jpg", ouptut);
    } catch (Exception e) {
      System.out.println("Error: " + e.getMessage());
    }
  }
Beispiel #6
0
  public void writeImageToStream(OutputStream os, String fileName, BufferedImage img) {
    // if we get here we need to save the image from the memory
    try {
      // try to write image using the format of the filename extension
      int pos = fileName.lastIndexOf('.');
      String ext = fileName.substring(pos + 1).toLowerCase(Locale.US);
      if (ext.equals("jpg") || ext.equals("jpeg")) ext = "JPG";
      else ext = "PNG";

      // circumvent security issues by disabling disk-based caching
      if (app.isApplet()) {
        javax.imageio.ImageIO.setUseCache(false);
      }

      ImageIO.write(img, ext, os);

      // restore caching to prevent side-effects
      if (app.isApplet()) {
        javax.imageio.ImageIO.setUseCache(true);
      }
    } catch (Exception e) {
      Application.debug(e.getMessage());
      try {
        // if this did not work save image as png
        ImageIO.write(img, "png", os);
      } catch (Exception ex) {
        Application.debug(ex.getMessage());
        return;
      }
    }
  }
  public void run(String[] args) {
    File inDir = new File("input/SampleZoomLevel");
    File outFile = new File("output/SampleZoomLevel/map.png");
    File[] fileList = inDir.listFiles();

    int i;
    // Stitching a map with 4 rows and 4 columns; the program is generalized,
    // so you can use higher multiples of 4, such as 8 by 8 and 16 by 16.
    int rows = 4;
    int cols = 4;
    int total = rows * cols;

    BufferedImage images[] = new BufferedImage[total];

    try {
      for (i = 0; i < total; i++) {
        File inFile = fileList[i];

        int c1;
        int c2;
        // The code below deals with the naming convention we use
        // for each map tile.
        // See the ReadMe for more on the naming convention.
        String s = inFile.getName().substring(0, 2);
        c1 = Integer.parseInt(s);
        s = inFile.getName().substring(3, 5);
        c2 = Integer.parseInt(s);

        BufferedImage image = null;

        image = ImageIO.read(inFile);
        images[c1 * cols + c2] = image;
      }

    } catch (IOException e) {
      System.err.println(e);
      System.exit(1);
    }

    // Our map tiles are square, with dimensions of 256 by 256 pixels.  With 4 rows and 	//4
    // columns, we create a 1024 by 1024 image.

    BufferedImage outputImage =
        new BufferedImage(256 * cols, 256 * rows, BufferedImage.TYPE_INT_ARGB_PRE);
    Graphics2D g = outputImage.createGraphics();

    // Loop through the rows and columns
    for (i = 0; i < rows; i++) {
      for (int j = 0; j < cols; j++) {
        g.drawImage(images[i * cols + j], j * 256, i * 256, 256, 256, null);
      }
    }

    try {
      ImageIO.write(outputImage, "png", outFile);
    } catch (IOException e) {
      System.err.println(e);
      System.exit(1);
    }
  }
 /**
  * Resize image bytes to a max width or height image size.
  *
  * @param inputBytes input image bytes
  * @param max max size
  * @return scaled image bytes
  * @throws IOException on error
  */
 public static byte[] resizeImage(byte[] inputBytes, int max) throws IOException {
   BufferedImage inputImage = ImageIO.read(new ByteArrayInputStream(inputBytes));
   BufferedImage outputImage = resizeImage(inputImage, max);
   ByteArrayOutputStream baos = new ByteArrayOutputStream();
   ImageIO.write(outputImage, "jpg", baos);
   return baos.toByteArray();
 }
  public static BufferedImage encodeImage(String filename, int[] primes) {
    /* encodes a and b in the image using a sequence.
     * We are assuming that the image would be big enough
     * to hold the 16 bits
     */

    BufferedImage img, newimg = null;
    int[] a = convertToBinary(primes[0], 8);
    int[] b = convertToBinary(primes[1], 8);
    int[] a_b = copyBits(a, b); // copy all bits into one array

    try {
      img = ImageIO.read(new File(imagePath + filename));
      for (int i = 0; i < a_b.length; i++) {
        int p = img.getRGB(i, i);
        int[] bin = convertToBinary(p, 32);
        bin[0] = a_b[i];
        int d = convertToDigit(bin, 32);
        img.setRGB(i, i, d);
      }
      ImageIO.write(img, "png", new File(imagePath + "new_" + filename));
      newimg = ImageIO.read(new File(imagePath + "new_" + filename));
    } catch (IOException e) {
      System.out.println("ERROR WRITING IMAGE...\n" + e.toString());
      System.exit(1);
    }

    return newimg;
  }
Beispiel #10
0
  private BufferedImage getImageIcon(String fileName) throws KettleException {
    InputStream inputStream = null;
    try {
      BufferedImage image = ImageIO.read(new File(fileName));
      if (image == null) {
        image = ImageIO.read(new File("/" + fileName));
      }
      if (image == null) {
        inputStream = getClass().getResourceAsStream(fileName);
        if (inputStream == null) {
          inputStream = getClass().getResourceAsStream("/" + fileName);
        }
        if (inputStream == null) {
          throw new KettleException("Unable to load image from file : '" + fileName + "'");
        }
        image = ImageIO.read(inputStream);
      }

      WaitingImageObserver observer = new WaitingImageObserver(image);
      observer.waitImageLoaded();

      return image;
    } catch (Throwable e) {
      throw new KettleException("Unable to load image from file : '" + fileName + "'", e);
    } finally {
      if (inputStream != null) {
        try {
          inputStream.close();
        } catch (IOException e) {
          throw new KettleException("Unable to close image reading stream", e);
        }
      }
    }
  }
Beispiel #11
0
  public Rect(int x, int y, Color color, int width, int height, String bokstav_) {
    this.x = x;
    this.y = y;
    this.width = width;
    this.height = height;
    this.color = color;
    this.bokstav = bokstav_;
    this.alive = false;

    // ... Initiate Images
    try {
      image = ImageIO.read(this.getClass().getClassLoader().getResourceAsStream("Untitled-10.png"));
    } catch (IOException ex) {
    }
    try {
      alive_image =
          ImageIO.read(this.getClass().getClassLoader().getResourceAsStream("Untitled-12.png"));
    } catch (IOException ex) {
    }
    try {
      dead_image =
          ImageIO.read(this.getClass().getClassLoader().getResourceAsStream("Untitled-11.png"));
    } catch (IOException ex) {
    }
  }
Beispiel #12
0
  /**
   * Compress and save an image to the disk. Currently this method only supports JPEG images.
   *
   * @param image The image to save
   * @param toFileName The filename to use
   * @param type The image type. Use <code>ImageUtils.IMAGE_JPEG</code> to save as JPEG images, or
   *     <code>ImageUtils.IMAGE_PNG</code> to save as PNG.
   */
  public static void saveCompressedImage(BufferedImage image, String toFileName, int type) {
    try {
      if (type == IMAGE_PNG) {
        throw new UnsupportedOperationException("PNG compression not implemented");
      }

      Iterator iter = ImageIO.getImageWritersByFormatName("jpg");
      ImageWriter writer;
      writer = (ImageWriter) iter.next();

      ImageOutputStream ios = ImageIO.createImageOutputStream(new File(toFileName));
      writer.setOutput(ios);

      ImageWriteParam iwparam = new JPEGImageWriteParam(Locale.getDefault());

      iwparam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
      iwparam.setCompressionQuality(0.7F);

      writer.write(null, new IIOImage(image, null, null), iwparam);

      ios.flush();
      writer.dispose();
      ios.close();
    } catch (IOException e) {
      throw new ForumException(e);
    }
  }
  /** loads the sprites to be used for the bots */
  public static void loadSprites() {

    try {

      mainImageEast = ImageIO.read(new File("char/archer_east.png"));
      mainImageWest = ImageIO.read(new File("char/archer_west.png"));

      north = new BufferedImage[frameCount];
      south = new BufferedImage[frameCount];
      east = new BufferedImage[frameCount];
      west = new BufferedImage[frameCount];
      north_east = new BufferedImage[frameCount];
      north_west = new BufferedImage[frameCount];
      south_east = new BufferedImage[frameCount];
      south_west = new BufferedImage[frameCount];

      for (int i = 0; i < frameCount; i++) {
        north[i] = mainImageEast.getSubimage(0 * width, height * i, width, height);
        north_east[i] = mainImageEast.getSubimage(1 * width, height * i, width, height);
        east[i] = mainImageEast.getSubimage(2 * width, height * i, width, height);
        south_east[i] = mainImageEast.getSubimage(3 * width, height * i, width, height);
        south[i] = mainImageEast.getSubimage(4 * width, height * i, width, height);

        north_west[i] = mainImageWest.getSubimage(3 * width, height * i, width, height);
        west[i] = mainImageWest.getSubimage(2 * width, height * i, width, height);
        south_west[i] = mainImageWest.getSubimage(1 * width, height * i, width, height);
      }

    } catch (Exception e) {
      System.out.println("Spritesheet Not Found!");
    }
  }
  public byte[] picdecolour(String picid, String type, boolean profPic) {
    try {
      BufferedImage BI = ImageIO.read(new File("/var/tmp/instagrAndrew/" + picid));
      BufferedImage processed = doTints(BI, this.tintValue, this.greyValue, false, profPic);

      if (this.contrastValue != 0f) {
        processed = doContrast(processed, this.contrastValue);
      }

      if (this.rotateValue != null) {
        processed = rotate(processed, rotateValue, null);
      }
      if (this.flipValue != null) {
        processed = rotate(processed, flipValue, null);
      }

      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      ImageIO.write(processed, type, baos);
      baos.flush();
      byte[] imageInByte = baos.toByteArray();
      baos.close();
      return imageInByte;
    } catch (IOException et) {

    }
    return null;
  }
Beispiel #15
0
  /**
   * Loads an image from the supplied input stream. Supports formats supported by {@link ImageIO}
   * but not {@link FastImageIO}.
   */
  protected static BufferedImage loadImage(InputStream iis) throws IOException {
    BufferedImage image;

    if (iis instanceof ImageInputStream) {
      image = ImageIO.read(iis);

    } else {
      // if we don't already have an image input stream, create a memory cache image input
      // stream to avoid causing freakout if we're used in a sandbox because ImageIO
      // otherwise use FileCacheImageInputStream which tries to create a temp file
      MemoryCacheImageInputStream mciis = new MemoryCacheImageInputStream(iis);
      image = ImageIO.read(mciis);
      try {
        // this doesn't close the underlying stream
        mciis.close();
      } catch (IOException ioe) {
        // ImageInputStreamImpl.close() throws an IOException if it's already closed;
        // there's no way to find out if it's already closed or not, so we have to check
        // the exception message to determine if this is actually warning worthy
        if (!"closed".equals(ioe.getMessage())) {
          log.warning("Failure closing image input '" + iis + "'.", ioe);
        }
      }
    }

    // finally close our input stream
    StreamUtil.close(iis);

    return image;
  }
Beispiel #16
0
    @Override
    protected void ensureContentAvailable() {
      if (!isContentAvailable()) {
        try {
          contentURL = createWadoURL(getMimeType(), -1);
        } catch (Exception e) {
          log.error("Unable to get image document WADO URL!", e);
        }
        try {
          Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName("dicom");
          if (readers != null && readers.hasNext()) {
            List<org.dcm4chee.archive.entity.File> files =
                ((TCQueryLocal) JNDIUtils.lookup(TCQueryLocal.JNDI_NAME))
                    .findInstanceByUID(getSOPInstanceUID())
                    .getFiles();
            String fsId = files.get(0).getFileSystem().getDirectoryPath();
            String fileId = files.get(0).getFilePath();

            ImageReader reader = readers.next();
            reader.setInput(
                ImageIO.createImageInputStream(
                    fsId.startsWith("tar:")
                        ? TarRetrieveDelegate.getInstance().retrieveFileFromTar(fsId, fileId)
                        : FileUtils.resolve(new File(fsId, fileId))),
                true);
            contentImage = reader.read(0);
            thumbnailImage = toThumbnailImage(contentImage);
          }
        } catch (Exception e) {
          log.error("Unable to convert encapsulated image to image!", e);
        }
      }
    }
  @Test
  public void lossyWrite() throws Exception {
    File f = File.createTempFile("test-jpeg2000-lossy", ".jp2");
    f.deleteOnExit();
    Iterator<ImageWriter> writers = ImageIO.getImageWritersBySuffix("jp2");
    assertTrue(writers.hasNext());
    ImageWriter writer = writers.next();
    J2KImageWriteParam writeParams = (J2KImageWriteParam) writer.getDefaultWriteParam();
    writeParams.setLossless(false);
    writeParams.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
    writeParams.setCompressionType("JPEG2000");
    //        writeParams.setFilter(J2KImageWriteParam.FILTER_97);

    writeParams.setCompressionQuality(0.0f);
    writeParams.setEncodingRate(0.5f);
    ImageOutputStream ios = ImageIO.createImageOutputStream(f);
    writer.setOutput(ios);
    writer.write(null, new IIOImage(image, null, null), writeParams);
    writer.dispose();
    ios.close();
    assertTrue("Expected file size < 1MB", f.length() < 128 * 1024);
    // System.out.println(f.length());
    BufferedImage read = ImageIO.read(f);
    assertEquals(SIZE, read.getWidth());
  }
  public byte[] getThumbNail() {
    byte[] img = this.getImage();
    byte[] out = null;
    ByteArrayOutputStream byteArrayOut = new ByteArrayOutputStream();

    try {
      BufferedImage bufferedImage = ImageIO.read(new ByteArrayInputStream(img));
      int w = bufferedImage.getWidth() / 10;
      int h = bufferedImage.getHeight() / 10;
      BufferedImage after = new BufferedImage(w, h, bufferedImage.getType());
      AffineTransform at = new AffineTransform();
      at.scale(0.1, 0.1);
      AffineTransformOp scaleOp = new AffineTransformOp(at, AffineTransformOp.TYPE_BILINEAR);
      after = scaleOp.filter(bufferedImage, after);
      ImageIO.write(after, "jpg", byteArrayOut);
      out = byteArrayOut.toByteArray();

    } catch (IOException e) {
      e
          .printStackTrace(); // To change body of catch statement use File | Settings | File
                              // Templates.
    }

    return out;
  }
Beispiel #19
0
  @Test
  public void testImagesResizeJpg() {
    new PlayBuilder().build();
    File folder = new File(Play.frameworkPath, "/framework/test-src/play/libs");

    File source = new File(folder, "winie.jpg");
    File result = new File(source.getParent(), "winie_testResult.jpg");

    Images.resize(source, result, 1536, 2048);
    try {
      BufferedImage buffSrc = ImageIO.read(source);
      BufferedImage buffDest = ImageIO.read(result);

      assertEquals(buffSrc.getColorModel().hasAlpha(), buffDest.getColorModel().hasAlpha());
      assertEquals(buffSrc.getColorModel().getPixelSize(), buffDest.getColorModel().getPixelSize());
      assertEquals(
          buffSrc.getColorModel().getTransferType(), buffDest.getColorModel().getTransferType());
      assertEquals(
          buffSrc.getColorModel().getTransparency(), buffDest.getColorModel().getTransparency());
    } catch (IOException e) {
      fail("cannot compare the 2 images");
    } finally {
      result.delete();
    }
  }
  public static void main(String[] args) throws IOException {

    File folder =
        new File(
            "C:\\Users\\smoeller\\Documents\\MSCS\\CS5542\\BigData-Spring2016-TourGuide\\BigData-Spring2016-TourGuide\\data\\");
    File[] listOfFiles = folder.listFiles();
    System.out.println("Total No of Files:" + listOfFiles.length);
    BufferedImage img = null;
    BufferedImage tempPNG = null;
    BufferedImage tempJPG = null;
    File newFilePNG = null;
    File newFileJPG = null;

    for (int i = 0; i < listOfFiles.length; i++) {
      if (listOfFiles[i].isFile()) {
        System.out.println("Resizing File " + folder.getPath() + listOfFiles[i].getName());
        int pos = listOfFiles[i].getName().lastIndexOf(".");
        img = ImageIO.read(new File(folder.getPath() + listOfFiles[i].getName()));
        tempJPG = resizeImage(img, img.getWidth(), img.getHeight());
        newFileJPG =
            new File(folder.getPath() + listOfFiles[i].getName().substring(0, pos) + "_New.jpg");
        ImageIO.write(tempJPG, "jpg", newFileJPG);
        System.out.println("    Resized to " + newFileJPG);
      }
    }
    System.out.println("DONE");
  }
Beispiel #21
0
  /**
   * Save onscreen image to file - suffix must be png, jpg, or gif.
   *
   * @param filename the name of the file with one of the required suffixes
   */
  public static void save(String filename) {
    File file = new File(filename);
    String suffix = filename.substring(filename.lastIndexOf('.') + 1);

    // png files
    if (suffix.toLowerCase().equals("png")) {
      try {
        ImageIO.write(onscreenImage, suffix, file);
      } catch (IOException e) {
        e.printStackTrace();
      }
    }

    // need to change from ARGB to RGB for jpeg
    // reference: http://archives.java.sun.com/cgi-bin/wa?A2=ind0404&L=java2d-interest&D=0&P=2727
    else if (suffix.toLowerCase().equals("jpg")) {
      WritableRaster raster = onscreenImage.getRaster();
      WritableRaster newRaster;
      newRaster = raster.createWritableChild(0, 0, width, height, 0, 0, new int[] {0, 1, 2});
      DirectColorModel cm = (DirectColorModel) onscreenImage.getColorModel();
      DirectColorModel newCM =
          new DirectColorModel(
              cm.getPixelSize(), cm.getRedMask(), cm.getGreenMask(), cm.getBlueMask());
      BufferedImage rgbBuffer = new BufferedImage(newCM, newRaster, false, null);
      try {
        ImageIO.write(rgbBuffer, suffix, file);
      } catch (IOException e) {
        e.printStackTrace();
      }
    } else {
      System.out.println("Invalid image file type: " + suffix);
    }
  }
Beispiel #22
0
 private BufferedImage getImage(File file) {
   ImageInputStream iis = null;
   BufferedImage image = null;
   try {
     iis = ImageIO.createImageInputStream(file);
     Iterator<ImageReader> it = ImageIO.getImageReaders(iis);
     if (!it.hasNext()) throw new UnsupportedOperationException("No image reader fround.");
     ImageReader reader = it.next();
     reader.setInput(iis);
     int scaleFactor;
     if (reader.getWidth(0) >= reader.getHeight(0))
       scaleFactor = Math.round(((float) reader.getWidth(0)) / MAX_SIZE);
     else scaleFactor = Math.round(((float) reader.getHeight(0)) / MAX_SIZE);
     ImageReadParam param = reader.getDefaultReadParam();
     param.setSourceSubsampling(scaleFactor, scaleFactor, 0, 0);
     image = reader.read(0, param);
   } catch (IOException e) {
     e.printStackTrace();
   } finally {
     if (iis != null)
       try {
         iis.close();
       } catch (IOException e) {
         e.printStackTrace();
       }
   }
   return image;
 }
  @Override
  public void writeImage(RenderedImage image, String mimeType, float quality, OutputStream out)
      throws IOException {
    if ("image/jpeg".equals(mimeType)) {
      // Find a JPEG writer.
      ImageWriter writer = null;
      Iterator<ImageWriter> iter = ImageIO.getImageWritersByMIMEType(mimeType);
      if (iter.hasNext()) {
        writer = iter.next();
      }
      JPEGImageWriteParam iwp = new JPEGImageWriteParam(null);
      iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
      iwp.setCompressionQuality(quality);

      // Prepare output file.
      ImageOutputStream ios = ImageIO.createImageOutputStream(out);
      writer.setOutput(ios);

      // Write the image.
      writer.write(null, new IIOImage(image, null, null), iwp);

      // Cleanup.
      ios.flush();
      writer.dispose();
      ios.close();
    } else {
      ImageIO.write(image, "png", out);
    }
  }
  public Karte(Frontend frontend, D_Karte daten) {
    this.frontend = frontend;
    this.daten = daten;
    String pfadBild = "daten//felder";
    String pfadRessource = "daten//ressourcen";
    String pfadEinheit = "daten//einheiten";
    String pfadStadt = "daten//stadt";
    try {
      bildFeldGewaehlt = ImageIO.read(new File(pfadBild, "gewaehlt.png"));
      bildFeldMarkiert = ImageIO.read(new File(pfadBild, "markiert.png"));
    } catch (IOException e) {
      e.printStackTrace();
      System.exit(-1);
    }
    dateienEinlesen(pfadBild, bildFeld);
    dateienEinlesen(pfadRessource, bildRessource);
    dateienEinlesen(pfadEinheit, bildEinheit);
    dateienEinlesen(pfadStadt, bildStadt);

    int spielfeldGroesse = frontend.getSpielfeldGroesse();
    int zoomfaktor = frontend.getZoomfaktor();
    int offset = spielfeldGroesse * zoomfaktor / 100;
    setLayout(null);
    setPreferredSize(new Dimension(getGroesseX() * offset, getGroesseY() * offset));
    felder = new Feld[getGroesseX() + 1][getGroesseY() + 1];
    for (int i = 1; i <= getGroesseX(); i++) {
      for (int j = 1; j <= getGroesseY(); j++) {
        Feld f = new Feld(frontend, i, j);
        felder[i][j] = f;
        add(f);
      }
    }
  }
Beispiel #25
0
  /**
   * 将照片logo添加到二维码中间
   *
   * @param image 生成的二维码照片对象
   * @param imagePath 照片保存路径
   * @param logoPath logo照片路径
   * @param formate 照片格式
   */
  public static void overlapImage(
      BufferedImage image,
      String formate,
      String imagePath,
      String logoPath,
      MatrixToLogoImageConfig logoConfig) {
    try {
      BufferedImage logo = ImageIO.read(new File(logoPath));
      Graphics2D g = image.createGraphics();
      // 考虑到logo照片贴到二维码中,建议大小不要超过二维码的1/5;
      int width = image.getWidth() / logoConfig.getLogoPart();
      int height = image.getHeight() / logoConfig.getLogoPart();
      // logo起始位置,此目的是为logo居中显示
      int x = (image.getWidth() - width) / 2;
      int y = (image.getHeight() - height) / 2;
      // 绘制图
      g.drawImage(logo, x, y, width, height, null);

      // 给logo画边框
      // 构造一个具有指定线条宽度以及 cap 和 join 风格的默认值的实心 BasicStroke
      g.setStroke(new BasicStroke(logoConfig.getBorder()));
      g.setColor(logoConfig.getBorderColor());
      g.drawRect(x, y, width, height);

      g.dispose();
      // 写入logo照片到二维码
      ImageIO.write(image, formate, new File(imagePath));
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
Beispiel #26
0
  /*
   * create QR code with overlay
   */
  public static void createQRCode(
      String qrCodeData,
      String outputFilePath,
      String overlayFilePath,
      String charset,
      Map<EncodeHintType, ErrorCorrectionLevel> hintMap,
      int qrCodeheight,
      int qrCodewidth)
      throws WriterException, IOException {

    // create QR code <BufferedImage>
    QRCodeWriter qrWriter = new QRCodeWriter();
    BitMatrix matrix =
        qrWriter.encode(qrCodeData, BarcodeFormat.QR_CODE, qrCodewidth, qrCodeheight, hintMap);
    BufferedImage image = MatrixToImageWriter.toBufferedImage(matrix);

    // read overlay image
    BufferedImage overlay = ImageIO.read(new File(overlayFilePath));

    // Draw the new image
    int deltaHeight = image.getHeight() - overlay.getHeight();
    int deltaWidth = image.getWidth() - overlay.getWidth();

    BufferedImage combined =
        new BufferedImage(qrCodeheight, qrCodewidth, BufferedImage.TYPE_INT_ARGB);
    Graphics2D g = (Graphics2D) combined.getGraphics();
    g.drawImage(image, 0, 0, null);
    g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f));
    g.drawImage(overlay, (int) Math.round(deltaWidth / 2), (int) Math.round(deltaHeight / 2), null);

    ImageIO.write(combined, "PNG", new File(outputFilePath));
  }
Beispiel #27
0
  private void setup() throws IOException, UnsupportedAudioFileException, LineUnavailableException {
    startSounds();
    tracker = new MediaTracker(this);

    fishImages[0] = ImageIO.read(getClass().getResourceAsStream("fish1.gif"));
    tracker.addImage(fishImages[0], 0);

    fishImages[1] = ImageIO.read(getClass().getResourceAsStream("fish2.gif"));
    tracker.addImage(fishImages[1], 0);

    aquariumImage = ImageIO.read(getClass().getResourceAsStream("tank.png"));
    tracker.addImage(aquariumImage, 0);

    try {
      tracker.waitForID(0);
    } catch (Exception ex) {
      System.out.println(ex.getMessage());
    }

    setSize(aquariumImage.getWidth(this), aquariumImage.getHeight(this));
    setResizable(true);
    setVisible(true);
    memoryImage = createImage(getSize().width, getSize().height);
    memoryGraphics = memoryImage.getGraphics();
  }
  private File getCachedImage(File file, int size) throws IOException {
    String md5 = DigestUtils.md5Hex(file.getPath());
    File cachedImage = new File(getImageCacheDirectory(size), md5 + ".jpeg");

    // Is cache missing or obsolete?
    if (!cachedImage.exists() || FileUtil.lastModified(file) > cachedImage.lastModified()) {
      InputStream in = null;
      OutputStream out = null;
      try {
        in = getImageInputStream(file);
        out = new FileOutputStream(cachedImage);
        BufferedImage image = ImageIO.read(in);
        if (image == null) {
          throw new Exception("Unable to decode image.");
        }

        image = scale(image, size, size);
        ImageIO.write(image, "jpeg", out);

      } catch (Throwable x) {
        // Delete corrupt (probably empty) thumbnail cache.
        LOG.warn("Failed to create thumbnail for " + file, x);
        IOUtils.closeQuietly(out);
        cachedImage.delete();
        throw new IOException("Failed to create thumbnail for " + file + ". " + x.getMessage());

      } finally {
        IOUtils.closeQuietly(in);
        IOUtils.closeQuietly(out);
      }
    }
    return cachedImage;
  }
  private <T> T scaleImageUsingAffineTransformation(final BufferedImage bufferedImage, T target) {
    BufferedImage destinationImage = generateDestinationImage();
    Graphics2D graphics2D = destinationImage.createGraphics();
    AffineTransform transformation =
        AffineTransform.getScaleInstance(
            ((double) getQualifiedWidth() / bufferedImage.getWidth()),
            ((double) getQualifiedHeight() / bufferedImage.getHeight()));
    graphics2D.drawRenderedImage(bufferedImage, transformation);
    graphics2D.addRenderingHints(retrieveRenderingHints());
    try {
      if (target instanceof File) {
        LOGGER.info(String.format(M_TARGET_TYPE_OF, "File"));
        ImageIO.write(destinationImage, imageType.toString(), (File) target);
      } else if (target instanceof ImageOutputStream) {
        LOGGER.info(String.format(M_TARGET_TYPE_OF, "ImageOutputStream"));
        ImageIO.write(destinationImage, imageType.toString(), (ImageOutputStream) target);
      } else if (target instanceof OutputStream) {
        LOGGER.info(String.format(M_TARGET_TYPE_OF, "OutputStream"));
        ImageIO.write(destinationImage, imageType.toString(), (OutputStream) target);
      } else {
        target = null;
      }
    } catch (IOException e) {
      e.printStackTrace();
    }

    return target;
  }
Beispiel #30
0
  /**
   * 把图片印刷到图片上
   *
   * @param pressImg -- 水印文件
   * @param targetImg -- 目标文件
   * @param x
   * @param y
   */
  public static final void pressImage(String pressImg, String targetImg, int x, int y) {
    try {
      File _file = new File(targetImg);
      Image src = ImageIO.read(_file);
      int wideth = src.getWidth(null);
      int height = src.getHeight(null);
      BufferedImage image = new BufferedImage(wideth, height, BufferedImage.TYPE_INT_RGB);
      Graphics g = image.createGraphics();
      g.drawImage(src, 0, 0, wideth, height, null);

      // 水印文件
      File _filebiao = new File(pressImg);
      Image src_biao = ImageIO.read(_filebiao);
      int wideth_biao = src_biao.getWidth(null);
      int height_biao = src_biao.getHeight(null);
      g.drawImage(
          src_biao,
          wideth - wideth_biao - x,
          height - height_biao - y,
          wideth_biao,
          height_biao,
          null);
      // /
      g.dispose();
      FileOutputStream out = new FileOutputStream(targetImg);
      JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
      encoder.encode(image);
      out.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }