コード例 #1
0
ファイル: DicomImageReader.java プロジェクト: rawmahn/dcm4che
  @Override
  public Raster readRaster(int frameIndex, ImageReadParam param) throws IOException {
    readMetadata();
    checkIndex(frameIndex);

    if (decompressor != null) {
      decompressor.setInput(iisOfFrame(frameIndex));

      if (LOG.isDebugEnabled()) LOG.debug("Start decompressing frame #" + (frameIndex + 1));
      Raster wr =
          pmi.decompress() == pmi && decompressor.canReadRaster()
              ? decompressor.readRaster(0, decompressParam(param))
              : decompressor.read(0, decompressParam(param)).getRaster();
      if (LOG.isDebugEnabled()) LOG.debug("Finished decompressing frame #" + (frameIndex + 1));
      return wr;
    }
    iis.seek(pixeldata.offset + frameIndex * frameLength);
    WritableRaster wr = Raster.createWritableRaster(createSampleModel(dataType, banded), null);
    DataBuffer buf = wr.getDataBuffer();
    if (buf instanceof DataBufferByte) {
      byte[][] data = ((DataBufferByte) buf).getBankData();
      for (byte[] bs : data) iis.readFully(bs);
      if (pixeldata.bigEndian && pixeldataVR.vr == VR.OW) ByteUtils.swapShorts(data);
    } else {
      short[] data = ((DataBufferUShort) buf).getData();
      iis.readFully(data, 0, data.length);
    }
    return wr;
  }
コード例 #2
0
ファイル: PSDReader.java プロジェクト: ksalic/TwelveMonkeys
  @Override
  public Directory read(final ImageInputStream input) throws IOException {
    Validate.notNull(input, "input");

    List<PSDEntry> entries = new ArrayList<PSDEntry>();

    while (true) {
      try {
        int type = input.readInt();

        if (type != PSD.RESOURCE_TYPE) {
          throw new IIOException(
              String.format("Wrong image resource type, expected '8BIM': '%08x'", type));
        }

        short id = input.readShort();

        PSDResource resource = new PSDResource(id, input);
        entries.add(new PSDEntry(id, resource.name(), resource.data()));

      } catch (EOFException e) {
        break;
      }
    }

    return new PSDDirectory(entries);
  }
コード例 #3
0
  private Dimension getSize(File file) {
    try {
      ImageInputStream input = ImageIO.createImageInputStream(file);
      if (input != null) {
        try {
          Iterator<ImageReader> readers = ImageIO.getImageReaders(input);
          if (readers.hasNext()) {
            ImageReader reader = readers.next();
            try {
              reader.setInput(input);
              return new Dimension(reader.getWidth(0), reader.getHeight(0));
            } finally {
              reader.dispose();
            }
          }
        } finally {
          if (input != null) {
            input.close();
          }
        }
      }

      // Fallback: read the image using the normal means
      BufferedImage image = ImageIO.read(file);
      if (image != null) {
        return new Dimension(image.getWidth(), image.getHeight());
      } else {
        return null;
      }
    } catch (IOException e) {
      // Pass -- we can't handle all image types, warn about those we can
      return null;
    }
  }
コード例 #4
0
ファイル: ImageTools.java プロジェクト: vikasing/crowl
 public Dimension getImageDimensions(InputStream imageStream) {
   ImageInputStream in = null;
   Dimension dimension = null;
   try {
     in = ImageIO.createImageInputStream(imageStream);
     final Iterator<ImageReader> readers = ImageIO.getImageReaders(in);
     if (readers.hasNext()) {
       ImageReader reader = readers.next();
       try {
         reader.setInput(in);
         dimension = new Dimension(reader.getWidth(0), reader.getHeight(0));
       } finally {
         reader.dispose();
       }
     }
   } catch (IOException e) {
     e.printStackTrace();
   } finally {
     if (in != null)
       try {
         in.close();
       } catch (Exception e) {
         e.printStackTrace();
       }
   }
   return dimension;
 }
