src/java/org/apache/poi/hssf/usermodel/HSSFPicture.java

   1 /*
   2 * Licensed to the Apache Software Foundation (ASF) under one or more
   3 * contributor license agreements.  See the NOTICE file distributed with
   4 * this work for additional information regarding copyright ownership.
   5 * The ASF licenses this file to You under the Apache License, Version 2.0
   6 * (the "License"); you may not use this file except in compliance with
   7 * the License.  You may obtain a copy of the License at
   8 *
   9 *     http://www.apache.org/licenses/LICENSE-2.0
  10 *
  11 * Unless required by applicable law or agreed to in writing, software
  12 * distributed under the License is distributed on an "AS IS" BASIS,
  13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 * See the License for the specific language governing permissions and
  15 * limitations under the License.
  16 */
  17 package org.apache.poi.hssf.usermodel;
  18
  19 import org.apache.poi.ddf.EscherBSERecord;
  20 import org.apache.poi.util.POILogFactory;
  21 import org.apache.poi.util.POILogger;
  22 import org.w3c.dom.Element;
  23 import org.w3c.dom.NodeList;
  24
  25 import javax.imageio.ImageIO;
  26 import javax.imageio.ImageReader;
  27 import javax.imageio.stream.ImageInputStream;
  28 import java.awt.image.BufferedImage;
  29 import java.awt.*;
  30 import java.io.ByteArrayInputStream;
  31 import java.io.IOException;
  32 import java.util.Iterator;
  33
  34 /**
  35  * Represents a escher picture.  Eg. A GIF, JPEG etc...
  36  *
  37  * @author Glen Stampoultzis
  38  * @author Yegor Kozlov (yegor at apache.org)
  39  */
  40 public class HSSFPicture
  41         extends HSSFSimpleShape
  42 {
  43     public static final int PICTURE_TYPE_EMF = HSSFWorkbook.PICTURE_TYPE_EMF;                // Windows Enhanced Metafile
  44     public static final int PICTURE_TYPE_WMF = HSSFWorkbook.PICTURE_TYPE_WMF;                // Windows Metafile
  45     public static final int PICTURE_TYPE_PICT = HSSFWorkbook.PICTURE_TYPE_PICT;              // Macintosh PICT
  46     public static final int PICTURE_TYPE_JPEG = HSSFWorkbook.PICTURE_TYPE_JPEG;              // JFIF
  47     public static final int PICTURE_TYPE_PNG = HSSFWorkbook.PICTURE_TYPE_PNG;                // PNG
  48     public static final int PICTURE_TYPE_DIB = HSSFWorkbook.PICTURE_TYPE_DIB;                // Windows DIB
  49
  50     /**
  51      * width of 1px in columns with default width in units of 1/256 of a character width
  52      */
  53     private static final float PX_DEFAULT = 32.00f;
  54     /**
  55      * width of 1px in columns with overridden width in units of 1/256 of a character width
  56      */
  57     private static final float PX_MODIFIED = 36.56f;
  58
  59     /**
  60      * Height of 1px of a row
  61      */
  62     private static final int PX_ROW = 15;
  63
  64     int pictureIndex;
  65     HSSFPatriarch patriarch;
  66
  67     private static final POILogger log = POILogFactory.getLogger(HSSFPicture.class);
  68
  69     /**
  70      * Constructs a picture object.
  71      */
  72     HSSFPicture( HSSFShape parent, HSSFAnchor anchor )
  73     {
  74         super( parent, anchor );
  75         setShapeType(OBJECT_TYPE_PICTURE);
  76     }
  77
  78     public int getPictureIndex()
  79     {
  80         return pictureIndex;
  81     }
  82
  83     public void setPictureIndex( int pictureIndex )
  84     {
  85         this.pictureIndex = pictureIndex;
  86     }
  87
  88     /**
  89      * Reset the image to the original size.
  90      *
  91      * @since POI 3.0.2
  92      */
  93     public void resize(){
  94         HSSFClientAnchor anchor = (HSSFClientAnchor)getAnchor();
  95         anchor.setAnchorType(2);
  96
  97         HSSFClientAnchor pref = getPreferredSize();
  98
  99         int row2 = anchor.getRow1() + (pref.getRow2() - pref.getRow1());
 100         int col2 = anchor.getCol1() + (pref.getCol2() - pref.getCol1());
 101
 102         anchor.setCol2((short)col2);
 103         anchor.setDx1(0);
 104         anchor.setDx2(pref.getDx2());
 105
 106         anchor.setRow2(row2);
 107         anchor.setDy1(0);
 108         anchor.setDy2(pref.getDy2());
 109     }
 110
 111     /**
 112      * Calculate the preferred size for this picture.
 113      *
 114      * @return HSSFClientAnchor with the preferred size for this image
 115      * @since POI 3.0.2
 116      */
 117     public HSSFClientAnchor getPreferredSize(){
 118         HSSFClientAnchor anchor = (HSSFClientAnchor)getAnchor();
 119
 120         Dimension size = getImageDimension();
 121
 122         float w = 0;
 123
 124         //space in the leftmost cell
 125         w += getColumnWidthInPixels(anchor.col1)*(1 - anchor.dx1/1024);
 126         short col2 = (short)(anchor.col1 + 1);
 127         int dx2 = 0;
 128
 129         while(w < size.width){
 130             w += getColumnWidthInPixels(col2++);
 131         }
 132
 133         if(w > size.width) {
 134             //calculate dx2, offset in the rightmost cell
 135             col2--;
 136             float cw = getColumnWidthInPixels(col2);
 137             float delta = w - size.width;
 138             dx2 = (int)((cw-delta)/cw*1024);
 139         }
 140         anchor.col2 = col2;
 141         anchor.dx2 = dx2;
 142
 143         float h = 0;
 144         h += (1 - anchor.dy1/256)* getRowHeightInPixels(anchor.row1);
 145         int row2 = anchor.row1 + 1;
 146         int dy2 = 0;
 147
 148         while(h < size.height){
 149             h += getRowHeightInPixels(row2++);
 150         }
 151         if(h > size.height) {
 152             row2--;
 153             float ch = getRowHeightInPixels(row2);
 154             float delta = h - size.height;
 155             dy2 = (int)((ch-delta)/ch*256);
 156         }
 157         anchor.row2 = row2;
 158         anchor.dy2 = dy2;
 159
 160         return anchor;
 161     }
 162
 163     private float getColumnWidthInPixels(short column){
 164
 165         short cw = patriarch.sheet.getColumnWidth(column);
 166         float px = getPixelWidth(column);
 167
 168         return cw/px;
 169     }
 170
 171     private float getRowHeightInPixels(int i){
 172
 173         HSSFRow row = patriarch.sheet.getRow(i);
 174         float height;
 175         if(row != null) height = row.getHeight();
 176         else height = patriarch.sheet.getDefaultRowHeight();
 177
 178         return height/PX_ROW;
 179     }
 180
 181     private float getPixelWidth(short column){
 182
 183         int def = patriarch.sheet.getDefaultColumnWidth()*256;
 184         short cw = patriarch.sheet.getColumnWidth(column);
 185
 186         return cw == def ? PX_DEFAULT : PX_MODIFIED;
 187     }
 188
 189     /**
 190      * The metadata of PNG and JPEG can contain the width of a pixel in millimeters.
 191      * Return the the "effective" dpi calculated as <code>25.4/HorizontalPixelSize</code>
 192      * and <code>25.4/VerticalPixelSize</code>.  Where 25.4 is the number of mm in inch.
 193      *
 194      * @return array of two elements: <code>{horisontalPdi, verticalDpi}</code>.
 195      * {96, 96} is the default.
 196      */
 197     protected int[] getResolution(ImageReader r) throws IOException {
 198         int hdpi=96, vdpi=96;
 199         double mm2inch = 25.4;
 200
 201         NodeList lst;
 202         Element node = (Element)r.getImageMetadata(0).getAsTree("javax_imageio_1.0");
 203         lst = node.getElementsByTagName("HorizontalPixelSize");
 204         if(lst != null && lst.getLength() == 1) hdpi = (int)(mm2inch/Float.parseFloat(((Element)lst.item(0)).getAttribute("value")));
 205
 206         lst = node.getElementsByTagName("VerticalPixelSize");
 207         if(lst != null && lst.getLength() == 1) vdpi = (int)(mm2inch/Float.parseFloat(((Element)lst.item(0)).getAttribute("value")));
 208
 209         return new int[]{hdpi, vdpi};
 210     }
 211
 212     /**
 213      * Return the dimension of this image
 214      *
 215      * @return image dimension
 216      */
 217     public Dimension getImageDimension(){
 218         EscherBSERecord bse = patriarch.sheet.book.getBSERecord(pictureIndex);
 219         byte[] data = bse.getBlipRecord().getPicturedata();
 220         int type = bse.getBlipTypeWin32();
 221         Dimension size = new Dimension();
 222
 223         switch (type){
 224             //we can calculate the preferred size only for JPEG and PNG
 225             //other formats like WMF, EMF and PICT are not supported in Java
 226             case HSSFWorkbook.PICTURE_TYPE_JPEG:
 227             case HSSFWorkbook.PICTURE_TYPE_PNG:
 228             case HSSFWorkbook.PICTURE_TYPE_DIB:
 229                 try {
 230                     //read the image using javax.imageio.*
 231                     ImageInputStream iis = ImageIO.createImageInputStream( new ByteArrayInputStream(data) );
 232                     Iterator i = ImageIO.getImageReaders( iis );
 233                     ImageReader r = (ImageReader) i.next();
 234                     r.setInput( iis );
 235                     BufferedImage img = r.read(0);
 236
 237                     int[] dpi = getResolution(r);
 238                     size.width = img.getWidth()*96/dpi[0];
 239                     size.height = img.getHeight()*96/dpi[1];
 240
 241                 } catch (IOException e){
 242                     //silently return if ImageIO failed to read the image
 243                     log.log(POILogger.WARN, e);
 244                 }
 245
 246                 break;
 247         }
 248         return size;
 249     }
 250 }