..

ulrich

2018-01-15 51ca668d316d8b4d284a255ac9b28c112f9f2690

 src/bilder.groovy

@@ -14,163 +14,88 @@
import java.net.FileNameMap;
import java.net.URLConnection;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriter;
import javax.imageio.ImageWriteParam;
import javax.imageio.stream.FileImageOutputStream;
import javax.imageio.IIOImage;
import java.lang.Integer;

/*
   Skript zum Verkleinern von Bildern mit Hilfe 
   der Klasse Bild
   Java-Code zum Verkleinern von Bildern

   args[0] - Anzahl Pixel an der laengsten Kante
   args[1] - qualitaet JPEG, z.B. 0.75 fuer 75% des Originals
   args[2] - Eingangsordner
   args[3] - Ausgabeordner
*/

File inFile = new File(args[1]);
FileNameMap fileNameMap = URLConnection.getFileNameMap();
int width = Integer.parseInt(args[0]);
int height = width;
String inDirName = args[2];
String outDirName = args[3];
File inFile = new File(inDirName);
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 outDir = new File(outDirName);
      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");
}

        float quality = Float.parseFloat(args[1]);
        float factor = (float) 0.0;


/*
   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);
        BufferedImage thumbImage;
        int imageWidth = image.getWidth(null);
        int imageHeight = image.getHeight(null);
 
      int thumbWidth = width;
        int thumbWidth = width;
        int thumbHeight = height;
    if(imageWidth < width) {
      thumbWidth = imageWidth;    
    }
    if(imageHeight < height) {
      thumbHeight = imageHeight;
    }
        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);
          thumbHeight = (int)(thumbWidth / imageRatio);
        }
        else {
            thumbWidth = (int)(thumbHeight * imageRatio);
          thumbWidth = (int)(thumbHeight * imageRatio);
        }
 

        String mimeType = fileNameMap.getContentTypeFor("file://" + fileList[i].getAbsolutePath());

        // 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);
    }
        if(mimeType.contains("jpeg") || mimeType.contains("png")) {
          thumbImage = new BufferedImage(thumbWidth, thumbHeight, BufferedImage.TYPE_INT_RGB);
        } else {
          thumbImage = new BufferedImage(thumbWidth, thumbHeight, BufferedImage.TYPE_INT_ARGB);
        }
        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;
    }*/
    
        /*
          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];
@@ -188,47 +113,37 @@
            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";

        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";
        }

            /*
               14.1.2018: Ausgabe um Qualitaetsparameter erweitert
               Beginn
            */
        ImageWriter writer = ImageIO.getImageWritersByFormatName(imgType).next();
        ImageWriteParam iwp = writer.getDefaultWriteParam();
        iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
        iwp.setCompressionQuality(quality);
        writer.setOutput(new FileImageOutputStream(outFile));
        writer.write(null, new IIOImage(thumbImage, null, null), iwp);
        writer.dispose();
            /* 14.1.2018 Ende */
      }
    } catch (InterruptedException ex) {
      System.out.println("Error: " + ex.getLocalizedMessage());
    }
    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);    
  }
   }
} else {
   System.out.println("fileList is null or empty");
}