import java.awt.Graphics2D;
|
import java.awt.Image;
|
import java.awt.RenderingHints;
|
import java.awt.image.BufferedImage;
|
import java.awt.image.ConvolveOp;
|
import java.awt.image.Kernel;
|
import java.awt.MediaTracker;
|
import java.awt.Container;
|
import java.awt.Toolkit;
|
import java.io.File;
|
import java.io.FileNotFoundException;
|
import java.io.IOException;
|
import java.io.OutputStream;
|
import java.net.FileNameMap;
|
import java.net.URLConnection;
|
import javax.imageio.ImageIO;
|
import java.lang.Integer;
|
|
/*
|
Skript zum Verkleinern von Bildern mit Hilfe
|
der Klasse Bild
|
*/
|
|
File inFile = new File(args[1]);
|
File[] fileList = inFile.listFiles();
|
if(fileList != null && fileList.length > 0) {
|
for(int i = 0; i < fileList.length; i++) {
|
System.out.println(fileList[i].getAbsolutePath());
|
|
File outDir = new File(args[2]);
|
File outFile = new File(outDir, fileList[i].getName());
|
System.out.println(outFile.getAbsolutePath());
|
//java.awt.Image image = (java.awt.Image) Toolkit.getDefaultToolkit().getImage(fileList[i].getAbsolutePath());
|
Image image = ImageIO.read(fileList[i]);
|
MediaTracker mediaTracker = new MediaTracker(new Container());
|
mediaTracker.addImage(image, 0);
|
try {
|
mediaTracker.waitForID(0);
|
if (!mediaTracker.isErrorAny()) {
|
Bild bild = new Bild();
|
bild.writeImageFile(image, Integer.parseInt(args[0]), bild.getMimeType(fileList[i]), new File(outDir, fileList[i].getName()).getAbsolutePath());
|
}
|
} catch (InterruptedException ex) {
|
System.out.println("Error: " + ex.getLocalizedMessage());
|
}
|
|
}
|
} else {
|
System.out.println("fileList is null or empty");
|
}
|
|
|
|
/*
|
Klasse Bild
|
*/
|
|
public class Bild {
|
|
public static final int WINZIG = 0;
|
public static final int KLEIN = 1;
|
public static final int SEMI = 2;
|
public static final int MITTEL = 3;
|
public static final int GROSS = 4;
|
|
public String[] GRNAME; // = {"-w", "-k", "-s", "-m", "-g"};
|
public int[] GR; // = {120, 240, 500, 700, 1200};
|
|
public Bild() {
|
GRNAME = new String[5]
|
GRNAME[0] = "-w";
|
GRNAME[1] = "-k";
|
GRNAME[2] = "-s";
|
GRNAME[3] = "-m";
|
GRNAME[4] = "-g";
|
|
GR = new int[5];
|
GR[0] = 120;
|
GR[1] = 240;
|
GR[2] = 500;
|
GR[3] = 700;
|
GR[4] = 1200;
|
|
}
|
|
public void writeImageStream(Image image, int gr, String mimeType, OutputStream out) throws InterruptedException, IOException {
|
ImageIO.write(getReducedImage(image, gr, mimeType), imgType(mimeType), out);
|
}
|
|
/**
|
*
|
* @param image
|
* @param gr
|
* @param mimeType
|
* @param vName Name der verkleinerten Datei
|
* @throws InterruptedException
|
* @throws IOException
|
*/
|
public void writeImageFile(BufferedImage image, int gr, String mimeType, String vName) throws InterruptedException, IOException {
|
ImageIO.write(getReducedImage(image, gr, mimeType), imgType(mimeType), new File(vName));
|
}
|
|
private BufferedImage getReducedImage(Image image, int gr, String mimeType) throws InterruptedException, IOException {
|
BufferedImage img;
|
int q = 90;
|
float sh = (float) 0.0;
|
if(mimeType.contains("jpeg")) {
|
img = getReducedImageImpl(image, gr, gr, q, sh, false);
|
} else {
|
img = getReducedImageImpl(image, gr, gr, q, sh, true);
|
}
|
return img;
|
}
|
|
/**
|
* Eine in Groesse und Qualitaet verringerte Bilddatei erzeugen
|
* @param image Ablageort und Name der Bilddatei
|
* @param width neue Breite
|
* @param height neue hoehe
|
* @param quality neue Qualitaet (0 - 100)
|
* @param factor Faktor fuer Schaerfe / Unschaerfe (z.B. -0.15f fuer leichte Unschaerfe, 0.05f fuer leichtes Nachschaerfen)
|
* @param withTransparency ob Transparenz benoetigt wird
|
* @return neues, in Groesse und Qualitaet entsprechend verringertes Bild
|
* @throws java.lang.InterruptedException
|
* @throws java.io.FileNotFoundException
|
*/
|
public BufferedImage getReducedImageImpl(BufferedImage image, int width, int height, int quality, float factor, boolean withTransparency)
|
throws InterruptedException, FileNotFoundException, IOException {
|
|
int imageWidth = image.getWidth(null);
|
int imageHeight = image.getHeight(null);
|
|
int thumbWidth = width;
|
int thumbHeight = height;
|
if(imageWidth < width) {
|
thumbWidth = imageWidth;
|
}
|
if(imageHeight < height) {
|
thumbHeight = imageHeight;
|
}
|
double thumbRatio = (double)thumbWidth / (double)thumbHeight;
|
double imageRatio = (double)imageWidth / (double)imageHeight;
|
if (thumbRatio < imageRatio) {
|
thumbHeight = (int)(thumbWidth / imageRatio);
|
}
|
else {
|
thumbWidth = (int)(thumbHeight * imageRatio);
|
}
|
|
// draw original image to thumbnail image object and
|
// scale it to the new size on-the-fly
|
//BufferedImage thumbImage = new BufferedImage(thumbWidth, thumbHeight, BufferedImage.TYPE_INT_RGB);
|
BufferedImage thumbImage;
|
if(withTransparency) {
|
thumbImage = new BufferedImage(thumbWidth, thumbHeight, BufferedImage.TYPE_INT_ARGB);
|
} else {
|
thumbImage = new BufferedImage(thumbWidth, thumbHeight, BufferedImage.TYPE_INT_RGB);
|
}
|
Graphics2D graphics2D = thumbImage.createGraphics();
|
graphics2D.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
|
graphics2D.drawImage(image, 0, 0, thumbWidth, thumbHeight, null);
|
|
// 30.7.2007: sharpening hinzugefuegt (Anfang)
|
//float factor = -0.15f; // minus = sharpen, plus = soften
|
//float[] sharpenArray = {0, -1, 0, -1, 5, -1, 0, -1, 0};
|
|
/*
|
30.6.2013: sharpening als Weichmacher nur, wenn Bild < 400
|
*/
|
/*if(thumbWidth < 400 || thumbHeight < 400) {
|
factor = 0.1f;
|
}*/
|
|
if(factor != (float) 0.0) {
|
//float[] array = {0, factor, 0, factor, 1-(factor*4), factor, 0, factor, 0};
|
float[] array = new float[9];
|
array[0] = 0;
|
array[1] = factor;
|
array[2] = 0;
|
array[3] = factor;
|
array[4] = 1-(factor*4);
|
array[5] = factor;
|
array[6] = 0;
|
array[7] = factor;
|
array[8] = 0;
|
Kernel kernel = new Kernel(3, 3, array);
|
ConvolveOp cOp = new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null);
|
thumbImage = cOp.filter(thumbImage, null);
|
}
|
// 30.7.2007: sharpening hinzugefuegt (Ende)
|
|
return thumbImage;
|
}
|
|
public String imgType(String mimeType) {
|
String imgType;
|
if(mimeType.contains("jpg")) {
|
imgType = "jpg";
|
} else if(mimeType.contains("jpeg")) {
|
imgType = "jpg";
|
} else if(mimeType.contains("png")) {
|
imgType = "png";
|
} else if(mimeType.contains("gif")) {
|
imgType = "gif";
|
} else {
|
imgType = "jpg";
|
}
|
return imgType;
|
}
|
|
/**
|
*
|
* @param v Bild.WINZIG .. Bild.GROSS
|
* @return Länge der längsten Kante in Bildpunkten
|
*/
|
public int getVariantenGroesse(int v) {
|
return GR[v];
|
}
|
|
public String getVariantenName(int v) {
|
return GRNAME[v];
|
}
|
|
public String getMimeType(File file) {
|
String absName = file.getAbsolutePath();
|
FileNameMap fileNameMap = URLConnection.getFileNameMap();
|
return fileNameMap.getContentTypeFor("file://" + absName);
|
}
|
}
|
