Thumbs.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2011 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package org.turro.elephant.impl.util;
 
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.io.File;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import org.turro.elephant.context.ElephantContext;
 
public class Thumbs {
  HttpServletRequest request; 
  ServletContext context;
    
  public Thumbs(HttpServletRequest request) {
    this.request = request;
    this.context = request.getSession().getServletContext();
  }
 
  // rotate = R:right L:left N:none
  public String getThumb(String file, int maxDim, String rotate) {
    String contextPath = request.getContextPath(),
           fileNoContext = file;
    
    if(contextPath.length() > 1 && file.startsWith(contextPath)) {
      fileNoContext = file.substring(contextPath.length());
    }
    String filePath = fileNoContext,
           thumbPath = insertThumb(fileNoContext);
    
    if(filePath.indexOf("_thumb") > -1) return file;
 
    createThumb(rotate, filePath, thumbPath, maxDim);
 
    return insertThumb(file);
  }
 
  public void createThumb(String rotate, String file, String thumb, int maxDim) {
    
    String filePath = context.getRealPath(file),
           thumbPath = context.getRealPath(thumb);
    
    try {
 
      File fi = new File(filePath);
 
      // maximum dimension
      if(maxDim <= 0) maxDim = 200;
 
      if(needsRecreateThumb(thumbPath, maxDim)) {
 
        BufferedImage inImage = ImageIO.read(fi);
        
        // Determine the scale.
        double scale = (double)maxDim/(double)inImage.getWidth(null);
//        if (inImage.getHeight(null) > inImage.getWidth(null)) {
//          scale = (double)maxDim/(double)inImage.getHeight(null);
//        }
 
        if(inImage.getWidth() <= maxDim/* && inImage.getHeight() <= maxDim*/) {
          scale = 1;
        }
        
        // Determine size of new image. 
        //One of them should equal maxDim.
        int scaledW = (int)(scale*inImage.getWidth(null));
        int scaledH = (int)(scale*inImage.getHeight(null));
 
        // Create an image buffer in 
        //which to paint on.
        BufferedImage outImage;
        if(":L".equals(rotate) || ":R".equals(rotate)) 
          outImage = new BufferedImage(
              scaledH, scaledW, BufferedImage.TYPE_INT_RGB);
        else
          outImage = new BufferedImage(
              scaledW, scaledH, BufferedImage.TYPE_INT_RGB);
 
        // Set the scale.
        AffineTransform tx = new AffineTransform();
 
        // If the image is smaller than 
        //the desired image size,
        // don't bother scaling.
        if (scale < 1.0d) {
          tx.scale(scale, scale);
        }
 
        if(":L".equals(rotate)) {
          // 90 to left
          tx.translate(inImage.getHeight(), 0);
          tx.rotate(Math.PI/2);
        }
        else if(":R".equals(rotate)) {
          // 90 to right
          tx.translate(0, inImage.getWidth());
          tx.rotate(-(Math.PI/2));
        }
 
        // Paint image.
        Graphics2D g2d = outImage.createGraphics();
        g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
        g2d.drawImage(inImage, tx, null);
        g2d.dispose();
 
        File fo = new File(thumbPath);
        ImageIO.write(outImage, "jpg", fo); 
    
        
      }
 
    } catch(Exception ex) {
      Logger.getLogger(Thumbs.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
  }
 
  private String insertThumb(String file) {
    int p = file.lastIndexOf('.');
    if(p > -1)
      return file.substring(0, p) + "_thumb.jpg";
    else
      return file + "_thumb";
  }
  
  private boolean needsRecreateThumb(String thumbPath, int maxDim) throws java.io.IOException {
    File thumb = new File(thumbPath);
    if(thumb.exists()) {
      BufferedImage thumbImage = ImageIO.read(thumb);
      boolean isSmaller = 
              thumbImage.getWidth() <= maxDim && 
              thumbImage.getHeight() <= maxDim;
      boolean hasCoincidence = false;
//              thumbImage.getWidth() == maxDim || 
//              thumbImage.getHeight() == maxDim;
      return !isSmaller && !hasCoincidence;              
    }
    else
      return true;
  }
}