Exemple #1
0
  /**
   * @param li ImageLevelInfo object
   * @param con JDBC Connection
   * @return the resolution for li, based on a random chosen tile
   * @throws SQLException
   * @throws IOException
   */
  protected double[] getPixelResolution(ImageLevelInfo li, Connection con)
      throws SQLException, IOException {
    double[] result = null;
    String statementString = getRandomTileStatement(li);
    PreparedStatement s = con.prepareStatement(statementString);
    ResultSet r = s.executeQuery();

    while (r.next()) {
      byte[] tileBytes = getTileBytes(r);

      if (tileBytes == null) {
        continue;
      }

      BufferedImage buffImage = null;
      li.setCanImageIOReadFromInputStream(true);
      try {
        buffImage = ImageIO.read(new ByteArrayInputStream(tileBytes));
      } catch (IOException e) {
      }

      if (buffImage == null) {
        if (LOGGER.isLoggable(Level.WARNING)) {
          LOGGER.warning(
              "Image IO cannot read from ByteInputStream,use less efficient jai methods");
        }
        li.setCanImageIOReadFromInputStream(false);
        SeekableStream stream = new ByteArraySeekableStream(tileBytes);
        String decoderName = null;

        for (String dn : ImageCodec.getDecoderNames(stream)) {
          decoderName = dn;
          break;
        }

        ImageDecoder decoder = ImageCodec.createImageDecoder(decoderName, stream, null);
        PlanarImage img = PlanarImage.wrapRenderedImage(decoder.decodeAsRenderedImage());
        buffImage = img.getAsBufferedImage();
      }

      Envelope env = getEnvelopeFromResultSet(r);

      result =
          new double[] {
            env.getWidth() / buffImage.getWidth(), env.getHeight() / buffImage.getHeight()
          };

      break;
    }

    r.close();
    s.close();

    return result;
  }
  /**
   * A convenience method for registering XTIFF methods into JAI, for extended classes of
   * XTIFFDescriptor.
   */
  public static void register(XTIFFDescriptor odesc) {

    OperationRegistry reg = JAI.getDefaultInstance().getOperationRegistry();

    // override tiff operation
    reg.unregisterOperationDescriptor("tiff");

    // ...and register tiff with the new desc
    reg.registerOperationDescriptor(odesc, "tiff");
    reg.registerRIF("tiff", "org.libtiff.jai", odesc);

    // re-register the tiff codec
    ImageCodec.unregisterCodec("tiff");
    ImageCodec.registerCodec(new XTIFFCodec());
  }
Exemple #3
0
  /**
   * Sets up all the images and trackers.
   *
   * @throws IOException if the image cannot be loaded
   */
  public static void settupImages() throws IOException {
    FileSeekableStream stream = new FileSeekableStream(filePath);

    ImageDecodeParam param = null;

    ImageDecoder dec = ImageCodec.createImageDecoder("tiff", stream, param);

    images = new RenderedImage[TIFFDirectory.getNumDirectories(stream)];

    System.out.println(images.length);

    for (int i = 0; i < images.length; i++) {
      images[i] = new NullOpImage(dec.decodeAsRenderedImage(i), null, null, OpImage.OP_IO_BOUND);
    }

    JFrame f = new JFrame("Trak");
    im = new ImageFrame(images);

    File save = new File(filePath + ".trak");
    if (save.exists()) {
      try {
        ObjectInputStream fromSave =
            new ObjectInputStream(new GZIPInputStream(new FileInputStream(save)));
        trackers = (DotTracker[]) fromSave.readObject();

        if (trackers.length != images.length) {
          throw new IOException("Invalid Trackers");
        }
        foundValidTrackers = true;
        System.out.println("Valid trackers found, not re-refining data");
      } catch (Exception e) {

      }
    }

    if (!foundValidTrackers) {
      trackers = new DotTracker[images.length];
    }

    f.add(im);
    f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    f.pack();
    f.setLocationRelativeTo(null);

    for (int i = 0; i < images.length; i++) {
      if (!foundValidTrackers) {
        trackers[i] = new DotTracker(im.datas[i]);
      }
      trackers[i].colorRefined(im.refinedImages[i].getGraphics());
      System.out.println(i);
    }

    remakeDots();

    f.setVisible(true);
  }
  public void write(RenderedImage renderedImage, String contentType, OutputStream os)
      throws IOException {

    if (contentType.contains(TYPE_BMP)) {
      ImageEncoder imageEncoder = ImageCodec.createImageEncoder(TYPE_BMP, os, null);

      imageEncoder.encode(renderedImage);
    } else if (contentType.contains(TYPE_GIF)) {
      encodeGIF(renderedImage, os);
    } else if (contentType.contains(TYPE_JPEG) || contentType.contains("jpeg")) {

      ImageIO.write(renderedImage, "jpeg", os);
    } else if (contentType.contains(TYPE_PNG)) {
      ImageIO.write(renderedImage, TYPE_PNG, os);
    } else if (contentType.contains(TYPE_TIFF) || contentType.contains("tif")) {

      ImageEncoder imageEncoder = ImageCodec.createImageEncoder(TYPE_TIFF, os, null);

      imageEncoder.encode(renderedImage);
    }
  }
  public ImageBag read(byte[] bytes) {
    RenderedImage renderedImage = null;
    String type = TYPE_NOT_AVAILABLE;

    Enumeration<ImageCodec> enu = ImageCodec.getCodecs();

    while (enu.hasMoreElements()) {
      ImageCodec codec = enu.nextElement();

      if (codec.isFormatRecognized(bytes)) {
        type = codec.getFormatName();

        renderedImage = read(bytes, type);

        break;
      }
    }

    if (type.equals("jpeg")) {
      type = TYPE_JPEG;
    }

    return new ImageBag(renderedImage, type);
  }
  protected RenderedImage read(byte[] bytes, String type) {
    RenderedImage renderedImage = null;

    try {
      if (type.equals(TYPE_JPEG)) {
        type = "jpeg";
      }

      ImageDecoder decoder =
          ImageCodec.createImageDecoder(type, new UnsyncByteArrayInputStream(bytes), null);

      renderedImage = decoder.decodeAsRenderedImage();
    } catch (IOException ioe) {
      if (_log.isDebugEnabled()) {
        _log.debug(type + ": " + ioe.getMessage());
      }
    }

    return renderedImage;
  }