下面列出了javax.imageio.ImageReader#getHeight ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
private java.awt.Dimension getImageSize(File image) throws IOException {
String filename = image.getName();
int p = filename.lastIndexOf('.');
if (p == -1) {
return null;
}
String suffix = filename.substring(p + 1).toLowerCase();
Iterator<ImageReader> readers = ImageIO.getImageReadersBySuffix(suffix);
if (readers.hasNext()) {
ImageReader reader = readers.next();
try {
try (ImageInputStream in = new FileImageInputStream(image)) {
reader.setInput(in);
int width = reader.getWidth(reader.getMinIndex());
int height = reader.getHeight(reader.getMinIndex());
return new java.awt.Dimension(width, height);
}
} finally {
reader.dispose();
}
} else {
return null;
}
}
public static BufferedImage readTexture(Object input, boolean cloak) throws IOException {
ImageReader reader = ImageIO.getImageReadersByMIMEType("image/png").next();
try {
reader.setInput(ImageIO.createImageInputStream(input), false, false);
// Verify texture bounds
int width = reader.getWidth(0);
int height = reader.getHeight(0);
if (!isValidTextureBounds(width, height, cloak))
throw new IOException(String.format("Invalid texture bounds: %dx%d", width, height));
// Read image
return reader.read(0);
} finally {
reader.dispose();
}
}
public static int[] getImageDimensions(File f) throws IOException {
ImageInputStream in = ImageIO.createImageInputStream(f);
try{
final Iterator readers = ImageIO.getImageReaders(in);
if(readers.hasNext()){
ImageReader reader=(ImageReader)readers.next();
try{
reader.setInput(in);
return new int[]{reader.getWidth(0), reader.getHeight(0)};
}finally{
reader.dispose();
}
}
}finally {
if(in!=null) in.close();
}
return null;
}
/**
* Gets image dimensions for given file
*
* @param imgFile image file
* @return dimensions of image
* @throws IOException if the file is not a known image
*/
public static Dimension getImageDimension(File imgFile) throws IOException {
int pos = imgFile.getName().lastIndexOf(".");
if (pos == -1)
throw new IOException("No extension for file: " + imgFile.getAbsolutePath());
String suffix = imgFile.getName().substring(pos + 1);
Iterator<ImageReader> iter = ImageIO.getImageReadersBySuffix(suffix);
while (iter.hasNext()) {
ImageReader reader = iter.next();
try {
ImageInputStream stream = new FileImageInputStream(imgFile);
reader.setInput(stream);
int width = reader.getWidth(reader.getMinIndex());
int height = reader.getHeight(reader.getMinIndex());
return new Dimension(width, height);
} catch (IOException e) {
log.warn("Error reading: " + imgFile.getAbsolutePath(), e);
} finally {
reader.dispose();
}
}
throw new IOException("Not a known image file: " + imgFile.getAbsolutePath());
}
public static int[] getImageDimensions(Object f) throws IOException {
if(f instanceof URL) f=((URL)f).openStream();
ImageInputStream in = ImageIO.createImageInputStream(f);
try{
final Iterator readers = ImageIO.getImageReaders(in);
if(readers.hasNext()){
ImageReader reader=(ImageReader)readers.next();
try{
reader.setInput(in);
return new int[]{reader.getWidth(0), reader.getHeight(0)};
}finally{
reader.dispose();
}
}
}finally {
if(in!=null) in.close();
}
return null;
}
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 ((float) w / h > (float) 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;
}
/**
* Gets image dimensions for given file
*
* @param imgFile image file
* @return dimensions of image
* @throws IOException if the file is not a known image
*/
public static Dimension getImageDimension(File imgFile) throws IOException {
int pos = imgFile.getName().lastIndexOf(".");
if (pos == -1)
throw new IOException("No extension for file: " + imgFile.getAbsolutePath());
String suffix = imgFile.getName().substring(pos + 1);
Iterator<ImageReader> iter = ImageIO.getImageReadersBySuffix(suffix);
if (iter.hasNext()) {
ImageReader reader = iter.next();
try {
ImageInputStream stream = new FileImageInputStream(imgFile);
reader.setInput(stream);
int width = reader.getWidth(reader.getMinIndex());
int height = reader.getHeight(reader.getMinIndex());
return new Dimension(width, height);
} finally {
reader.dispose();
}
}
throw new IOException("Not a known image file: " + imgFile.getAbsolutePath());
}
public static Dimension getImageDimension(URI imageURI) {
ImageInputStream inStream = null;
try {
inStream = ImageIO.createImageInputStream(imageURI.toURL().openStream());
Iterator<ImageReader> it = ImageIO.getImageReaders(inStream);
if (it.hasNext()) {
ImageReader reader = it.next();
reader.setInput(inStream);
Dimension ret = new Dimension(reader.getWidth(0), reader.getHeight(0));
reader.dispose();
inStream.close();
return ret;
}
} catch (IOException ex) {
}
return null;
}
private static Dimension getImageDimension(File imgFile) throws IOException {
int pos = imgFile.getName().lastIndexOf(".");
if (pos == -1)
throw new IOException("No extension for file: " + imgFile.getAbsolutePath());
String suffix = imgFile.getName().substring(pos + 1);
Iterator<ImageReader> iter = ImageIO.getImageReadersBySuffix(suffix);
while (iter.hasNext()) {
ImageReader reader = iter.next();
try {
ImageInputStream stream = new FileImageInputStream(imgFile);
reader.setInput(stream);
int width = reader.getWidth(reader.getMinIndex());
int height = reader.getHeight(reader.getMinIndex());
return new Dimension(width, height);
} catch (IOException e) {
LOG.log(Level.WARNING, "Error reading: " + imgFile.getAbsolutePath(), e);
} finally {
reader.dispose();
}
}
throw new IOException("Not a known image file: " + imgFile.getAbsolutePath());
}
public static Dimension getDimesion(InputStream input) throws IOException {
try (ImageInputStream in = ImageIO.createImageInputStream(input)) {
final Iterator<ImageReader> readers = ImageIO.getImageReaders(in);
if (readers.hasNext()) {
ImageReader reader = readers.next();
try {
reader.setInput(in);
return new Dimension(reader.getWidth(0), reader.getHeight(0));
} finally {
reader.dispose();
}
}
} catch (IOException ex) {
}
BufferedImage image = read(input);
return new Dimension(image.getWidth(), image.getHeight());
}
private void determineWidthAndHeight() throws IOException {
final ImageReader imgReader = getImageReader();
width_ = imgReader.getWidth(0);
height_ = imgReader.getHeight(0);
// ImageIO creates temp files; to save file handles
// we will cache the values and close this directly to free the resources
if (imageData_ != null) {
imageData_.close();
imageData_ = null;
}
}
public static BufferedImage readFileByHeight(String format, String filename,
int height) {
BufferedImage bufferedImage;
int scale = 1;
try {
if ("ico".equals(format) || "icon".equals(format)) {
bufferedImage = readIcon(new File(filename));
return ImageManufacture.scaleImageHeightKeep(bufferedImage, height);
}
ImageReader reader = getReader(format);
try ( ImageInputStream in = ImageIO.createImageInputStream(
new BufferedInputStream(new BufferedInputStream(new FileInputStream(filename))))) {
reader.setInput(in, false);
if (reader.getHeight(0) <= height) {
scale = 1;
} else {
scale = reader.getHeight(0) / height + 1;
if (scale < 2) {
scale = 2;
}
}
// logger.debug(height + " " + scale);
ImageReadParam param = reader.getDefaultReadParam();
param.setSourceSubsampling(scale, scale, 0, 0);
bufferedImage = reader.read(0, param);
// logger.debug(bufferedImage.getWidth() + " " + bufferedImage.getHeight());
reader.dispose();
}
} catch (Exception e) {
bufferedImage = readBrokenImage(e, new File(filename), scale);
}
return bufferedImage;
}
/***
* 获取图片的高
* @param srcImageFile 源图片路径
* @return
* @date 2016-3-30下午9:02:19
*/
public static int getImageHeight(String srcImageFile){
File file = new File(srcImageFile);
try {
Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName("jpg");
ImageReader reader = (ImageReader) readers.next();
ImageInputStream iis = ImageIO.createImageInputStream(file);
reader.setInput(iis, true);
return reader.getHeight(0);
} catch (IOException e) {
e.printStackTrace();
return 0;
}
}
@Test
public void testUpdateIcon() throws IOException {
final LinkedMultiValueMap<String, Object> multipartData = new LinkedMultiValueMap<>();
multipartData.add("icon", new InputStreamResource(getClass().getResourceAsStream("test-image.png")));
final ResponseEntity<Connector> updated = post("/api/v1/connectors/twitter/icon",
multipartData, Connector.class, tokenRule.validToken(), HttpStatus.OK,
multipartHeaders());
assertThat(updated.getBody().getId()).isPresent();
assertThat(updated.getBody().getIcon()).isNotBlank().startsWith("db:");
final ResponseEntity<ByteArrayResource> got = get("/api/v1/connectors/twitter/icon", ByteArrayResource.class);
assertThat(got.getHeaders().getFirst("Content-Type")).isEqualTo("image/png");
try (ImageInputStream iis = ImageIO.createImageInputStream(got.getBody().getInputStream());) {
final Iterator<ImageReader> readers = ImageIO.getImageReaders(iis);
if (readers.hasNext()) {
final ImageReader reader = readers.next();
try {
reader.setInput(iis);
final Dimension dimensions = new Dimension(reader.getWidth(0), reader.getHeight(0));
assertThat(dimensions.getHeight()).as("Wrong image height").isEqualTo(106d);
assertThat(dimensions.getWidth()).as("Wrong image width").isEqualTo(106d);
} finally {
reader.dispose();
}
}
}
}
public static BufferedImage create(File inputFile, int imageType) throws IOException {
try (ImageInputStream stream = ImageIO.createImageInputStream(inputFile);) {
Iterator<ImageReader> readers = ImageIO.getImageReaders(stream);
if (readers.hasNext()) {
try {
ImageReader reader = readers.next();
reader.setInput(stream, true, true);
int width = reader.getWidth(reader.getMinIndex());
int height = reader.getHeight(reader.getMinIndex());
BufferedImage image = create(width, height, imageType);
int cores = Math.max(1, Runtime.getRuntime().availableProcessors() / 2);
int block = Math.min(MAX_PIXELS_IN_MEMORY / cores / width, (int) (Math.ceil(height / (double) cores)));
ExecutorService generalExecutor = Executors.newFixedThreadPool(cores);
List<Callable<ImagePartLoader>> partLoaders = new ArrayList<>();
for (int y = 0; y < height; y += block) {
partLoaders.add(new ImagePartLoader(
y, width, Math.min(block, height - y), inputFile, image));
}
generalExecutor.invokeAll(partLoaders);
generalExecutor.shutdown();
return image;
} catch (InterruptedException ex) {
Logger.getLogger(BigBufferedImage.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
return null;
}
protected Result saveImage(final ImageInputStream input, final File outputFile) throws IOException {
final FessConfig fessConfig = ComponentUtil.getFessConfig();
final Iterator<ImageReader> readers = ImageIO.getImageReaders(input);
if (readers.hasNext()) {
final ImageReader reader = readers.next();
try {
reader.setInput(input);
final ImageReadParam param = reader.getDefaultReadParam();
final int width = reader.getWidth(0);
final int height = reader.getHeight(0);
if (width <= 0 || height <= 0) {
return Result.NO_IMAGE;
}
if (!fessConfig.validateThumbnailSize(width, height)) {
return Result.INVALID_SIZE;
}
final int samplingWidth = width / fessConfig.getThumbnailHtmlImageThumbnailWidthAsInteger();
final int samplingHeight = height / fessConfig.getThumbnailHtmlImageThumbnailHeightAsInteger();
param.setSourceSubsampling(samplingWidth <= 0 ? 1 : samplingWidth, samplingHeight <= 0 ? 1 : samplingHeight, 0, 0);
param.setSourceRegion(new Rectangle(width, height > width ? width : height));
final BufferedImage image = reader.read(0, param);
final int thumbnailWidth = fessConfig.getThumbnailHtmlImageThumbnailWidthAsInteger();
final int thumbnailHeight =
(int) ((height > width ? width : height) * fessConfig.getThumbnailHtmlImageThumbnailWidthAsInteger().floatValue() / width);
final BufferedImage thumbnail = new BufferedImage(thumbnailWidth, thumbnailHeight, image.getType());
thumbnail.getGraphics().drawImage(image.getScaledInstance(thumbnailWidth, thumbnailHeight, Image.SCALE_AREA_AVERAGING), 0,
0, thumbnailWidth, thumbnailHeight, null);
ImageIO.write(thumbnail, fessConfig.getThumbnailHtmlImageFormat(), outputFile);
image.flush();
return Result.OK;
} finally {
reader.dispose();
}
}
return Result.FAILED;
}
/***
* 缩放图像，按照长宽缩放
* @param srcImageFile
* @param result
* @param height 变换后的高度
* @param width 变换后的长度
* @param bb 比例不对称时，是否补白，true 补白;false 不补白
* @return
* @date 2016-3-30下午2:44:37
*/
public static boolean scale2(String srcImageFile, String result, int height, int width, boolean bb) {
try {
double ratio = 0.0; // 缩放比例
File file = new File(srcImageFile);
BufferedImage bi = ImageIO.read(file); // 读入文件
Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName("jpg");
ImageReader reader = (ImageReader) readers.next();
ImageInputStream iis = ImageIO.createImageInputStream(file);
reader.setInput(iis, true);
int width1 = reader.getWidth(0); // 得到源图宽
int height1 = reader.getHeight(0); // 得到源图长
@SuppressWarnings("static-access")
Image itemp = bi.getScaledInstance(width, height, bi.SCALE_SMOOTH);
// 计算比例
if ((height1 > height) || (width1 > width)) {
if (height1 > width1) {
ratio = (new Integer(height)).doubleValue()
/ height1;
} else {
ratio = (new Integer(width)).doubleValue() / width1;
}
AffineTransformOp op = new AffineTransformOp(AffineTransform
.getScaleInstance(ratio, ratio), null);
itemp = op.filter(bi, null);
}
if (bb) {//补白
BufferedImage image = new BufferedImage(width, height,
BufferedImage.TYPE_INT_RGB);
Graphics2D g = image.createGraphics();
g.setColor(Color.white);
g.fillRect(0, 0, width, height);
if (width == itemp.getWidth(null))
g.drawImage(itemp, 0, (height - itemp.getHeight(null)) / 2,
itemp.getWidth(null), itemp.getHeight(null),
Color.white, null);
else
g.drawImage(itemp, (width - itemp.getWidth(null)) / 2, 0,
itemp.getWidth(null), itemp.getHeight(null),
Color.white, null);
g.dispose();
itemp = image;
}
ImageIO.write((BufferedImage) itemp, "JPEG", new File(result));
return true;
} catch (IOException e) {
e.printStackTrace();
return false;
}
}
@Test
public void testUpdateConnectorAndIconViaMultipart() throws IOException {
final Connector initialConnector = dataManager.fetch(Connector.class, "twitter");
assertThat(initialConnector.getIcon()).isNotBlank().doesNotStartWith("db:");
final Connector connectorWithNewdescription = new Connector.Builder().createFrom(initialConnector)
.description("Updated!").build();
final LinkedMultiValueMap<String, Object> multipartData = new LinkedMultiValueMap<>();
multipartData.add("connector", connectorWithNewdescription);
multipartData.add("icon", new InputStreamResource(getClass().getResourceAsStream("test-image.png")));
put("/api/v1/connectors/twitter",
multipartData, Void.class, tokenRule.validToken(), HttpStatus.NO_CONTENT,
multipartHeaders());
final ResponseEntity<Connector> updatedConnector = get("/api/v1/connectors/twitter", Connector.class);
assertThat(updatedConnector.getBody().getId()).isPresent();
assertThat(updatedConnector.getBody().getIcon()).isNotBlank().startsWith("db:");
assertThat(updatedConnector.getBody().getDescription()).isNotBlank().isEqualTo("Updated!");
final ResponseEntity<ByteArrayResource> got = get("/api/v1/connectors/twitter/icon", ByteArrayResource.class);
assertThat(got.getHeaders().getFirst("Content-Type")).isEqualTo("image/png");
try (ImageInputStream iis = ImageIO.createImageInputStream(got.getBody().getInputStream());) {
final Iterator<ImageReader> readers = ImageIO.getImageReaders(iis);
if (readers.hasNext()) {
final ImageReader reader = readers.next();
try {
reader.setInput(iis);
final Dimension dimensions = new Dimension(reader.getWidth(0), reader.getHeight(0));
assertThat(dimensions.getHeight()).as("Wrong image height").isEqualTo(106d);
assertThat(dimensions.getWidth()).as("Wrong image width").isEqualTo(106d);
} finally {
reader.dispose();
}
}
}
}
@Test
public void testThumbnail() throws Exception {
String orig = p("test-imag" + E_ACCENT + ".jpeg");
// Upload an image.
InputStream in = this.getClass().getResourceAsStream("/test-image.jpeg");
if (in == null) {
throw new AssertionError("couldn't load test image \"test-image.jpeg\"");
}
DbxEntry.File origMD;
try {
origMD = client.uploadFile(orig, DbxWriteMode.add(), -1, in);
}
finally {
IOUtil.closeInput(in);
}
BufferedImage origImage = ImageIO.read(getClass().getResource("/test-image.jpeg"));
int origW = origImage.getWidth();
int origH = origImage.getHeight();
DbxThumbnailFormat[] formats = { DbxThumbnailFormat.JPEG, DbxThumbnailFormat.PNG, };
DbxThumbnailSize[] sizes = {
DbxThumbnailSize.w32h32,
DbxThumbnailSize.w64h64,
DbxThumbnailSize.w64h64,
DbxThumbnailSize.w640h480,
DbxThumbnailSize.w1024h768,
};
for (DbxThumbnailFormat format : formats) {
long prevSize = 0;
ImageReader reader = getImageReaderForFormat(format);
for (DbxThumbnailSize size : sizes) {
ByteArrayOutputStream out = new ByteArrayOutputStream();
DbxEntry.File md = client.getThumbnail(size, format, orig, null, out);
byte[] data = out.toByteArray();
assertEquals(removeMediaInfo(origMD), removeMediaInfo(md));
// We're getting bigger and bigger thumbnails, so they should have more bytes
// than the previous ones.
assertTrue(data.length > prevSize);
reader.setInput(new MemoryCacheImageInputStream(new ByteArrayInputStream(data)));
int w = reader.getWidth(0);
int h = reader.getHeight(0);
int expectedW = Math.min(size.width, origW);
int expectedH = Math.min(size.width, origH);
assertTrue((w == expectedW && h <= expectedH) || (h == expectedH && w <= expectedW),
"expected = " + expectedW + "x" + expectedH + ", got = " + w + "x" + h);
}
}
}
private void readImages(IDataHolder output, ImageReader reader) throws IOException, ScanFileHolderException {
int n = reader.getNumImages(true);
if (n == 0) {
return;
}
if (!loadData)
return;
boolean allSame = true;
if (height < 0 || width < 0) {
height = reader.getHeight(0); // this can throw NPE when using 12-bit reader
width = reader.getWidth(0);
for (int i = 1; i < n; i++) {
if (height != reader.getHeight(i) || width != reader.getWidth(i)) {
allSame = false;
break;
}
}
}
final ImageTypeSpecifier its = reader.getRawImageType(0); // this raises an exception for 12-bit images when using standard reader
if (allSame) {
for (int i = 1; i < n; i++) {
if (!its.equals(reader.getRawImageType(i))) {
throw new ScanFileHolderException("Type of image in stack does not match first");
}
}
}
int dtype = AWTImageUtils.getDTypeFromImage(its.getSampleModel(), keepBitWidth)[0];
if (n == 1) {
ILazyDataset image;
if (loadLazily) {
image = createLazyDataset(dtype, height, width);
} else {
image = createDataset(reader.read(0));
}
image.setName(DEF_IMAGE_NAME);
image.setMetadata(metadata);
output.addDataset(DEF_IMAGE_NAME, image);
} else if (allSame) {
ILazyDataset ld = createLazyDataset(dtype, n, height, width);
ld.setMetadata(metadata);
output.addDataset(STACK_NAME, ld);
} else {
createLazyDatasets(output, reader);
}
if (loadMetadata) {
createMetadata(output, reader);
metadata.setMetadata(metadataMap);
output.setMetadata(metadata);
}
}