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 -- 2019, 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 3 of the GNU Lesser General Public License
   7  * or later as published by the Free Software Foundation.
   8  */
   9
  10 package eu.svjatoslav.meviz.htmlindexer.metadata.fileTypes;
  11
  12 import eu.svjatoslav.commons.file.FilePathParser;
  13 import eu.svjatoslav.commons.file.IOHelper;
  14 import eu.svjatoslav.meviz.htmlindexer.Constants;
  15 import eu.svjatoslav.meviz.htmlindexer.GifSequenceWriter;
  16 import eu.svjatoslav.meviz.htmlindexer.ImageFormatError;
  17 import eu.svjatoslav.meviz.htmlindexer.Utils;
  18 import eu.svjatoslav.meviz.htmlindexer.metadata.Dimension;
  19
  20 import javax.imageio.ImageIO;
  21 import javax.imageio.ImageReader;
  22 import javax.imageio.stream.FileImageOutputStream;
  23 import javax.imageio.stream.ImageInputStream;
  24 import javax.imageio.stream.ImageOutputStream;
  25 import javax.swing.*;
  26 import java.awt.*;
  27 import java.awt.image.BufferedImage;
  28 import java.awt.image.FilteredImageSource;
  29 import java.awt.image.ImageFilter;
  30 import java.awt.image.ImageProducer;
  31 import java.io.*;
  32 import java.util.ArrayList;
  33 import java.util.List;
  34
  35 import static eu.svjatoslav.meviz.htmlindexer.Utils.getBufferedImage;
  36 import static java.awt.image.BufferedImage.TYPE_INT_RGB;
  37
  38 public class Picture extends AbstractFile {
  39
  40     private static final long serialVersionUID = -4156533490858298387L;
  41     /**
  42      * Picture dimensions.
  43      */
  44     private Dimension dimensions;
  45
  46     public Picture(final File parentDirectory, final String fileName)
  47             throws Exception {
  48         super(parentDirectory, fileName);
  49     }
  50
  51     private static void ensureNonzeroImageArea(final java.awt.Dimension result) {
  52         if (result.width < 1)
  53             result.width = 1;
  54         if (result.height < 1)
  55             result.height = 1;
  56     }
  57
  58     /**
  59      * Actual returned target thumbnail size will be adjusted from desired one
  60      * by attempting to generate as large as possible thumbnail, while not
  61      * exceeding provided thumbnail width and height, and preserving aspect
  62      * ratio of original image.
  63      */
  64     private static java.awt.Dimension getTargetThumbnailDimension(
  65             final java.awt.Dimension originalImageDimension,
  66             final java.awt.Dimension desiredTargetDimension) {
  67
  68         final double thumbWidthToHeightRatio = (double) desiredTargetDimension.width
  69                 / (double) desiredTargetDimension.height;
  70         final double inputImageWidthToHeightRatio = (double) originalImageDimension.width
  71                 / (double) originalImageDimension.height;
  72
  73         if (thumbWidthToHeightRatio < inputImageWidthToHeightRatio) {
  74
  75             final java.awt.Dimension result = new java.awt.Dimension(
  76                     desiredTargetDimension.width,
  77                     (int) (desiredTargetDimension.width / inputImageWidthToHeightRatio));
  78
  79             ensureNonzeroImageArea(result);
  80
  81             return result;
  82         } else {
  83
  84             final java.awt.Dimension result = new java.awt.Dimension(
  85                     (int) (desiredTargetDimension.height * inputImageWidthToHeightRatio),
  86                     desiredTargetDimension.height);
  87
  88             ensureNonzeroImageArea(result);
  89
  90             return result;
  91         }
  92     }
  93
  94     /**
  95      * Propose list of thumbnail dimensions.
  96      */
  97     public static List<Dimension> getThumbnailDimensions(Dimension current) {
  98         final ArrayList<Dimension> result = new ArrayList<>();
  99         result.add(current);
 100
 101         while (current.getArea() > 1000000) {
 102             current = current.getScaled(0.5d);
 103             result.add(current);
 104         }
 105
 106         return result;
 107
 108     }
 109
 110     public static void makeThumbnail(final File inputFile,
 111                                      final File outputFile,
 112                                      final java.awt.Dimension preferredTargetDimensions) {
 113
 114         String fileExtension = FilePathParser.getFileExtension(inputFile.getName());
 115
 116         try {
 117             if ("gif".equalsIgnoreCase(fileExtension))
 118                 makeGifThumbnail(inputFile, outputFile, preferredTargetDimensions);
 119             else
 120                 makeJpegThumbnail(inputFile, outputFile, preferredTargetDimensions);
 121         } catch (final Exception exception) {
 122             System.out.println(exception.toString());
 123             exception.printStackTrace();
 124         }
 125     }
 126
 127     private static void makeJpegThumbnail(File inputFile, File outputFile, java.awt.Dimension preferredTargetDimensions)
 128             throws IOException, ImageFormatError {
 129
 130         final BufferedImage inputImage = getBufferedImage(inputFile);
 131
 132         final java.awt.Dimension sourceImageDimension = new java.awt.Dimension(
 133                 inputImage.getWidth(), inputImage.getHeight());
 134
 135         final java.awt.Dimension targetDimensions = getTargetThumbnailDimension(
 136                 sourceImageDimension, preferredTargetDimensions);
 137
 138         final OutputStream out = new FileOutputStream(outputFile);
 139
 140         final Image scaledImage = scaleImage(inputImage,
 141                 targetDimensions.width, targetDimensions.height);
 142
 143         final BufferedImage bufferedImage = new BufferedImage(
 144                 scaledImage.getWidth(null), scaledImage.getHeight(null),
 145                 TYPE_INT_RGB);
 146
 147         final Graphics2D g = bufferedImage.createGraphics();
 148         g.drawImage(scaledImage, 0, 0, null);
 149         g.dispose();
 150
 151         ImageIO.write(bufferedImage, "jpg", out);
 152         out.close();
 153     }
 154
 155     private static void makeGifThumbnail(
 156             File inputFile, File outputFile, java.awt.Dimension preferredTargetDimensions) throws IOException {
 157         ImageIcon imageIcon = new ImageIcon(IOHelper.getFileContents(inputFile));
 158
 159         final java.awt.Dimension sourceImageDimension = new java.awt.Dimension(
 160                 imageIcon.getIconWidth(), imageIcon.getIconHeight());
 161
 162         System.out.println("Source image dimensions:" + sourceImageDimension);
 163
 164         final java.awt.Dimension targetDimensions = getTargetThumbnailDimension(
 165                 sourceImageDimension, preferredTargetDimensions);
 166
 167         System.out.println("Desired target image dimensions:" + targetDimensions);
 168
 169         FileInputStream fiStream = new FileInputStream(inputFile);
 170
 171         ImageReader reader = ImageIO.getImageReadersByFormatName("gif").next();
 172         ImageInputStream stream = ImageIO.createImageInputStream(inputFile);
 173         reader.setInput(stream);
 174
 175         Utils.ImageFrame[] frames = Utils.readGIF(reader);
 176         for (Utils.ImageFrame frame : frames) {
 177             Image scaleImage = scaleImage(frame.image, targetDimensions.width, targetDimensions.height);
 178             BufferedImage bimage = new BufferedImage(
 179                     targetDimensions.width, targetDimensions.height, BufferedImage.TYPE_INT_ARGB);
 180             Graphics2D bGr = bimage.createGraphics();
 181             bGr.drawImage(scaleImage, 0, 0, null);
 182             bGr.dispose();
 183             frame.image = bimage;
 184         }
 185
 186         ImageOutputStream output = new FileImageOutputStream(outputFile);
 187
 188         GifSequenceWriter writer =
 189                 new GifSequenceWriter(output, frames[0].image.getType(), frames[0].getDelay(), true);
 190
 191         writer.writeToSequence(frames[0].image);
 192         for (int i = 1; i < frames.length; i++) {
 193             BufferedImage nextImage = frames[i].image;
 194             writer.writeToSequence(nextImage);
 195         }
 196
 197         writer.close();
 198         output.close();
 199     }
 200
 201     /**
 202      * @return new image scaled to desired dimensions
 203      */
 204     private static Image scaleImage(final Image srcImage, final int width,
 205                                     final int height) {
 206
 207         final ImageFilter filter = new java.awt.image.AreaAveragingScaleFilter(
 208                 width, height);
 209
 210         final ImageProducer prod = new FilteredImageSource(
 211                 srcImage.getSource(), filter);
 212
 213         final Image newImage = Toolkit.getDefaultToolkit().createImage(prod);
 214
 215         return new ImageIcon(newImage).getImage();
 216     }
 217
 218     private String computeThumbnailHash(final Dimension targetDimension) {
 219
 220         // compute new thumbnails hash number
 221         final String forMagicHash = fileName + " "
 222                 + targetDimension.width + " "
 223                 + targetDimension.height + " "
 224                 + getFileLength() + " "
 225                 + Constants.THUMBNAIL_VERSION;
 226
 227         return Utils.getStringCrcAsHex(forMagicHash);
 228     }
 229
 230     public Dimension getDimensions() {
 231         return dimensions;
 232     }
 233
 234     /**
 235      * Get thumbnail file name for this image and desired thumbnail dimensions
 236      * relative to designated thumbnails directory within parent directory.
 237      */
 238     public String getRelativeThumbnailFileName(final Dimension targetDimension) {
 239         String thumbnailExtension = "gif".equalsIgnoreCase(getFileExtension()) ? "gif" : "jpeg";
 240
 241         return FilePathParser.getFileNameWithoutExtension(fileName) + " ("
 242                 + computeThumbnailHash(targetDimension) + ")." + thumbnailExtension;
 243     }
 244
 245     @Override
 246     public void updateFileMetadata(final File parentDirectory) throws Exception {
 247         final BufferedImage image = getBufferedImage(getFile(parentDirectory));
 248         dimensions = new Dimension(image.getWidth(), image.getHeight());
 249     }
 250
 251 }