1 /*

     2  * Copyright (c) 2005, 2015, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 package com.sun.imageio.plugins.common;

    26 

    27 import java.awt.Point;

    28 import java.awt.Rectangle;

    29 import java.awt.image.RenderedImage;

    30 import java.awt.image.ColorModel;

    31 import java.awt.image.SampleModel;

    32 import java.awt.image.Raster;

    33 import java.awt.image.WritableRaster;

    34 import java.util.Enumeration;

    35 import java.util.Hashtable;

    36 import java.util.Iterator;

    37 import java.util.Vector;

    38 

    39 public abstract class SimpleRenderedImage implements RenderedImage {

    40     /** The X coordinate of the image's upper-left pixel. */

    41     protected int minX;

    42 

    43     /** The Y coordinate of the image's upper-left pixel. */

    44     protected int minY;

    45 

    46     /** The image's width in pixels. */

    47     protected int width;

    48 

    49     /** The image's height in pixels. */

    50     protected int height;

    51 

    52     /** The width of a tile. */

    53     protected int tileWidth;

    54 

    55     /** The height of a tile. */

    56     protected int tileHeight;

    57 

    58     /** The X coordinate of the upper-left pixel of tile (0, 0). */

    59     protected int tileGridXOffset = 0;

    60 

    61     /** The Y coordinate of the upper-left pixel of tile (0, 0). */

    62     protected int tileGridYOffset = 0;

    63 

    64     /** The image's SampleModel. */

    65     protected SampleModel sampleModel;

    66 

    67     /** The image's ColorModel. */

    68     protected ColorModel colorModel;

    69 

    70     /** The image's sources, stored in a Vector. */

    71     protected Vector<RenderedImage> sources = new Vector<RenderedImage>();

    72 

    73     /** A Hashtable containing the image properties. */

    74     protected Hashtable<String,Object> properties = new Hashtable<String,Object>();

    75 

    76     /** Returns the X coordinate of the leftmost column of the image. */

    77     public int getMinX() {

    78         return minX;

    79     }

    80 

    81     /**

    82      * Returns the X coordinate of the column immediatetely to the

    83      * right of the rightmost column of the image.  getMaxX() is

    84      * implemented in terms of getMinX() and getWidth() and so does

    85      * not need to be implemented by subclasses.

    86      */

    87     public final int getMaxX() {

    88         return getMinX() + getWidth();

    89     }

    90 

    91     /** Returns the X coordinate of the uppermost row of the image. */

    92     public int getMinY() {

    93         return minY;

    94     }

    95 

    96     /**

    97      * Returns the Y coordinate of the row immediately below the

    98      * bottom row of the image.  getMaxY() is implemented in terms of

    99      * getMinY() and getHeight() and so does not need to be

   100      * implemented by subclasses.

   101      */

   102     public final int getMaxY() {

   103         return getMinY() + getHeight();

   104     }

   105 

   106     /** Returns the width of the image. */

   107     public int getWidth() {

   108         return width;

   109     }

   110 

   111     /** Returns the height of the image. */

   112     public int getHeight() {

   113         return height;

   114     }

   115 

   116     /** Returns a Rectangle indicating the image bounds. */

   117     public Rectangle getBounds() {

   118         return new Rectangle(getMinX(), getMinY(), getWidth(), getHeight());

   119     }

   120 

   121     /** Returns the width of a tile. */

   122     public int getTileWidth() {

   123         return tileWidth;

   124     }

   125 

   126     /** Returns the height of a tile. */

   127     public int getTileHeight() {

   128         return tileHeight;

   129     }

   130 

   131     /**

   132      * Returns the X coordinate of the upper-left pixel of tile (0, 0).

   133      */

   134     public int getTileGridXOffset() {

   135         return tileGridXOffset;

   136     }

   137 

   138     /**

   139      * Returns the Y coordinate of the upper-left pixel of tile (0, 0).

   140      */

   141     public int getTileGridYOffset() {

   142         return tileGridYOffset;

   143     }

   144 

   145     /**

   146      * Returns the horizontal index of the leftmost column of tiles.

   147      * getMinTileX() is implemented in terms of getMinX()

   148      * and so does not need to be implemented by subclasses.

   149      */

   150     public int getMinTileX() {

   151         return XToTileX(getMinX());

   152     }

   153 

   154     /**

   155      * Returns the horizontal index of the rightmost column of tiles.

   156      * getMaxTileX() is implemented in terms of getMaxX()

   157      * and so does not need to be implemented by subclasses.

   158      */

   159     public int getMaxTileX() {

   160         return XToTileX(getMaxX() - 1);

   161     }

   162 

   163     /**

   164      * Returns the number of tiles along the tile grid in the

   165      * horizontal direction.  getNumXTiles() is implemented in terms

   166      * of getMinTileX() and getMaxTileX() and so does not need to be

   167      * implemented by subclasses.

   168      */

   169     public int getNumXTiles() {

   170         return getMaxTileX() - getMinTileX() + 1;

   171     }

   172 

   173     /**

   174      * Returns the vertical index of the uppermost row of tiles.  getMinTileY()

   175      * is implemented in terms of getMinY() and so does not need to be

   176      * implemented by subclasses.

   177      */

   178     public int getMinTileY() {

   179         return YToTileY(getMinY());

   180     }

   181 

   182     /**

   183      * Returns the vertical index of the bottom row of tiles.  getMaxTileY()

   184      * is implemented in terms of getMaxY() and so does not need to

   185      * be implemented by subclasses.

   186      */

   187     public int getMaxTileY() {

   188         return YToTileY(getMaxY() - 1);

   189     }

   190 

   191     /**

   192      * Returns the number of tiles along the tile grid in the vertical

   193      * direction.  getNumYTiles() is implemented in terms

   194      * of getMinTileY() and getMaxTileY() and so does not need to be

   195      * implemented by subclasses.

   196      */

   197     public int getNumYTiles() {

   198         return getMaxTileY() - getMinTileY() + 1;

   199     }

   200 

   201     /** Returns the SampleModel of the image. */

   202     public SampleModel getSampleModel() {

   203         return sampleModel;

   204     }

   205 

   206     /** Returns the ColorModel of the image. */

   207     public ColorModel getColorModel() {

   208         return colorModel;

   209     }

   210 

   211     /**

   212      * Gets a property from the property set of this image.  If the

   213      * property name is not recognized,

   214      * <code>java.awt.Image.UndefinedProperty</code> will be returned.

   215      *

   216      * @param name the name of the property to get, as a

   217      * <code>String</code>.  @return a reference to the property

   218      * <code>Object</code>, or the value

   219      * <code>java.awt.Image.UndefinedProperty.</code>

   220      */

   221     public Object getProperty(String name) {

   222         name = name.toLowerCase();

   223         Object value = properties.get(name);

   224         return value != null ? value : java.awt.Image.UndefinedProperty;

   225     }

   226 

   227     /**

   228      * Returns a list of the properties recognized by this image.  If

   229      * no properties are available, <code>null</code> will be

   230      * returned.

   231      *

   232      * @return an array of <code>String</code>s representing valid

   233      *         property names.

   234      */

   235     public String[] getPropertyNames() {

   236         String[] names = null;

   237 

   238         if(properties.size() > 0) {

   239             names = new String[properties.size()];

   240             int index = 0;

   241 

   242             Enumeration<String> e = properties.keys();

   243             while (e.hasMoreElements()) {

   244                 String name = e.nextElement();

   245                 names[index++] = name;

   246             }

   247         }

   248 

   249         return names;

   250     }

   251 

   252     /**

   253      * Returns an array of <code>String</code>s recognized as names by

   254      * this property source that begin with the supplied prefix.  If

   255      * no property names match, <code>null</code> will be returned.

   256      * The comparison is done in a case-independent manner.

   257      *

   258      * <p> The default implementation calls

   259      * <code>getPropertyNames()</code> and searches the list of names

   260      * for matches.

   261      *

   262      * @return an array of <code>String</code>s giving the valid

   263      * property names.

   264      */

   265     public String[] getPropertyNames(String prefix) {

   266         String propertyNames[] = getPropertyNames();

   267         if (propertyNames == null) {

   268             return null;

   269         }

   270 

   271         prefix = prefix.toLowerCase();

   272 

   273         Vector<String> names = new Vector<String>();

   274         for (int i = 0; i < propertyNames.length; i++) {

   275             if (propertyNames[i].startsWith(prefix)) {

   276                 names.addElement(propertyNames[i]);

   277             }

   278         }

   279 

   280         if (names.size() == 0) {

   281             return null;

   282         }

   283 

   284         // Copy the strings from the Vector over to a String array.

   285         String prefixNames[] = new String[names.size()];

   286         int count = 0;

   287         for (Iterator<String> it = names.iterator(); it.hasNext(); ) {

   288             prefixNames[count++] = it.next();

   289         }

   290 

   291         return prefixNames;

   292     }

   293 

   294     // Utility methods.

   295 

   296     /**

   297      * Converts a pixel's X coordinate into a horizontal tile index

   298      * relative to a given tile grid layout specified by its X offset

   299      * and tile width.

   300      */

   301     public static int XToTileX(int x, int tileGridXOffset, int tileWidth) {

   302         x -= tileGridXOffset;

   303         if (x < 0) {

   304             x += 1 - tileWidth; // Force round to -infinity

   305         }

   306         return x/tileWidth;

   307     }

   308 

   309     /**

   310      * Converts a pixel's Y coordinate into a vertical tile index

   311      * relative to a given tile grid layout specified by its Y offset

   312      * and tile height.

   313      */

   314     public static int YToTileY(int y, int tileGridYOffset, int tileHeight) {

   315         y -= tileGridYOffset;

   316         if (y < 0) {

   317             y += 1 - tileHeight; // Force round to -infinity

   318         }

   319         return y/tileHeight;

   320     }

   321 

   322     /**

   323      * Converts a pixel's X coordinate into a horizontal tile index.

   324      * This is a convenience method.  No attempt is made to detect

   325      * out-of-range coordinates.

   326      *

   327      * @param x the X coordinate of a pixel.

   328      * @return the X index of the tile containing the pixel.

   329      */

   330     public int XToTileX(int x) {

   331         return XToTileX(x, getTileGridXOffset(), getTileWidth());

   332     }

   333 

   334     /**

   335      * Converts a pixel's Y coordinate into a vertical tile index.

   336      * This is a convenience method.  No attempt is made to detect

   337      * out-of-range coordinates.

   338      *

   339      * @param y the Y coordinate of a pixel.

   340      * @return the Y index of the tile containing the pixel.

   341      */

   342     public int YToTileY(int y) {

   343         return YToTileY(y, getTileGridYOffset(), getTileHeight());

   344     }

   345 

   346     /**

   347      * Converts a horizontal tile index into the X coordinate of its

   348      * upper left pixel relative to a given tile grid layout specified

   349      * by its X offset and tile width.

   350      */

   351     public static int tileXToX(int tx, int tileGridXOffset, int tileWidth) {

   352         return tx*tileWidth + tileGridXOffset;

   353     }

   354 

   355     /**

   356      * Converts a vertical tile index into the Y coordinate of

   357      * its upper left pixel relative to a given tile grid layout

   358      * specified by its Y offset and tile height.

   359      */

   360     public static int tileYToY(int ty, int tileGridYOffset, int tileHeight) {

   361         return ty*tileHeight + tileGridYOffset;

   362     }

   363 

   364     /**

   365      * Converts a horizontal tile index into the X coordinate of its

   366      * upper left pixel.  This is a convenience method.  No attempt is made

   367      * to detect out-of-range indices.

   368      *

   369      * @param tx the horizontal index of a tile.

   370      * @return the X coordinate of the tile's upper left pixel.

   371      */

   372     public int tileXToX(int tx) {

   373         return tx*tileWidth + tileGridXOffset;

   374     }

   375 

   376     /**

   377      * Converts a vertical tile index into the Y coordinate of its

   378      * upper left pixel.  This is a convenience method.  No attempt is made

   379      * to detect out-of-range indices.

   380      *

   381      * @param ty the vertical index of a tile.

   382      * @return the Y coordinate of the tile's upper left pixel.

   383      */

   384     public int tileYToY(int ty) {

   385         return ty*tileHeight + tileGridYOffset;

   386     }

   387 

   388     public Vector<RenderedImage> getSources() {

   389         return null;

   390     }

   391 

   392     /**

   393      * Returns the entire image in a single Raster.  For images with

   394      * multiple tiles this will require making a copy.

   395      *

   396      * <p> The returned Raster is semantically a copy.  This means

   397      * that updates to the source image will not be reflected in the

   398      * returned Raster.  For non-writable (immutable) source images,

   399      * the returned value may be a reference to the image's internal

   400      * data.  The returned Raster should be considered non-writable;

   401      * any attempt to alter its pixel data (such as by casting it to

   402      * WritableRaster or obtaining and modifying its DataBuffer) may

   403      * result in undefined behavior.  The copyData method should be

   404      * used if the returned Raster is to be modified.

   405      *

   406      * @return a Raster containing a copy of this image's data.

   407      */

   408     public Raster getData() {

   409         Rectangle rect = new Rectangle(getMinX(), getMinY(),

   410                                        getWidth(), getHeight());

   411         return getData(rect);

   412     }

   413 

   414     /**

   415      * Returns an arbitrary rectangular region of the RenderedImage

   416      * in a Raster.  The rectangle of interest will be clipped against

   417      * the image bounds.

   418      *

   419      * <p> The returned Raster is semantically a copy.  This means

   420      * that updates to the source image will not be reflected in the

   421      * returned Raster.  For non-writable (immutable) source images,

   422      * the returned value may be a reference to the image's internal

   423      * data.  The returned Raster should be considered non-writable;

   424      * any attempt to alter its pixel data (such as by casting it to

   425      * WritableRaster or obtaining and modifying its DataBuffer) may

   426      * result in undefined behavior.  The copyData method should be

   427      * used if the returned Raster is to be modified.

   428      *

   429      * @param bounds the region of the RenderedImage to be returned.

   430      */

   431     public Raster getData(Rectangle bounds) {

   432         // Get the image bounds.

   433         Rectangle imageBounds = getBounds();

   434 

   435         // Check for parameter validity.

   436         if(bounds == null) {

   437             bounds = imageBounds;

   438         } else if(!bounds.intersects(imageBounds)) {

   439             throw new IllegalArgumentException("The provided region doesn't intersect with the image bounds.");

   440         }

   441 

   442         // Determine tile limits for the prescribed bounds.

   443         int startX = XToTileX(bounds.x);

   444         int startY = YToTileY(bounds.y);

   445         int endX = XToTileX(bounds.x + bounds.width - 1);

   446         int endY = YToTileY(bounds.y + bounds.height - 1);

   447 

   448         // If the bounds are contained in a single tile, return a child

   449         // of that tile's Raster.

   450         if ((startX == endX) && (startY == endY)) {

   451             Raster tile = getTile(startX, startY);

   452             return tile.createChild(bounds.x, bounds.y,

   453                                     bounds.width, bounds.height,

   454                                     bounds.x, bounds.y, null);

   455         } else {

   456             // Recalculate the tile limits if the data bounds are not a

   457             // subset of the image bounds.

   458             if(!imageBounds.contains(bounds)) {

   459                 Rectangle xsect = bounds.intersection(imageBounds);

   460                 startX = XToTileX(xsect.x);

   461                 startY = YToTileY(xsect.y);

   462                 endX = XToTileX(xsect.x + xsect.width - 1);

   463                 endY = YToTileY(xsect.y + xsect.height - 1);

   464             }

   465 

   466             // Create a WritableRaster of the desired size

   467             SampleModel sm =

   468                 sampleModel.createCompatibleSampleModel(bounds.width,

   469                                                         bounds.height);

   470 

   471             // Translate it

   472             WritableRaster dest =

   473                 Raster.createWritableRaster(sm, bounds.getLocation());

   474 

   475             // Loop over the tiles in the intersection.

   476             for (int j = startY; j <= endY; j++) {

   477                 for (int i = startX; i <= endX; i++) {

   478                     // Retrieve the tile.

   479                     Raster tile = getTile(i, j);

   480 

   481                     // Create a child of the tile for the intersection of

   482                     // the tile bounds and the bounds of the requested area.

   483                     Rectangle tileRect = tile.getBounds();

   484                     Rectangle intersectRect =

   485                         bounds.intersection(tile.getBounds());

   486                     Raster liveRaster = tile.createChild(intersectRect.x,

   487                                                          intersectRect.y,

   488                                                          intersectRect.width,

   489                                                          intersectRect.height,

   490                                                          intersectRect.x,

   491                                                          intersectRect.y,

   492                                                          null);

   493 

   494                     // Copy the data from the child.

   495                     dest.setRect(liveRaster);

   496                 }

   497             }

   498 

   499             return dest;

   500         }

   501     }

   502 

   503     /**

   504      * Copies an arbitrary rectangular region of the RenderedImage

   505      * into a caller-supplied WritableRaster.  The region to be

   506      * computed is determined by clipping the bounds of the supplied

   507      * WritableRaster against the bounds of the image.  The supplied

   508      * WritableRaster must have a SampleModel that is compatible with

   509      * that of the image.

   510      *

   511      * <p> If the raster argument is null, the entire image will

   512      * be copied into a newly-created WritableRaster with a SampleModel

   513      * that is compatible with that of the image.

   514      *

   515      * @param dest a WritableRaster to hold the returned portion of

   516      *        the image.

   517      * @return a reference to the supplied WritableRaster, or to a

   518      *         new WritableRaster if the supplied one was null.

   519      */

   520     public WritableRaster copyData(WritableRaster dest) {

   521         // Get the image bounds.

   522         Rectangle imageBounds = getBounds();

   523 

   524         Rectangle bounds;

   525         if (dest == null) {

   526             // Create a WritableRaster for the entire image.

   527             bounds = imageBounds;

   528             Point p = new Point(minX, minY);

   529             SampleModel sm =

   530                 sampleModel.createCompatibleSampleModel(width, height);

   531             dest = Raster.createWritableRaster(sm, p);

   532         } else {

   533             bounds = dest.getBounds();

   534         }

   535 

   536         // Determine tile limits for the intersection of the prescribed

   537         // bounds with the image bounds.

   538         Rectangle xsect = imageBounds.contains(bounds) ?

   539             bounds : bounds.intersection(imageBounds);

   540         int startX = XToTileX(xsect.x);

   541         int startY = YToTileY(xsect.y);

   542         int endX = XToTileX(xsect.x + xsect.width - 1);

   543         int endY = YToTileY(xsect.y + xsect.height - 1);

   544 

   545         // Loop over the tiles in the intersection.

   546         for (int j = startY; j <= endY; j++) {

   547             for (int i = startX; i <= endX; i++) {

   548                 // Retrieve the tile.

   549                 Raster tile = getTile(i, j);

   550 

   551                 // Create a child of the tile for the intersection of

   552                 // the tile bounds and the bounds of the requested area.

   553                 Rectangle tileRect = tile.getBounds();

   554                 Rectangle intersectRect =

   555                     bounds.intersection(tile.getBounds());

   556                 Raster liveRaster = tile.createChild(intersectRect.x,

   557                                                      intersectRect.y,

   558                                                      intersectRect.width,

   559                                                      intersectRect.height,

   560                                                      intersectRect.x,

   561                                                      intersectRect.y,

   562                                                      null);

   563 

   564                 // Copy the data from the child.

   565                 dest.setRect(liveRaster);

   566             }

   567         }

   568 

   569         return dest;

   570     }

   571 }