/**
*
*/
paquete com.b510;
importar java.awt.Rectangle;
importar java.awt.image.BufferedImage;
importar java.io.File;
importar java.io.FileInputStream;
importar java.io.IOException;
importar java.util.Fecha;
importar java.util.Iterator;
importar javax.imageio.ImageIO;
importar javax.imageio.ImageReadParam;
importar javax.imageio.ImageReader;
importar javax.imageio.stream.ImageInputStream;
/**
* @fecha 2012-11-26
*@autor xhw
*
*/
clase pública ImageCut {
/**
* Nombre de ruta de la imagen de origen, como por ejemplo: c:/1.jpg
*/
cadena privada srcpath = "e:/poool.jpg";
/**
* Cortar el nombre de la ruta de almacenamiento de la imagen. Por ejemplo: c:/2.jpg.
*/
subruta de cadena privada = "e:/pool_end";
/**
*formato de imagen jpg
*/
Cadena final estática privada IMAGE_FORM_OF_JPG = "jpg";
/**
*formato de imagen png
*/
cadena final estática privada IMAGE_FORM_OF_PNG = "png";
/**
* coordenada x del punto de corte
*/
privado int x;
/**
* Coordenada Y del punto de corte
*/
privado int y;
/**
* Ancho del punto de corte
*/
ancho int privado;
/**
* Altura del punto de corte
*/
altura interna privada;
Corte de imagen público() {
}
ImageCut público (int x, int y, int ancho, int alto) {
esto.x = x;
esto.y = y;
this.width = ancho;
this.height = altura;
}
public static void main (String [] args) lanza una excepción {
ImageCut imageCut = nuevo ImageCut(134, 0, 366, 366);
imageCut.cut(imageCut.getSrcpath(), imageCut.getSubpath());
}
/**
* Devuelve un iterador que contiene todos los ImageReaders actualmente registrados que afirman poder decodificar el formato especificado.
* Parámetro: formatName: contiene el nombre del formato informal (como "jpeg" o "tiff"), etc.
*
* @param postFix
* Extensión de archivo
* @devolver
*/
Iterador público<ImageReader> getImageReadersByFormatName(String postFix) {
cambiar (postFix) {
caso IMAGE_FORM_OF_JPG:
devolver ImageIO.getImageReadersByFormatName(IMAGE_FORM_OF_JPG);
caso IMAGE_FORM_OF_PNG:
devolver ImageIO.getImageReadersByFormatName(IMAGE_FORM_OF_PNG);
por defecto:
devolver ImageIO.getImageReadersByFormatName(IMAGE_FORM_OF_JPG);
}
}
/**
* Recorta la imagen y guarda la nueva imagen recortada.
* @param srcpath ruta de la imagen fuente
* @param subpath Cortar ruta de almacenamiento de imágenes
* @throwsIOException
*/
corte vacío público (String srcpath, String subpath) lanza IOException {
FileInputStream es = nulo;
ImageInputStream iis = nulo;
intentar {
//Leer archivo de imagen
es = nuevo FileInputStream(srcpath);
//Obtiene el nombre del sufijo del archivo
Cadena postFix = getPostfix(srcpath);
System.out.println("El formato de la imagen es: " + postFix);
/*
* Devuelve un iterador que contiene todos los ImageReaders actualmente registrados que afirman poder decodificar el formato especificado.
* Parámetro: formatName: contiene el nombre del formato informal (como "jpeg" o "tiff"), etc.
*/
Iterador<ImageReader> it = getImageReadersByFormatName(postFix);
Lector ImageReader = it.next();
// Obtener secuencia de imágenes
iis = ImageIO.createImageInputStream(es);
/*
* <p>iis:Leer fuente.true:Buscar solo hacia adelante</p> Márquelo como 'Buscar solo hacia adelante'.
* Esta configuración significa que las imágenes contenidas en la fuente de entrada solo se leerán secuencialmente, lo que posiblemente permitirá al lector evitar el almacenamiento en caché de aquellas partes de la entrada que contienen datos asociados con imágenes que se han leído previamente.
*/
lector.setInput(iis, verdadero);
/*
* <p>Clase que describe cómo decodificar la secuencia<p> Se utiliza para especificar cómo decodificar la secuencia desde Java Image I/O en la entrada.
* Stream transforma una imagen o conjunto de imágenes en el contexto de un cuadro. Los complementos para formatos de imagen específicos se implementarán desde su ImageReader.
* El método getDefaultReadParam devuelve una instancia de ImageReadParam.
*/
ImageReadParam parámetro = lector.getDefaultReadParam();
/*
* Área de recorte de imágenes. Rectángulo especifica un área en el espacio de coordenadas, a través del objeto Rectángulo
* Las coordenadas (x, y), ancho y alto del vértice superior izquierdo pueden definir esta área.
*/
Rectángulo rect = nuevo Rectángulo (x, y, ancho, alto);
// Proporcionar una imagen en búfer para usarla como destino para decodificar datos de píxeles.
param.setSourceRegion(rect);
/*
* Utilice el ImageReadParam proporcionado para leer el objeto especificado por el índice imageIndex y trátelo como un objeto completo.
* Devuelve imagen almacenada en búfer.
*/
BufferedImage bi = lector.read(0, param);
//Guardar nueva imagen
ImageIO.write(bi, postFix, nuevo archivo (subruta + "_" + nueva fecha().getTime() + "." + postFix));
} finalmente {
si (es != nulo)
es.close();
si (iis! = nulo)
iis.close();
}
}
/**
* Obtenga el nombre del sufijo de inputFilePath, por ejemplo: el nombre del sufijo de "e:/test.pptx" es: "pptx"<br>
*
* @param inputFilePath
* @devolver
*/
cadena pública getPostfix (cadena inputFilePath) {
devolver inputFilePath.substring(inputFilePath.lastIndexOf(".") + 1);
}
público int getHeight() {
altura de retorno;
}
setHeight vacío público (altura int) {
this.height = altura;
}
cadena pública getSrcpath() {
devolver ruta_src;
}
setSrcpath público vacío (String srcpath) {
this.srcpath = srcpath;
}
cadena pública getSubpath() {
subruta de retorno;
}
setSubpath público vacío (subruta de cadena) {
this.subpath = subruta;
}
público int getWidth() {
ancho de retorno;
}
setWidth vacío público (int ancho) {
this.width = ancho;
}
público int getX() {
devolver x;
}
conjunto vacío públicoX (int x) {
esto.x = x;
}
público int getY() {
devolver y;
}
conjunto vacío públicoY (int y) {
esto.y = y;
}
}