コード例 #5
0
ファイル: ScanPhoto.java プロジェクト: rpdev/PhotoSorter
 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;
 }
コード例 #6
0
ファイル: CsvFile.java プロジェクト: bcdev/beam
  private void parseProperties() throws IOException {
    String line;
    stream.seek(0);
    propertiesByteSize = 0;
    long posInStream = 0l;
    while ((line = stream.readLine()) != null) {
      if (!line.startsWith("#")) {
        stream.seek(posInStream);
        break;
      }
      propertiesByteSize += (stream.getStreamPosition() - posInStream);
      posInStream = stream.getStreamPosition();

      line = line.substring(1);
      int pos = line.indexOf('=');
      if (pos == -1) {
        throw new IOException("Missing '=' in '" + line + "'");
      }
      String name = line.substring(0, pos).trim();
      if (name.isEmpty()) {
        throw new IOException("Empty property name in '" + line + "'");
      }
      String value = line.substring(pos + 1).trim();
      try {
        if (contains(Constants.CRS_IDENTIFIERS, name) && crs != null) {
          crs = CRS.parseWKT(value);
        }
      } catch (FactoryException e) {
        throw new IOException(e);
      }
      properties.put(name, value);
    }
    propertiesParsed = true;
  }
コード例 #7
0
  @Override
  public BufferedImage read(Class<? extends BufferedImage> clazz, HttpInputMessage inputMessage)
      throws IOException, HttpMessageNotReadableException {

    ImageInputStream imageInputStream = null;
    ImageReader imageReader = null;
    try {
      imageInputStream = createImageInputStream(inputMessage.getBody());
      MediaType contentType = inputMessage.getHeaders().getContentType();
      Iterator<ImageReader> imageReaders =
          ImageIO.getImageReadersByMIMEType(contentType.toString());
      if (imageReaders.hasNext()) {
        imageReader = imageReaders.next();
        ImageReadParam irp = imageReader.getDefaultReadParam();
        process(irp);
        imageReader.setInput(imageInputStream, true);
        return imageReader.read(0, irp);
      } else {
        throw new HttpMessageNotReadableException(
            "Could not find javax.imageio.ImageReader for Content-Type [" + contentType + "]");
      }
    } finally {
      if (imageReader != null) {
        imageReader.dispose();
      }
      if (imageInputStream != null) {
        try {
          imageInputStream.close();
        } catch (IOException ex) {
          // ignore
        }
      }
    }
  }
コード例 #8
0
  public boolean canDecodeInput(Object input) throws IOException {

    // The input source must be an ImageInputStream because the constructor
    // passes STANDARD_INPUT_TYPE (an array consisting of ImageInputStream)
    // as the only type of input source that it will deal with to its
    // superclass.

    if (!(input instanceof ImageInputStream)) return false;

    ImageInputStream stream = (ImageInputStream) input;

    /** Read and validate the input source's header. */
    byte[] header = new byte[8];
    try {
      // The input source's current position must be preserved so that
      // other ImageReaderSpis can determine if they can decode the input
      // source's format, should this input source be unable to handle the
      // decoding. Because the input source is an ImageInputStream, its
      // mark() and reset() methods are called to preserve the current
      // position.

      stream.mark();
      stream.read(header);
      stream.reset();
    } catch (IOException e) {
      return false;
    }

    byte[] controlHeader = new byte[] {(byte) 151, 74, 66, 50, 13, 10, 26, 10};

    return Arrays.equals(controlHeader, header);
  }
コード例 #9
0
ファイル: IOUtilsTest.java プロジェクト: marcpawl/vassal
  @Test
  public void testCloseQuietlyImageInputStreamClosed() throws IOException {
    final ImageInputStream in = new MemoryCacheImageInputStream(new ClosedInputStream());
    in.close();

    IOUtils.closeQuietly(in);
  }
