public static BufferedImage cut(String format, InputStream src, int x, int y, int w, int h) throws IOException { Iterator<ImageReader> iterator = ImageIO.getImageReadersByFormatName(format); ImageReader reader = (ImageReader) iterator.next(); ImageInputStream iis = ImageIO.createImageInputStream(src); reader.setInput(iis, true); ImageReadParam param = reader.getDefaultReadParam(); int imgWidth = reader.getWidth(0); int imgHeight = reader.getHeight(0); if (x + w > imgWidth) { w = imgWidth - x; } if (y + h > imgHeight) { h = imgHeight - y; } Rectangle rect = new Rectangle(x, y, w, h); param.setSourceRegion(rect); BufferedImage bi = reader.read(0, param); return bi; }
@Override public void newData(byte[] bytes) { if(Dashboard.visionInitialized()){ Mat m = CvProcessing.byteArray2Mat(bytes); Dashboard.setForVision(m); } if(mode == DisplayMode.Normal){ ByteArrayInputStream bis = new ByteArrayInputStream(bytes); Iterator<?> readers = ImageIO.getImageReadersByFormatName("jpeg"); ImageReader reader = (ImageReader) readers.next(); Object source = bis; try { ImageInputStream iis = ImageIO.createImageInputStream(source); reader.setInput(iis, true); ImageReadParam param = reader.getDefaultReadParam(); BufferedImage image = reader.read(0, param); setImage(image); } catch (IOException e) { } } }
public TIFFRenderedImage(TIFFImageReader reader, int imageIndex, ImageReadParam readParam, int width, int height) throws IOException { this.reader = reader; this.imageIndex = imageIndex; this.tileParam = cloneImageReadParam(readParam, false); this.subsampleX = tileParam.getSourceXSubsampling(); this.subsampleY = tileParam.getSourceYSubsampling(); this.isSubsampling = this.subsampleX != 1 || this.subsampleY != 1; this.width = width/subsampleX; this.height = height/subsampleY; // If subsampling is being used, we may not match the // true tile grid exactly, but everything should still work this.tileWidth = reader.getTileWidth(imageIndex)/subsampleX; this.tileHeight = reader.getTileHeight(imageIndex)/subsampleY; Iterator<ImageTypeSpecifier> iter = reader.getImageTypes(imageIndex); this.its = iter.next(); tileParam.setDestinationType(its); }
public BufferedImage read(int imageIndex, ImageReadParam param) throws IOException { checkState(imageIndex); int len = 3*width*height; byte[] imageData = new byte[len]; // The following is not efficient and is skipping all the // progress updates, and ignoring the ImageReadParam, which // it should not, but it is all we need for this test. stream.readFully(imageData, 0, len); BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB); int off = 0; for (int h=0;h<height;h++) { int rgb = imageData[off]++ << 16 | imageData[off++] << 8 | imageData[off++]; for (int w=0;w<width;w++) { bi.setRGB(w, h, rgb); } } return bi; }
@Override public BufferedImage readTile(int imageIndex, int tileX, int tileY) throws IOException { checkIndex(imageIndex); int xOffset = getTileGridXOffset(imageIndex); int yOffset = getTileGridYOffset(imageIndex); int tileWidth = getTileWidth(imageIndex); int tileHeight = getTileHeight(imageIndex); Rectangle region = new Rectangle( xOffset + tileX * tileWidth, yOffset + tileY * tileHeight, tileWidth, tileHeight); if (region.x + region.width > getWidth(imageIndex) || region.y + region.height > getHeight(imageIndex)) { throw new IllegalArgumentException("Tile indices out of bounds."); } ImageReadParam param = getDefaultReadParam(); param.setSourceRegion(region); return this.read(imageIndex, param); }
public static BufferedImage readImage(Object source) throws IOException { ImageInputStream stream = ImageIO.createImageInputStream(source); ImageReader reader = ImageIO.getImageReaders(stream).next(); reader.setInput(stream); ImageReadParam param =reader.getDefaultReadParam(); ImageTypeSpecifier typeToUse = null; for (Iterator i = reader.getImageTypes(0);i.hasNext(); ) { ImageTypeSpecifier type = (ImageTypeSpecifier) i.next(); if (type.getColorModel().getColorSpace().isCS_sRGB()) typeToUse = type; } if (typeToUse!=null) param.setDestinationType(typeToUse); BufferedImage b = reader.read(0, param); reader.dispose(); stream.close(); return b; }
/** Determine parameters for image reading based on the IIIF selector and a given scaling factor **/ private ImageReadParam getReadParam(ImageReader reader, ImageApiSelector selector, double decodeScaleFactor) throws IOException { ImageReadParam readParam = reader.getDefaultReadParam(); Dimension nativeDimensions = new Dimension(reader.getWidth(0), reader.getHeight(0)); Rectangle targetRegion = selector.getRegion().resolve(nativeDimensions); // IIIF regions are always relative to the native size, while ImageIO regions are always relative to the decoded // image size, hence the conversion Rectangle decodeRegion = new Rectangle( (int) Math.ceil(targetRegion.getX() * decodeScaleFactor), (int) Math.ceil(targetRegion.getY() * decodeScaleFactor), (int) Math.ceil(targetRegion.getWidth() * decodeScaleFactor), (int) Math.ceil(targetRegion.getHeight() * decodeScaleFactor)); readParam.setSourceRegion(decodeRegion); // TurboJpegImageReader can rotate during decoding boolean didRotate = false; if (selector.getRotation().getRotation() != 0 && reader instanceof TurboJpegImageReader) { ((TurboJpegImageReadParam) readParam).setRotationDegree((int) selector.getRotation().getRotation()); didRotate = true; } return readParam; }
private static LoadedImage read(ImageInputStream stream, ImageType imageType) throws IOException { if (stream == null) { throw new IllegalArgumentException("stream == null!"); } Iterator iter = ImageIO.getImageReaders(stream); if (!iter.hasNext()) { return null; } ImageReader reader = (ImageReader) iter.next(); ImageReadParam param = reader.getDefaultReadParam(); reader.setInput(stream, true, true); BufferedImage bi; IIOMetadata metadata; try { metadata = reader.getImageMetadata(0); bi = reader.read(0, param); } finally { reader.dispose(); stream.close(); } return new LoadedImage(null, bi, metadata, null); }
@Deprecated public static BufferedImage readSvg(File file, Dimension sourceDimension) throws Exception { try (ImageInputStream input = ImageIO.createImageInputStream(file)) { Iterator<ImageReader> readers = ImageIO.getImageReaders(input); if (!readers.hasNext()) { throw new IllegalArgumentException("No reader for: " + file); } ImageReader reader = readers.next(); try { reader.setInput(input); ImageReadParam param = reader.getDefaultReadParam(); param.setSourceRenderSize(sourceDimension); return reader.read(0, param); } finally { reader.dispose(); } } }
/** * @Description:截图 * @author:liuyc * @time:2016年5月27日 上午10:18:23 * @param srcFile源图片、targetFile截好后图片全名、startAcross 开始截取位置横坐标、StartEndlong开始截图位置纵坐标、width截取的长,hight截取的高 */ public static void cutImage(String srcFile, String targetFile, int startAcross, int StartEndlong, int width, int hight) throws Exception { // 取得图片读入器 Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName("jpg"); ImageReader reader = readers.next(); // 取得图片读入流 InputStream source = new FileInputStream(srcFile); ImageInputStream iis = ImageIO.createImageInputStream(source); reader.setInput(iis, true); // 图片参数对象 ImageReadParam param = reader.getDefaultReadParam(); Rectangle rect = new Rectangle(startAcross, StartEndlong, width, hight); param.setSourceRegion(rect); BufferedImage bi = reader.read(0, param); ImageIO.write(bi, targetFile.split("\\.")[1], new File(targetFile)); }
private List<BufferedImage> getBufferedImages(byte[] favIconBytes) throws IOException { try (ImageInputStream stream = ImageIO.createImageInputStream(new ByteArrayInputStream(favIconBytes))) { Iterator<ImageReader> iter = ImageIO.getImageReaders(stream); if (!iter.hasNext()) { return Collections.emptyList(); } ImageReader reader = (ImageReader) iter.next(); try { ImageReadParam param = reader.getDefaultReadParam(); reader.setInput(stream, true, true); List<BufferedImage> bufferedImages = new ArrayList<>(); int i = 0; while (true) { try { BufferedImage bufferedImage = reader.read(i, param); bufferedImages.add(bufferedImage); } catch (IndexOutOfBoundsException e) { return bufferedImages; } i++; } } finally { reader.dispose(); } } }
private static BufferedImage readBuffereImage(ImageReader reader, int w, int h) throws IOException { ImageReadParam param = reader.getDefaultReadParam(); int srcWidth = reader.getWidth(0); int srcHeight = reader.getHeight(0); Rectangle rect = null; if (w / h > srcWidth / srcHeight) { h = h * srcWidth / w; w = srcWidth; rect = new Rectangle(0, (srcHeight - h) / 2, w, h); } else { w = w * srcHeight / h; h = srcHeight; rect = new Rectangle((srcWidth - w) / 2, 0, w, h); } param.setSourceRegion(rect); BufferedImage srcBuffered = reader.read(0, param); return srcBuffered; }
@NotNull public static BufferedImage readImageFromBytes(@NotNull byte[] content) throws IOException { 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 { ImageReadParam param = imageReader.getDefaultReadParam(); imageReader.setInput(imageInputStream, true, true); int minIndex = imageReader.getMinIndex(); return imageReader.read(minIndex, param); } finally { imageReader.dispose(); } } } finally { imageInputStream.close(); } throw new IOException("Can't read image from given content"); }
/** * 方法(私有)<br> * 名称: cropImage<br> * 描述: 根据指定的位置和尺寸剪切图片<br> * * @return BufferedImage - 图片字节数组 * @throws java.io.IOException */ private ByteArrayOutputStream cropImage (ByteArrayOutputStream out,int x,int y,int width,int height) throws IOException { Iterator iterator=ImageIO.getImageReadersByFormatName(this.outputFormat.getFormat()); ImageReader reader=(ImageReader)iterator.next(); InputStream in=new ByteArrayInputStream(out.toByteArray()); ImageInputStream iis=ImageIO.createImageInputStream(in); reader.setInput(iis,true); ImageReadParam param=reader.getDefaultReadParam(); Rectangle rect=new Rectangle(x,y,width,height); param.setSourceRegion(rect); BufferedImage bi=reader.read(0,param); out.reset(); ImageIO.write(bi,this.outputFormat.getFormat(),out); //System.out.println("dropImage:"+out.toByteArray().length); return out; }
/** * <p> * Validate that the specified {@link javax.imageio.ImageReadParam} contains * only the default values. If non-default values are present, * {@link java.io.IOException} is thrown. * </p> * * @param param * the <code>ImageReadParam</code> to be validated * @param head * the <code>TGAHeader</code> that contains information about the * source image * @throws IOException * if the <code>ImageReadParam</code> contains non-default * values */ private void checkImageReadParam(final ImageReadParam param, final TGAHeader header) throws IOException { if (param != null) { // get the image height and width from the header for convenience final int width = header.getWidth(); final int height = header.getHeight(); // ensure that the param contains only the defaults final Rectangle sourceROI = param.getSourceRegion(); if ((sourceROI != null) && ((sourceROI.x != 0) || (sourceROI.y != 0) || (sourceROI.width != width) || (sourceROI.height != height))) { throw new IOException("The source region of interest is not the default."); // FIXME: // localize } /* else -- the source ROI is the default */ final Rectangle destinationROI = param.getSourceRegion(); if ((destinationROI != null) && ((destinationROI.x != 0) || (destinationROI.y != 0) || (destinationROI.width != width) || (destinationROI.height != height))) { throw new IOException("The destination region of interest is not the default."); // FIXME: // localize } /* else -- the destination ROI is the default */ if ((param.getSourceXSubsampling() != 1) || (param.getSourceYSubsampling() != 1)) { throw new IOException("Source sub-sampling is not supported."); // FIXME: // localize } /* else -- sub-sampling is the default */ } /* else -- the ImageReadParam is null so the defaults *are* used */ }
/** * Workaround for sRGB color space bug on JRE 1.5 * http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4705399 * * @param source (inputstream or File) * @return fixed buffered image * @throws IOException */ public static BufferedImage readImage(Object source) throws IOException { ImageInputStream stream = ImageIO.createImageInputStream(source); ImageReader reader = ImageIO.getImageReaders(stream).next(); reader.setInput(stream); ImageReadParam param =reader.getDefaultReadParam(); ImageTypeSpecifier typeToUse = null; for (Iterator i = reader.getImageTypes(0);i.hasNext(); ) { ImageTypeSpecifier type = (ImageTypeSpecifier) i.next(); if (type.getColorModel().getColorSpace().isCS_sRGB()) typeToUse = type; } if (typeToUse!=null) param.setDestinationType(typeToUse); BufferedImage b = reader.read(0, param); reader.dispose(); stream.close(); return b; }
@Override public ImagePartLoader call() throws Exception { Thread.currentThread().setPriority((Thread.MIN_PRIORITY + Thread.NORM_PRIORITY) / 2); try (ImageInputStream stream = ImageIO.createImageInputStream(file);) { Iterator<ImageReader> readers = ImageIO.getImageReaders(stream); if (readers.hasNext()) { ImageReader reader = readers.next(); reader.setInput(stream, true, true); ImageReadParam param = reader.getDefaultReadParam(); param.setSourceRegion(region); BufferedImage part = reader.read(0, param); Raster source = part.getRaster(); WritableRaster target = image.getRaster(); target.setRect(0, y, source); } } return ImagePartLoader.this; }
@Override public BufferedImage read(int imageIndex, ImageReadParam param) throws IOException { readHeader(); ImageInputStream in = (ImageInputStream) getInput(); SubImageInputStream sin = new SubImageInputStream(in, imageOffsets[imageIndex], imageLengths[imageIndex]); sin.seek(0); ImageReader ir = new CMYKJPEGImageReader(getOriginatingProvider()); ir.setInput(sin); BufferedImage img = ir.read(0); ir.dispose(); return img; }
@Override public ImagePartLoader call() throws Exception { Thread.currentThread().setPriority((Thread.MIN_PRIORITY + Thread.NORM_PRIORITY) / 2); ImageInputStream stream = ImageIO.createImageInputStream(file); Iterator<ImageReader> readers = ImageIO.getImageReaders(stream); if (readers.hasNext()) { ImageReader reader = readers.next(); reader.setInput(stream, true, true); ImageReadParam param = reader.getDefaultReadParam(); param.setSourceRegion(region); BufferedImage part = reader.read(0, param); Raster source = part.getRaster(); WritableRaster target = image.getRaster(); target.setRect(0, y, source); } return ImagePartLoader.this; }
@Override public BufferedImage read(int i, ImageReadParam imageReadParam) throws IOException { if (iis == null) { throw new IllegalArgumentException("input stream == null"); } DecodingImageSource source = new IISDecodingImageSource(iis); OffscreenImage image = new OffscreenImage(source); source.addConsumer(image); source.load(); // The interrupted flag should be cleared because ImageDecoder interrupts // current thread while decoding. The same technique is used in // ImageLoader#run(). Another solution can be to create // a separate decoding thread. However, decoder keeps its own pool // of threads so creating a new thread will be just a waste of resources. Thread.interrupted(); return image.getBufferedImage(); }
public static Image readImage(String filePath) { try { File source = new File(filePath); ImageInputStream iis = ImageIO.createImageInputStream(source); Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName("png"); final ImageReader reader = readers.next(); reader.setInput(iis, true); final ImageReadParam param = reader.getDefaultReadParam(); BufferedImage bi = reader.read(0, param); reader.dispose(); return bi; } catch (IOException ex) { System.err.println("Failed to load image " + filePath); return null; } }
private Optional<Image> tryLoad(ImageReader reader, byte[] bytes, int type) { try { reader.setInput(new ByteArrayInputStream(bytes), true, true); ImageReadParam params = reader.getDefaultReadParam(); Iterator<ImageTypeSpecifier> imageTypes = reader.getImageTypes(0); while (imageTypes.hasNext()) { ImageTypeSpecifier imageTypeSpecifier = imageTypes.next(); int bufferedImageType = imageTypeSpecifier.getBufferedImageType(); if (bufferedImageType == BufferedImage.TYPE_BYTE_GRAY) { params.setDestinationType(imageTypeSpecifier); } } BufferedImage bufferedImage = reader.read(0, params); return Optional.of(Image$.MODULE$.wrapAwt(bufferedImage)); } catch (Exception e) { return Optional.empty(); } }
public TIFFRenderedImage(TIFFImageReader reader, int imageIndex, ImageReadParam readParam, int width, int height) throws IOException { this.reader = reader; this.imageIndex = imageIndex; this.tileParam = cloneImageReadParam(readParam, false); this.subsampleX = tileParam.getSourceXSubsampling(); this.subsampleY = tileParam.getSourceYSubsampling(); this.isSubsampling = this.subsampleX != 1 || this.subsampleY != 1; this.width = width/subsampleX; this.height = height/subsampleY; // If subsampling is being used, we may not match the // true tile grid exactly, but everything should still work this.tileWidth = reader.getTileWidth(imageIndex)/subsampleX; this.tileHeight = reader.getTileHeight(imageIndex)/subsampleY; Iterator iter = reader.getImageTypes(imageIndex); this.its = (ImageTypeSpecifier)iter.next(); tileParam.setDestinationType(its); }
public RenderedImage readAsRenderedImage(int imageIndex, ImageReadParam param) throws java.io.IOException { if (param == null) param = getDefaultReadParam(); checkIndex(imageIndex); clearAbortRequest(); processImageStarted(0); RenderedImage image = new RawRenderedImage(iis, this, param, imageIndex); if (abortRequested()) processReadAborted(); else processImageComplete(); return image; }
public void cut() throws IOException { FileInputStream is = null; ImageInputStream iis = null; try { is = new FileInputStream(srcpath); Iterator<ImageReader> it = ImageIO.getImageReadersByFormatName(this.imageType); ImageReader reader = it.next(); iis = ImageIO.createImageInputStream(is); reader.setInput(iis, true); ImageReadParam param = reader.getDefaultReadParam(); Rectangle rect = new Rectangle(x, y, width, height); param.setSourceRegion(rect); BufferedImage bi = reader.read(0, param); ImageIO.write(bi, this.imageType, new File(subpath)); } finally { if (is != null) is.close(); if (iis != null) iis.close(); } }
public static BufferedImage read(String format, InputStream in) throws IOException { Iterator<ImageReader> iterator = ImageIO.getImageReadersByFormatName(format); ImageReader reader = (ImageReader) iterator.next(); ImageInputStream iis = ImageIO.createImageInputStream(in); reader.setInput(iis, true); ImageReadParam param = reader.getDefaultReadParam(); BufferedImage bi = reader.read(0, param); return bi; }
@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 } } } }
public BufferedImage read(int imageIndex, ImageReadParam param) throws IIOException { if (imageIndex != 0) { throw new IndexOutOfBoundsException("imageIndex != 0!"); } readImage(param); return theImage; }
public BufferedImage read(int imageIndex, ImageReadParam param) throws IOException { if (input == null) throw new IllegalStateException(); if (imageIndex >= 5 || imageIndex < 0) throw new IndexOutOfBoundsException(); if (seekForwardOnly) { if (imageIndex < minIndex) throw new IndexOutOfBoundsException(); minIndex = imageIndex; } return getDestination(param, getImageTypes(imageIndex), 10, 15); }
public static void computeRegions(ImageReadParam param, int srcWidth, int srcHeight, BufferedImage image, Rectangle srcRegion, Rectangle destRegion) { ImageReader.computeRegions(param, srcWidth, srcHeight, image, srcRegion, destRegion); }
public static void checkReadParamBandSettings(ImageReadParam param, int numSrcBands, int numDstBands) { ImageReader.checkReadParamBandSettings( param, numSrcBands, numDstBands); }
public static BufferedImage getDestination(ImageReadParam param, Iterator imageTypes, int width, int height) throws IIOException { return ImageReader.getDestination(param, imageTypes, width, height); }
private static void testType(ImageReader reader, ImageTypeSpecifier t, BufferedImage src) throws IOException { ImageReadParam p = reader.getDefaultReadParam(); p.setDestinationType(t); BufferedImage dst = reader.read(0, p); verify(src, dst, t); }
/** * Creates a copy of {@code param}. The source subsampling and * and bands settings and the destination bands and offset settings * are copied. If {@code param} is a {@code TIFFImageReadParam} * then the {@code TIFFDecompressor} and * {@code TIFFColorConverter} settings are also copied; otherwise * they are explicitly set to {@code null}. * * @param param the parameters to be copied. * @param copyTagSets whether the {@code TIFFTagSet} settings * should be copied if set. * @return copied parameters. */ private ImageReadParam cloneImageReadParam(ImageReadParam param, boolean copyTagSets) { // Create a new TIFFImageReadParam. TIFFImageReadParam newParam = new TIFFImageReadParam(); // Copy the basic settings. newParam.setSourceSubsampling(param.getSourceXSubsampling(), param.getSourceYSubsampling(), param.getSubsamplingXOffset(), param.getSubsamplingYOffset()); newParam.setSourceBands(param.getSourceBands()); newParam.setDestinationBands(param.getDestinationBands()); newParam.setDestinationOffset(param.getDestinationOffset()); if (param instanceof TIFFImageReadParam && copyTagSets) { // Copy the settings from the input parameter. TIFFImageReadParam tparam = (TIFFImageReadParam) param; List<TIFFTagSet> tagSets = tparam.getAllowedTagSets(); if (tagSets != null) { Iterator<TIFFTagSet> tagSetIter = tagSets.iterator(); if (tagSetIter != null) { while (tagSetIter.hasNext()) { TIFFTagSet tagSet = tagSetIter.next(); newParam.addAllowedTagSet(tagSet); } } } } return newParam; }
public BufferedImage readTile(int imageIndex, int tileX, int tileY) throws IOException { int w = getWidth(imageIndex); int h = getHeight(imageIndex); int tw = getTileWidth(imageIndex); int th = getTileHeight(imageIndex); int x = tw * tileX; int y = th * tileY; if (tileX < 0 || tileY < 0 || x >= w || y >= h) { throw new IllegalArgumentException("Tile indices are out of bounds!"); } if (x + tw > w) { tw = w - x; } if (y + th > h) { th = h - y; } ImageReadParam param = getDefaultReadParam(); Rectangle tileRect = new Rectangle(x, y, tw, th); param.setSourceRegion(tileRect); return read(imageIndex, param); }
public RenderedImage readAsRenderedImage(int imageIndex, ImageReadParam param) throws IOException { prepareRead(imageIndex, param); return new TIFFRenderedImage(this, imageIndex, imageReadParam, width, height); }