src/main/java/eu/svjatoslav/meviz/htmlindexer/metadata/fileTypes/Picture.java

   1 /*
   2  * Meviz - Various tools collection to work with multimedia.
   3  * Copyright (C) 2012, Svjatoslav Agejenko, svjatoslav@svjatoslav.eu
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of version 2 of the GNU General Public License
   7  * as published by the Free Software Foundation.
   8  */
   9
  10 package eu.svjatoslav.meviz.htmlindexer.metadata.fileTypes;
  11
  12 import java.awt.Graphics2D;
  13 import java.awt.Image;
  14 import java.awt.Toolkit;
  15 import java.awt.image.BufferedImage;
  16 import java.awt.image.FilteredImageSource;
  17 import java.awt.image.ImageFilter;
  18 import java.awt.image.ImageProducer;
  19 import java.io.File;
  20 import java.io.FileOutputStream;
  21 import java.io.IOException;
  22 import java.io.OutputStream;
  23 import java.util.ArrayList;
  24 import java.util.List;
  25
  26 import javax.imageio.ImageIO;
  27 import javax.swing.ImageIcon;
  28
  29 import eu.svjatoslav.commons.file.FilePathParser;
  30 import eu.svjatoslav.meviz.htmlindexer.Constants;
  31 import eu.svjatoslav.meviz.htmlindexer.ImageFormatError;
  32 import eu.svjatoslav.meviz.htmlindexer.Utils;
  33 import eu.svjatoslav.meviz.htmlindexer.metadata.Dimension;
  34
  35 public class Picture extends AbstractFile {
  36
  37         /**
  38          * Actual returned target thumbnail size will be adjusted from desired one
  39          * by attempting to generate as large as possible thumbnail, while not
  40          * exceeding provided thumbnail width and height, and preserving aspect
  41          * ratio of original image.
  42          */
  43         public static java.awt.Dimension getTargetThumbnailDimension(
  44                         final java.awt.Dimension originalImageDimension,
  45                         final java.awt.Dimension desiredTargetDimension) {
  46
  47                 final double thumbWidthToHeightRatio = (double) desiredTargetDimension.width
  48                                 / (double) desiredTargetDimension.height;
  49                 final double inputImageWidthToHeightRatio = (double) originalImageDimension.width
  50                                 / (double) originalImageDimension.height;
  51
  52                 if (thumbWidthToHeightRatio < inputImageWidthToHeightRatio) {
  53
  54                         final java.awt.Dimension result = new java.awt.Dimension(
  55                                         desiredTargetDimension.width,
  56                                         (int) (desiredTargetDimension.width / inputImageWidthToHeightRatio));
  57
  58                         return result;
  59                 } else {
  60
  61                         final java.awt.Dimension result = new java.awt.Dimension(
  62                                         (int) (desiredTargetDimension.height * inputImageWidthToHeightRatio),
  63                                         desiredTargetDimension.height);
  64
  65                         return result;
  66                 }
  67         }
  68
  69         /**
  70          * Propose list of thumbnail dimensions.
  71          */
  72         public static List<Dimension> getThumbnailDimensions(Dimension current) {
  73                 final ArrayList<Dimension> result = new ArrayList<Dimension>();
  74                 result.add(current);
  75
  76                 while (current.getArea() > 1000000) {
  77                         current = current.getScaled(0.5d);
  78                         result.add(current);
  79                 }
  80
  81                 return result;
  82
  83         }
  84
  85         public static void makeThumbnail(final File inputFile,
  86                         final File outputFile,
  87                         final java.awt.Dimension preferredTargetDimensions) {
  88
  89                 try {
  90
  91                         final BufferedImage inputImage = Utils.getBufferedImage(inputFile);
  92
  93                         final java.awt.Dimension sourceImageDimension = new java.awt.Dimension(
  94                                         inputImage.getWidth(), inputImage.getHeight());
  95
  96                         final java.awt.Dimension targetDimensions = getTargetThumbnailDimension(
  97                                         sourceImageDimension, preferredTargetDimensions);
  98
  99                         final OutputStream out = new FileOutputStream(outputFile);
 100
 101                         final Image scaledImage = scaleImage(inputImage,
 102                                         targetDimensions.width, targetDimensions.height);
 103
 104                         final BufferedImage bufferedImage = new BufferedImage(
 105                                         scaledImage.getWidth(null), scaledImage.getHeight(null),
 106                                         BufferedImage.TYPE_INT_RGB);
 107
 108                         final Graphics2D g = bufferedImage.createGraphics();
 109                         g.drawImage(scaledImage, 0, 0, null);
 110                         g.dispose();
 111
 112                         ImageIO.write(bufferedImage, "jpg", out);
 113                         out.close();
 114
 115                 } catch (final Exception exception) {
 116                         System.out.println(exception.toString());
 117                         exception.printStackTrace();
 118                 }
 119         }
 120
 121         /**
 122          * @return new image scaled to desired dimensions
 123          */
 124         public static Image scaleImage(final Image srcImage, final int width,
 125                         final int height) {
 126
 127                 ImageFilter filter;
 128                 filter = new java.awt.image.AreaAveragingScaleFilter(width, height);
 129
 130                 final ImageProducer prod = new FilteredImageSource(
 131                                 srcImage.getSource(), filter);
 132
 133                 final Image newImage = Toolkit.getDefaultToolkit().createImage(prod);
 134
 135                 final ImageIcon imageIcon = new ImageIcon(newImage);
 136                 return imageIcon.getImage();
 137         }
 138
 139         private static final long serialVersionUID = -4156533490858298387L;;
 140
 141         /**
 142          * Picture dimensions.
 143          */
 144         private Dimension dimensions;
 145
 146         public Picture(final File parentDirectory, final String fileName)
 147                         throws IOException, ImageFormatError {
 148                 super(parentDirectory, fileName);
 149         }
 150
 151         private String computeThumbnailHash(final Dimension targetDimension) {
 152
 153                 // compute new thumbnails hash number
 154                 final String forMagicHash = fileName + " "
 155                                 + String.valueOf(targetDimension.width) + " "
 156                                 + String.valueOf(targetDimension.height) + " "
 157                                 + String.valueOf(getFileLength()) + " "
 158                                 + Constants.THUMBNAIL_VERSION;
 159
 160                 // System.out.println("Computing hash from: " + forMagicHash);
 161                 return Utils.getStringCrcAsHex(forMagicHash);
 162         }
 163
 164         public Dimension getDimensions() {
 165                 return dimensions;
 166         }
 167
 168         /**
 169          * Get thumbnail file name for this image and desired thumbnail dimensions
 170          * relative to designated thumbnails directory within parent directory.
 171          */
 172         public String getRelativeThumbnailFileName(final Dimension targetDimension) {
 173                 return FilePathParser.getFileNameWithoutExtension(fileName) + " ("
 174                                 + computeThumbnailHash(targetDimension) + ").jpeg";
 175         }
 176
 177         @Override
 178         public void updateFileMetainfo(final File parentDirectory)
 179                         throws IOException {
 180                 BufferedImage image;
 181                 try {
 182                         image = Utils.getBufferedImage(getFile(parentDirectory));
 183                 } catch (final ImageFormatError e) {
 184                         throw new RuntimeException(e);
 185                 }
 186                 dimensions = new Dimension(image.getWidth(), image.getHeight());
 187         }
 188
 189 }