コード例 #10
0
  private int locateImage(int imageIndex) throws IIOException {
    readHeader();

    try {
      // Find closest known index
      int index = Math.min(imageIndex, imageStartPosition.size() - 1);

      // Seek to that position
      Long l = (Long) imageStartPosition.get(index);
      stream.seek(l.longValue());

      // Skip IFDs until at desired index or last image found
      while (index < imageIndex) {
        int count = stream.readUnsignedShort();
        stream.skipBytes(12 * count);

        long offset = stream.readUnsignedInt();
        if (offset == 0) {
          return index;
        }

        imageStartPosition.add(new Long(offset));
        stream.seek(offset);
        ++index;
      }
    } catch (IOException e) {
      throw new IIOException("Couldn't seek!", e);
    }

    if (currIndex != imageIndex) {
      imageMetadata = null;
    }
    currIndex = imageIndex;
    return imageIndex;
  }
コード例 #11
0
  @Test
  public void testAddAndGetTile() throws InterruptedException, FileNotFoundException, IOException {
    // Input stream to use
    ImageInputStream stream_in = null;
    try {
      stream_in = new FileImageInputStream(TestData.file(this, "world.tiff"));
      // Input RenderedImage to use
      final RenderedOp input =
          ImageReadDescriptor.create(
              stream_in, 0, false, false, false, null, null, null, null, null);

      // Boolean used for checking if the conditions are passed
      final AtomicBoolean passed = new AtomicBoolean(true);
      // Cache creation
      final ConcurrentTileCacheMultiMap cache =
          new ConcurrentTileCacheMultiMap(1000 * 1000, false, 1f, 4);
      // Selection of one tile from the image
      Raster data = input.getTile(input.getMinTileX(), input.getMinTileY());
      // Setting the tile inside the cache
      cache.add(input, input.getMinTileX(), input.getMinTileY(), data);
      // Thread pool to use for doing concurrent access on the cache
      ThreadPoolExecutor executor =
          new ThreadPoolExecutor(
              TOTAL, TOTAL, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1000000));
      // Latch used for waiting all the threads to end their work
      final CountDownLatch latch = new CountDownLatch(TOTAL);
      // Cycle for launching various requests
      int counter = TOTAL;
      while (counter > 0) {

        executor.execute(
            new Runnable() {

              public void run() {
                // Get the tile to use
                Raster data = cache.getTile(input, input.getMinTileX(), input.getMinTileY());
                if (data == null) {
                  passed.getAndSet(false);
                }
                latch.countDown();
              }
            });
        // Counter update
        counter--;
      }
      // Waiting all threads to finish
      latch.await();
      // Ensure that all the threads have found the tile
      Assert.assertTrue(passed.get());
    } finally {
      try {
        if (stream_in != null) {
          stream_in.flush();
          stream_in.close();
        }
      } catch (Throwable t) {
        //
      }
    }
  }
