/**
*
*/
paquet com.b510 ;
importer java.awt.Rectangle ;
importer java.awt.image.BufferedImage ;
importer java.io.File ;
importer java.io.FileInputStream ;
importer java.io.IOException ;
importer java.util.Date ;
importer java.util.Iterator ;
importer javax.imageio.ImageIO ;
importer javax.imageio.ImageReadParam ;
importer javax.imageio.ImageReader ;
importer javax.imageio.stream.ImageInputStream ;
/**
* @date 2012-11-26
* @auteur xhw
*
*/
classe publique ImageCut {
/**
* Nom du chemin de l'image source tel que : c:/1.jpg
*/
private String srcpath = "e:/poool.jpg";
/**
* Nom du chemin de stockage de l'image coupée Par exemple : c:/2.jpg.
*/
sous-chemin de chaîne privé = "e:/pool_end" ;
/**
*format d'image jpg
*/
chaîne finale statique privée IMAGE_FORM_OF_JPG = "jpg";
/**
*format d'image png
*/
chaîne finale statique privée IMAGE_FORM_OF_PNG = "png";
/**
* Coordonnée x du point de cisaillement
*/
int privé x ;
/**
* Coordonnée Y du point de coupe
*/
entité privée;
/**
* Largeur du point de coupe
*/
largeur int privée ;
/**
* Hauteur du point de coupe
*/
hauteur int privée ;
public ImageCut() {
}
public ImageCut (int x, int y, int largeur, int hauteur) {
ceci.x = x;
ceci.y = y;
this.width = largeur ;
this.hauteur = hauteur;
}
public static void main (String[] args) lève une exception {
ImageCut imageCut = new ImageCut(134, 0, 366, 366);
imageCut.cut(imageCut.getSrcpath(), imageCut.getSubpath());
}
/**
* Renvoie un itérateur contenant tous les ImageReaders actuellement enregistrés qui prétendent pouvoir décoder le format spécifié.
* Paramètre : formatName - Contient le nom du format informel (tel que "jpeg" ou "tiff"), etc.
*
* @param postFix
*Extension de fichier
* @retour
*/
public Iterator<ImageReader> getImageReadersByFormatName(String postFix) {
commutateur (postFix) {
cas IMAGE_FORM_OF_JPG :
return ImageIO.getImageReadersByFormatName(IMAGE_FORM_OF_JPG);
cas IMAGE_FORM_OF_PNG :
return ImageIO.getImageReadersByFormatName(IMAGE_FORM_OF_PNG);
défaut:
return ImageIO.getImageReadersByFormatName(IMAGE_FORM_OF_JPG);
}
}
/**
* Recadrez l'image et enregistrez la nouvelle image recadrée.
* @param srcpath chemin de l'image source
* @param subpath Couper le chemin de stockage de l'image
* @throwsIOException
*/
public void cut (String srcpath, String subpath) lance IOException {
FileInputStream est = null ;
ImageInputStream iis = null ;
essayer {
//Lire le fichier image
est = nouveau FileInputStream(srcpath);
// Récupère le nom suffixe du fichier
Chaîne postFix = getPostfix(srcpath);
System.out.println("Le format de l'image est : " + postFix);
/*
* Renvoie un itérateur contenant tous les ImageReaders actuellement enregistrés qui prétendent pouvoir décoder le format spécifié.
* Paramètre : formatName - Contient le nom du format informel (tel que "jpeg" ou "tiff"), etc.
*/
Itérateur<ImageReader> it = getImageReadersByFormatName(postFix);
Lecteur ImageReader = it.next();
// Récupère le flux d'images
iis = ImageIO.createImageInputStream(est);
/*
* <p>iis : Lire source.true : Recherche avant uniquement</p> Marquez-le comme "Recherche avant uniquement".
* Ce paramètre signifie que les images contenues dans la source d'entrée ne seront lues que de manière séquentielle, permettant éventuellement au lecteur d'éviter de mettre en cache les parties de l'entrée qui contiennent des données associées aux images qui ont été lues précédemment.
*/
lecteur.setInput(iis, true);
/*
* <p>Classe qui décrit comment décoder le flux<p> Utilisé pour spécifier comment décoder le flux à partir des E/S d'image Java en entrée.
* Stream transforme une image ou un ensemble d'images dans le contexte d'un cadre. Des plugins pour des formats d'image spécifiques seront implémentés à partir de leur ImageReader
* La méthode getDefaultReadParam renvoie une instance de ImageReadParam.
*/
ImageReadParam param = reader.getDefaultReadParam();
/*
* Zone de recadrage de l'image. Rectangle spécifie une zone dans l'espace de coordonnées, via l'objet Rectangle
* Les coordonnées (x, y), la largeur et la hauteur du sommet supérieur gauche peuvent définir cette zone.
*/
Rectangle rect = nouveau Rectangle(x, y, largeur, hauteur);
// Fournit une BufferedImage à utiliser comme cible pour décoder les données de pixels.
param.setSourceRegion(rect);
/*
* Utilisez le ImageReadParam fourni pour lire l'objet spécifié par l'index imageIndex et le traiter comme un objet complet
* BufferedImage revient.
*/
BufferedImage bi = reader.read(0, param);
//Enregistrer la nouvelle image
ImageIO.write(bi, postFix, new File(sous-chemin + "_" + new Date().getTime() + "." + postFix));
} enfin {
si (est != nul)
est.close();
si (iis != null)
iis.close();
}
}
/**
* Obtenez le nom du suffixe de inputFilePath, par exemple : le nom du suffixe de "e:/test.pptx" est : "pptx"<br>
*
* @param inputFilePath
* @retour
*/
public String getPostfix (String inputFilePath) {
return inputFilePath.substring(inputFilePath.lastIndexOf(".") + 1);
}
public int getHauteur() {
hauteur de retour ;
}
public void setHeight (int hauteur) {
this.hauteur = hauteur;
}
chaîne publique getSrcpath() {
retourner le chemin src ;
}
public void setSrcpath(String srcpath) {
this.srcpath = srcpath;
}
chaîne publique getSubpath() {
retourner le sous-chemin ;
}
public void setSubpath (sous-chemin de chaîne) {
this.subpath = sous-chemin ;
}
public int getLargeur() {
largeur de retour ;
}
public void setWidth (int largeur) {
this.width = largeur ;
}
public int getX() {
renvoyer x ;
}
public void setX (int x) {
ceci.x = x;
}
public int getY() {
retourner y ;
}
public void setY(int y) {
ceci.y = y;
}
}