コード例 #12
0
ファイル: ImageSize.java プロジェクト: javagraphics/main
  private static Dimension getSizeUsingImageIO(URL url) throws IOException {
    InputStream in = null;
    ImageInputStream iis = null;
    ImageReader reader = null;
    try {
      in = url.openStream();
      iis = new MemoryCacheImageInputStream(in);
      Iterator<ImageReader> it = ImageIO.getImageReaders(iis);
      if (!it.hasNext()) return null;

      reader = it.next();
      reader.setInput(iis, true, true);

      Dimension d = new Dimension(reader.getWidth(0), reader.getHeight(0));
      if (d.width <= 0 || d.height <= 0)
        throw new RuntimeException("invalid dimensions: " + d.width + "x" + d.height);
      return d;
    } finally {
      try {
        if (reader != null) reader.dispose();
      } catch (Exception e) {
        e.printStackTrace();
      }
      try {
        if (iis != null) iis.close();
      } catch (Exception e) {
        e.printStackTrace();
      }
      try {
        if (in != null) in.close();
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
  }
コード例 #13
0
  /**
   * reads an AOT Kx LUT (BBDR breadboard procedure GA_read_LUT_AOD)
   *
   * <p>A LUT value can be accessed with lut.getValue(new double[]{wvlValue, aotValue, hsfValue,
   * aziValue, szaValue, vzaValue, parameterValue});
   *
   * @param sensor The sensor
   * @return LookupTable
   * @throws java.io.IOException when failing to real LUT data
   */
  public static LookupTable getAotKxLookupTable(Sensor sensor) throws IOException {
    ImageInputStream iis = Luts.getAotKxLutData(sensor.getInstrument());
    try {
      // read LUT dimensions and values
      float[] vza = Luts.readDimension(iis);
      int nVza = vza.length;
      float[] sza = Luts.readDimension(iis);
      int nSza = sza.length;
      float[] azi = Luts.readDimension(iis);
      int nAzi = azi.length;
      float[] hsf = Luts.readDimension(iis);
      int nHsf = hsf.length;
      float[] aot = Luts.readDimension(iis);
      int nAot = aot.length;

      float[] kx = new float[] {1.0f, 2.0f};
      int nKx = kx.length;

      float[] wvl = sensor.getWavelength();
      final int nWvl = wvl.length;

      float[] lut = new float[nKx * nVza * nSza * nAzi * nHsf * nAot * nWvl];
      iis.readFully(lut, 0, lut.length);

      return new LookupTable(lut, wvl, aot, hsf, azi, sza, vza, kx);
    } finally {
      iis.close();
    }
  }
コード例 #14
0
  /**
   * Gets a list of <code>IIOImage</code> objects for an image file.
   *
   * @param imageFile input image file. It can be any of the supported formats, including TIFF,
   *     JPEG, GIF, PNG, BMP, JPEG, and PDF if GPL Ghostscript is installed
   * @return a list of <code>IIOImage</code> objects
   * @throws Exception
   */
  public static List<IIOImage> getIIOImageList(File imageFile) throws IOException {
    File workingTiffFile = null;

    ImageReader reader = null;
    ImageInputStream iis = null;

    try {
      // convert PDF to TIFF
      if (imageFile.getName().toLowerCase().endsWith(".pdf")) {
        workingTiffFile = PdfUtilities.convertPdf2Tiff(imageFile);
        imageFile = workingTiffFile;
      }

      List<IIOImage> iioImageList = new ArrayList<IIOImage>();

      String imageFileName = imageFile.getName();
      String imageFormat = imageFileName.substring(imageFileName.lastIndexOf('.') + 1);
      if (imageFormat.matches("(pbm|pgm|ppm)")) {
        imageFormat = "pnm";
      } else if (imageFormat.equals("jp2")) {
        imageFormat = "jpeg2000";
      }
      Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName(imageFormat);
      reader = readers.next();

      if (reader == null) {
        throw new RuntimeException(
            "Need to install JAI Image I/O package.\nhttps://jai-imageio.dev.java.net");
      }

      iis = ImageIO.createImageInputStream(imageFile);
      reader.setInput(iis);

      int imageTotal = reader.getNumImages(true);

      for (int i = 0; i < imageTotal; i++) {
        //                IIOImage oimage = new IIOImage(reader.read(i), null,
        // reader.getImageMetadata(i));
        IIOImage oimage = reader.readAll(i, reader.getDefaultReadParam());
        iioImageList.add(oimage);
      }

      return iioImageList;
    } finally {
      try {
        if (iis != null) {
          iis.close();
        }
        if (reader != null) {
          reader.dispose();
        }
      } catch (Exception e) {
        // ignore
      }
      if (workingTiffFile != null && workingTiffFile.exists()) {
        workingTiffFile.delete();
      }
    }
  }
コード例 #15
0
  GranuleOverviewLevelDescriptor getLevel(final int index) {

    // load level
    // create the base grid to world transformation
    ImageInputStream inStream = null;
    ImageReader reader = null;
    try {

      // get a stream
      assert cachedStreamSPI != null : "no cachedStreamSPI available!";
      inStream =
          cachedStreamSPI.createInputStreamInstance(
              granuleUrl, ImageIO.getUseCache(), ImageIO.getCacheDirectory());
      if (inStream == null)
        throw new IllegalArgumentException(
            "Unable to create an inputstream for the granuleurl:"
                + (granuleUrl != null ? granuleUrl : "null"));

      // get a reader and try to cache the relevant SPI
      if (cachedReaderSPI == null) {
        reader = ImageIOExt.getImageioReader(inStream);
        if (reader != null) cachedReaderSPI = reader.getOriginatingProvider();
      } else reader = cachedReaderSPI.createReaderInstance();
      if (reader == null)
        throw new IllegalArgumentException(
            "Unable to get an ImageReader for the provided file " + granuleUrl.toString());
      reader.setInput(inStream);

      // call internal method which will close everything
      return getLevel(index, reader);

    } catch (IllegalStateException e) {

      // clean up
      try {
        if (inStream != null) inStream.close();
      } catch (Throwable ee) {

      } finally {
        if (reader != null) reader.dispose();
      }

      throw new IllegalArgumentException(e);

    } catch (IOException e) {

      // clean up
      try {
        if (inStream != null) inStream.close();
      } catch (Throwable ee) {
      } finally {
        if (reader != null) reader.dispose();
      }

      throw new IllegalArgumentException(e);
    }
  }
コード例 #16
0
  /**
   * Write world image extensions : TFW, PRJ, TAB
   *
   * @param request
   * @param file
   * @param in
   * @throws IOException
   */
  private void writeWorldImageExt(WcsReaderRequest request, File file) throws IOException {

    String baseFilePath = file.getPath().substring(0, file.getPath().lastIndexOf('.'));

    // Compute image size and image transformed BBOX
    ReferencedEnvelope transformedBBox;
    AffineTransform transform;

    int width = -1;
    int height = -1;
    String ext = FileUtils.extension(file);

    try {
      final Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName(ext.substring(1));

      while (readers.hasNext() && width < 0 && height < 0) {
        ImageInputStream stream = null;
        try {
          ImageReader reader = readers.next();
          stream = ImageIO.createImageInputStream(file.getAbsoluteFile());
          reader.setInput(stream, true, false);
          width = reader.getWidth(0);
          height = reader.getHeight(0);
          break;
        } catch (Exception e) {
          width = -1;
          height = -1;
          // try next reader;
        } finally {
          if (stream != null) {
            stream.close();
          }
        }
      }

      transformedBBox = request.requestBbox.transform(request.responseCRS, true, 10);
      if (width < 0) {
        width = (int) Math.round(transformedBBox.getWidth() / request.crsResolution());
      }

      if (height < 0) {
        height = (int) Math.round(transformedBBox.getHeight() / request.crsResolution());
      }

      Rectangle imageSize = new Rectangle(width, height);
      transform = RendererUtilities.worldToScreenTransform(transformedBBox, imageSize);
      transform.invert();

    } catch (Exception e) {
      throw new ExtractorException(e);
    }

    // Generate TFW TAB PRJ files
    createWorldFile(transform, ext, baseFilePath);
    createTABFile(transformedBBox, width, height, baseFilePath, ext);
    createPrjFile(request.responseCRS, baseFilePath);
  }
コード例 #17
0
  /**
   * {@inheritDoc}
   *
   * @return GridCoverageReader.
   */
  @Override
  public GridCoverageReader convert(final ReferenceType source, final Map<String, Object> params)
      throws UnconvertibleObjectException {

    final InputStream stream = getInputStreamFromReference(source);

    String encoding = null;
    if (params != null && params.get(ENCODING) != null) {
      encoding = (String) params.get(ENCODING);
    }
    ImageInputStream imageStream = null;
    try {

      // decode form base64 stream
      if (encoding != null && encoding.equals(WPSEncoding.BASE64.getValue())) {
        final String encodedImage = IOUtilities.toString(stream);
        final byte[] byteData = Base64.decode(encodedImage.trim());
        if (byteData != null && byteData.length > 0) {
          try (InputStream is = new ByteArrayInputStream(byteData)) {
            imageStream = ImageIO.createImageInputStream(is);
          }
        }

      } else {
        imageStream = ImageIO.createImageInputStream(stream);
      }

      if (imageStream != null) {
        final ImageReader reader;
        if (source.getMimeType() != null) {
          reader = XImageIO.getReaderByMIMEType(source.getMimeType(), imageStream, null, null);
        } else {
          reader = XImageIO.getReader(imageStream, null, Boolean.FALSE);
        }
        return CoverageIO.createSimpleReader(reader);
      } else {
        throw new UnconvertibleObjectException("Error during image stream acquisition.");
      }

    } catch (MalformedURLException ex) {
      throw new UnconvertibleObjectException(
          "Reference grid coverage invalid input : Malformed url", ex);
    } catch (CoverageStoreException ex) {
      throw new UnconvertibleObjectException(
          "Reference grid coverage invalid input : Can't read coverage", ex);
    } catch (IOException ex) {
      throw new UnconvertibleObjectException("Reference grid coverage invalid input : IO", ex);
    } finally {
      if (imageStream != null) {
        try {
          imageStream.close();
        } catch (IOException ex) {
          LOGGER.log(Level.WARNING, "Error during release the image stream.", ex);
        }
      }
    }
  }
コード例 #18
0
  /**
   * Returns the geotiff metadata for this geotiff file.
   *
   * @return the metadata
   */
  public GeoTiffIIOMetadataDecoder getMetadata() {
    GeoTiffIIOMetadataDecoder metadata = null;
    ImageReader reader = null;
    boolean closeMe = true;
    ImageInputStream stream = null;

    try {
      if ((source instanceof InputStream) || (source instanceof ImageInputStream)) {
        closeMe = false;
      }
      if (source instanceof ImageInputStream) {
        stream = (ImageInputStream) source;
      } else {
        inStreamSPI = ImageIOExt.getImageInputStreamSPI(source);
        if (inStreamSPI == null) {
          throw new IllegalArgumentException("No input stream for the provided source");
        }
        stream =
            inStreamSPI.createInputStreamInstance(
                source, ImageIO.getUseCache(), ImageIO.getCacheDirectory());
      }
      if (stream == null) {
        throw new IllegalArgumentException("No input stream for the provided source");
      }
      stream.mark();
      reader = READER_SPI.createReaderInstance();
      reader.setInput(stream);
      final IIOMetadata iioMetadata = reader.getImageMetadata(0);
      metadata = new GeoTiffIIOMetadataDecoder(iioMetadata);
    } catch (IOException e) {
      if (LOGGER.isLoggable(Level.SEVERE)) {
        LOGGER.log(Level.SEVERE, e.getMessage(), e);
      }
    } finally {
      if (reader != null)
        try {
          reader.dispose();
        } catch (Throwable t) {
        }

      if (stream != null) {
        try {
          stream.reset();
        } catch (Throwable t) {
        }
        if (closeMe) {
          try {
            stream.close();
          } catch (Throwable t) {
          }
        }
      }
    }
    return metadata;
  }
コード例 #19
0
  // TODO: Candidate util method
  private static long skipToEOF(final ImageInputStream stream) throws IOException {
    long length = stream.length();

    if (length > 0) {
      // Known length, skip there and we're done.
      stream.seek(length);
    } else {
      // Otherwise, seek to EOF the hard way.
      // First, store stream position...
      long pos = stream.getStreamPosition();

      // ...skip 1k blocks until we're passed EOF...
      while (stream.skipBytes(1024l) > 0) {
        if (stream.read() == -1) {
          break;
        }

        pos = stream.getStreamPosition();
      }

      // ...go back to last known pos...
      stream.seek(pos);

      // ...finally seek until EOF one byte at a time. Done.
      while (stream.read() != -1) {}
    }

    return stream.getStreamPosition();
  }
コード例 #20
0
 BufferedImage getThumbnail(ImageInputStream iis, JPEGImageReader reader) throws IOException {
   iis.mark();
   iis.seek(streamPos);
   JPEGImageReader thumbReader = new JPEGImageReader(null);
   thumbReader.setInput(iis);
   thumbReader.addIIOReadProgressListener(new ThumbnailReadListener(reader));
   BufferedImage ret = thumbReader.read(0, null);
   thumbReader.dispose();
   iis.reset();
   return ret;
 }
コード例 #21
0
ファイル: Dedication.java プロジェクト: pabranch/plantuml
 public BufferedImage getBufferedImage(String keepLetter) {
   try {
     final InputStream is = getInputStream(keepLetter);
     final ImageInputStream iis = ImageIO.createImageInputStream(is);
     final VP8Decoder vp8Decoder = new VP8Decoder();
     vp8Decoder.decodeFrame(iis, false);
     iis.close();
     return vp8Decoder.getFrame().getBufferedImage();
   } catch (Exception e) {
     return null;
   }
 }
コード例 #22
0
 public void runTest(Object ctx, int numReps) {
   final Context ictx = (Context) ctx;
   try {
     do {
       ImageInputStream iis = ictx.createImageInputStream();
       iis.close();
       ictx.closeOriginalStream();
     } while (--numReps >= 0);
   } catch (IOException e) {
     e.printStackTrace();
   }
 }
コード例 #23
0
ファイル: BoolDecoder.java プロジェクト: 51ttw/plantuml
  private void initBoolDecoder() throws IOException {

    value = 0; /* value = first 16 input bits */

    data.seek(offset);
    value = data.readUnsignedByte() << 8;
    // value = (data[offset]) << 8;
    offset++;

    range = 255; /* initial range is full */
    bit_count = 0; /* have not yet shifted out any bits */
  }
コード例 #24
0
ファイル: IOUtilsTest.java プロジェクト: marcpawl/vassal
  @Test
  public void testCloseQuietlyImageInputStreamOpen() {
    final ImageInputStream in = new MemoryCacheImageInputStream(new NullInputStream(1000));

    IOUtils.closeQuietly(in);

    try {
      in.close();
      fail();
    } catch (IOException e) {
      // This, oddly, the expected behavior of close().
    }
  }
コード例 #25
0
  public boolean canDecodeInput(Object source) throws IOException {
    if (!(source instanceof ImageInputStream)) {
      return false;
    }

    ImageInputStream stream = (ImageInputStream) source;
    byte[] b = new byte[2];
    stream.mark();
    stream.readFully(b);
    stream.reset();

    return (b[0] == 0x42) && (b[1] == 0x4d);
  }
コード例 #26
0
ファイル: CsvFile.java プロジェクト: bcdev/beam
 private void skipToLine(long lineOffset) throws IOException {
   if (bytePositionForOffset.containsKey(lineOffset)) {
     stream.seek(bytePositionForOffset.get(lineOffset));
     return;
   }
   Map.Entry<Long, Long> entry = getBestOffset(lineOffset);
   stream.seek(entry.getValue());
   long linesToSkip = lineOffset - entry.getKey();
   for (int i = 0; i < linesToSkip; i++) {
     stream.readLine();
   }
   bytePositionForOffset.put(lineOffset, stream.getStreamPosition());
 }
コード例 #27
0
    BufferedImage getThumbnail(ImageInputStream iis, JPEGImageReader reader) throws IOException {
      iis.mark();
      iis.seek(streamPos);
      DataBufferByte buffer = new DataBufferByte(getLength());
      readByteBuffer(iis, buffer.getData(), reader, 1.0F, 0.0F);
      iis.reset();

      WritableRaster raster =
          Raster.createInterleavedRaster(
              buffer, thumbWidth, thumbHeight, thumbWidth * 3, 3, new int[] {0, 1, 2}, null);
      ColorModel cm =
          new ComponentColorModel(
              JPEG.JCS.sRGB, false, false, ColorModel.OPAQUE, DataBuffer.TYPE_BYTE);
      return new BufferedImage(cm, raster, false, null);
    }
コード例 #28
0
  /**
   * Load image data for file and put user data attributes into file.
   *
   * @param file File
   * @return true if file image is loaded.
   * @throws java.io.IOException if image can not be loaded
   */
  private static boolean refresh(@NotNull VirtualFile file) throws IOException {
    Long loadedTimeStamp = file.getUserData(TIMESTAMP_KEY);
    SoftReference<BufferedImage> imageRef = file.getUserData(BUFFERED_IMAGE_REF_KEY);
    if (loadedTimeStamp == null
        || loadedTimeStamp.longValue() != file.getTimeStamp()
        || SoftReference.dereference(imageRef) == null) {
      try {
        final byte[] content = file.contentsToByteArray();

        if (ICO_FORMAT.equalsIgnoreCase(file.getExtension())) {
          try {
            final BufferedImage image =
                ICO_IMAGE_PARSER.getBufferedImage(new ByteSourceArray(content), null);
            file.putUserData(FORMAT_KEY, ICO_FORMAT);
            file.putUserData(BUFFERED_IMAGE_REF_KEY, new SoftReference<>(image));
            return true;
          } catch (ImageReadException ignore) {
          }
        }

        InputStream inputStream = new ByteArrayInputStream(content, 0, content.length);
        ImageInputStream imageInputStream = ImageIO.createImageInputStream(inputStream);
        try {
          Iterator<ImageReader> imageReaders = ImageIO.getImageReaders(imageInputStream);
          if (imageReaders.hasNext()) {
            ImageReader imageReader = imageReaders.next();
            try {
              file.putUserData(FORMAT_KEY, imageReader.getFormatName());
              ImageReadParam param = imageReader.getDefaultReadParam();
              imageReader.setInput(imageInputStream, true, true);
              int minIndex = imageReader.getMinIndex();
              BufferedImage image = imageReader.read(minIndex, param);
              file.putUserData(BUFFERED_IMAGE_REF_KEY, new SoftReference<>(image));
              return true;
            } finally {
              imageReader.dispose();
            }
          }
        } finally {
          imageInputStream.close();
        }
      } finally {
        // We perform loading no more needed
        file.putUserData(TIMESTAMP_KEY, file.getTimeStamp());
      }
    }
    return false;
  }
コード例 #29
0
ファイル: DecodeBF16.java プロジェクト: attilaszia/yaosp
  public BufferedImage decode(ImageInputStream in) throws IOException, BMPException {
    if (!useDefaultMasks) bitmasks = readBitMasks(in);
    skipToImage(in);

    Dimension d = infoHeader.getSize();
    int h = (int) d.getHeight();
    int w = (int) d.getWidth();

    // BMP scanlines are padded to dword offsets
    int scansize = (w + (w & 1)) << 1;
    short[] data = new short[w * h];

    for (int y = h - 1; y >= 0; y--) {
      byte[] scanline = new byte[scansize];
      if (in.read(scanline) != scansize) throw new IOException("Couldn't read image data.");

      for (int x = 0; x < w; x++)
        data[x + y * w] =
            (short) ((scanline[x * 2] & (0xFF)) | ((scanline[x * 2 + 1] & (0xFF)) << 8));
    }

    ColorModel cm = new DirectColorModel(16, bitmasks[0], bitmasks[1], bitmasks[2]);
    SampleModel sm = new SinglePixelPackedSampleModel(DataBuffer.TYPE_USHORT, w, h, bitmasks);
    DataBuffer db = new DataBufferUShort(data, w * h, 0);
    WritableRaster raster = Raster.createWritableRaster(sm, db, null);
    return new BufferedImage(cm, raster, false, null);
  }
コード例 #30
0
ファイル: CsvFile.java プロジェクト: bcdev/beam
 @Override
 public void close() {
   try {
     stream.close();
   } catch (IOException ignore) {
   }
 }