| Frames | No Frames |
1: /* ColorConvertOp.java -- 2: Copyright (C) 2004, 2006 Free Software Foundation 3: 4: This file is part of GNU Classpath. 5: 6: GNU Classpath is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU Classpath is distributed in the hope that it will be useful, but 12: WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14: General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU Classpath; see the file COPYING. If not, write to the 18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19: 02110-1301 USA. 20: 21: Linking this library statically or dynamically with other modules is 22: making a combined work based on this library. Thus, the terms and 23: conditions of the GNU General Public License cover the whole 24: combination. 25: 26: As a special exception, the copyright holders of this library give you 27: permission to link this library with independent modules to produce an 28: executable, regardless of the license terms of these independent 29: modules, and to copy and distribute the resulting executable under 30: terms of your choice, provided that you also meet, for each linked 31: independent module, the terms and conditions of the license of that 32: module. An independent module is a module which is not derived from 33: or based on this library. If you modify this library, you may extend 34: this exception to your version of the library, but you are not 35: obligated to do so. If you do not wish to do so, delete this 36: exception statement from your version. */ 37: 38: 39: package java.awt.image; 40: 41: import gnu.java.awt.Buffers; 42: 43: import java.awt.Graphics2D; 44: import java.awt.Point; 45: import java.awt.RenderingHints; 46: import java.awt.color.ColorSpace; 47: import java.awt.color.ICC_ColorSpace; 48: import java.awt.color.ICC_Profile; 49: import java.awt.geom.Point2D; 50: import java.awt.geom.Rectangle2D; 51: 52: /** 53: * ColorConvertOp is a filter for converting images or rasters between 54: * colorspaces, either through a sequence of colorspaces or just from source to 55: * destination. 56: * 57: * Color conversion is done on the color components without alpha. Thus 58: * if a BufferedImage has alpha premultiplied, this is divided out before 59: * color conversion, and premultiplication applied if the destination 60: * requires it. 61: * 62: * Color rendering and dithering hints may be applied if specified. This is 63: * likely platform-dependent. 64: * 65: * @author jlquinn@optonline.net 66: */ 67: public class ColorConvertOp implements BufferedImageOp, RasterOp 68: { 69: private RenderingHints hints; 70: private ICC_Profile[] profiles = null; 71: private ColorSpace[] spaces; 72: 73: 74: /** 75: * Convert a BufferedImage through a ColorSpace. 76: * 77: * Objects created with this constructor can be used to convert 78: * BufferedImage's to a destination ColorSpace. Attempts to convert Rasters 79: * with this constructor will result in an IllegalArgumentException when the 80: * filter(Raster, WritableRaster) method is called. 81: * 82: * @param cspace The target color space. 83: * @param hints Rendering hints to use in conversion, if any (may be null) 84: * @throws NullPointerException if the ColorSpace is null. 85: */ 86: public ColorConvertOp(ColorSpace cspace, RenderingHints hints) 87: { 88: if (cspace == null) 89: throw new NullPointerException(); 90: spaces = new ColorSpace[]{cspace}; 91: this.hints = hints; 92: } 93: 94: /** 95: * Convert from a source colorspace to a destination colorspace. 96: * 97: * This constructor takes two ColorSpace arguments as the source and 98: * destination color spaces. It is usually used with the 99: * filter(Raster, WritableRaster) method, in which case the source colorspace 100: * is assumed to correspond to the source Raster, and the destination 101: * colorspace with the destination Raster. 102: * 103: * If used with BufferedImages that do not match the source or destination 104: * colorspaces specified here, there is an implicit conversion from the 105: * source image to the source ColorSpace, or the destination ColorSpace to 106: * the destination image. 107: * 108: * @param srcCspace The source ColorSpace. 109: * @param dstCspace The destination ColorSpace. 110: * @param hints Rendering hints to use in conversion, if any (may be null). 111: * @throws NullPointerException if any ColorSpace is null. 112: */ 113: public ColorConvertOp(ColorSpace srcCspace, ColorSpace dstCspace, 114: RenderingHints hints) 115: { 116: if (srcCspace == null || dstCspace == null) 117: throw new NullPointerException(); 118: spaces = new ColorSpace[]{srcCspace, dstCspace}; 119: this.hints = hints; 120: } 121: 122: /** 123: * Convert from a source colorspace to a destinatino colorspace. 124: * 125: * This constructor builds a ColorConvertOp from an array of ICC_Profiles. 126: * The source will be converted through the sequence of color spaces 127: * defined by the profiles. If the sequence of profiles doesn't give a 128: * well-defined conversion, an IllegalArgumentException is thrown. 129: * 130: * If used with BufferedImages that do not match the source or destination 131: * colorspaces specified here, there is an implicit conversion from the 132: * source image to the source ColorSpace, or the destination ColorSpace to 133: * the destination image. 134: * 135: * For Rasters, the first and last profiles must have the same number of 136: * bands as the source and destination Rasters, respectively. If this is 137: * not the case, or there fewer than 2 profiles, an IllegalArgumentException 138: * will be thrown. 139: * 140: * @param profiles An array of ICC_Profile's to convert through. 141: * @param hints Rendering hints to use in conversion, if any (may be null). 142: * @throws NullPointerException if the profile array is null. 143: * @throws IllegalArgumentException if the array is not a well-defined 144: * conversion. 145: */ 146: public ColorConvertOp(ICC_Profile[] profiles, RenderingHints hints) 147: { 148: if (profiles == null) 149: throw new NullPointerException(); 150: 151: this.hints = hints; 152: this.profiles = profiles; 153: 154: // Create colorspace array with space for src and dest colorspace 155: // Note that the ICC_ColorSpace constructor will throw an 156: // IllegalArgumentException if the profile is invalid; thus we check 157: // for a "well defined conversion" 158: spaces = new ColorSpace[profiles.length]; 159: for (int i = 0; i < profiles.length; i++) 160: spaces[i] = new ICC_ColorSpace(profiles[i]); 161: } 162: 163: /** 164: * Convert from source color space to destination color space. 165: * 166: * Only valid for BufferedImage objects, this Op converts from the source 167: * image's color space to the destination image's color space. 168: * 169: * The destination in the filter(BufferedImage, BufferedImage) method cannot 170: * be null for this operation, and it also cannot be used with the 171: * filter(Raster, WritableRaster) method. 172: * 173: * @param hints Rendering hints to use in conversion, if any (may be null). 174: */ 175: public ColorConvertOp(RenderingHints hints) 176: { 177: this.hints = hints; 178: spaces = new ColorSpace[0]; 179: } 180: 181: /** 182: * Converts the source image using the conversion path specified in the 183: * constructor. The resulting image is stored in the destination image if one 184: * is provided; otherwise a new BufferedImage is created and returned. 185: * 186: * The source and destination BufferedImage (if one is supplied) must have 187: * the same dimensions. 188: * 189: * @param src The source image. 190: * @param dst The destination image. 191: * @throws IllegalArgumentException if the rasters and/or color spaces are 192: * incompatible. 193: * @return The transformed image. 194: */ 195: public final BufferedImage filter(BufferedImage src, BufferedImage dst) 196: { 197: // TODO: The plan is to create a scanline buffer for intermediate buffers. 198: // For now we just suck it up and create intermediate buffers. 199: 200: if (dst == null && spaces.length == 0) 201: throw new IllegalArgumentException("Not enough color space information " 202: + "to complete conversion."); 203: 204: if (dst != null 205: && (src.getHeight() != dst.getHeight() || src.getWidth() != dst.getWidth())) 206: throw new IllegalArgumentException("Source and destination images have " 207: + "different dimensions"); 208: 209: // Make sure input isn't premultiplied by alpha 210: if (src.isAlphaPremultiplied()) 211: { 212: BufferedImage tmp = createCompatibleDestImage(src, src.getColorModel()); 213: copyimage(src, tmp); 214: tmp.coerceData(false); 215: src = tmp; 216: } 217: 218: // Convert through defined intermediate conversions 219: BufferedImage tmp; 220: for (int i = 0; i < spaces.length; i++) 221: { 222: if (src.getColorModel().getColorSpace().getType() != spaces[i].getType()) 223: { 224: tmp = createCompatibleDestImage(src, 225: createCompatibleColorModel(src, 226: spaces[i])); 227: copyimage(src, tmp); 228: src = tmp; 229: } 230: } 231: 232: // No implicit conversion to destination type needed; return result from the 233: // last intermediate conversions (which was left in src) 234: if (dst == null) 235: dst = src; 236: 237: // Implicit conversion to destination image's color space 238: else 239: copyimage(src, dst); 240: 241: return dst; 242: } 243: 244: /** 245: * Converts the source raster using the conversion path specified in the 246: * constructor. The resulting raster is stored in the destination raster if 247: * one is provided; otherwise a new WritableRaster is created and returned. 248: * 249: * This operation is not valid with every constructor of this class; see 250: * the constructors for details. Further, the source raster must have the 251: * same number of bands as the source ColorSpace, and the destination raster 252: * must have the same number of bands as the destination ColorSpace. 253: * 254: * The source and destination raster (if one is supplied) must also have the 255: * same dimensions. 256: * 257: * @param src The source raster. 258: * @param dest The destination raster. 259: * @throws IllegalArgumentException if the rasters and/or color spaces are 260: * incompatible. 261: * @return The transformed raster. 262: */ 263: public final WritableRaster filter(Raster src, WritableRaster dest) 264: { 265: // Various checks to ensure that the rasters and color spaces are compatible 266: if (spaces.length < 2) 267: throw new IllegalArgumentException("Not enough information about " + 268: "source and destination colorspaces."); 269: 270: if (spaces[0].getNumComponents() != src.getNumBands() 271: || (dest != null && spaces[spaces.length - 1].getNumComponents() != dest.getNumBands())) 272: throw new IllegalArgumentException("Source or destination raster " + 273: "contains the wrong number of bands."); 274: 275: if (dest != null 276: && (src.getHeight() != dest.getHeight() || src.getWidth() != dest.getWidth())) 277: throw new IllegalArgumentException("Source and destination rasters " + 278: "have different dimensions"); 279: 280: // Need to iterate through each color space. 281: // spaces[0] corresponds to the ColorSpace of the source raster, and 282: // spaces[spaces.length - 1] corresponds to the ColorSpace of the 283: // destination, with any number (or zero) of intermediate conversions. 284: 285: for (int i = 0; i < spaces.length - 2; i++) 286: { 287: WritableRaster tmp = createCompatibleDestRaster(src, spaces[i + 1], 288: false, 289: src.getTransferType()); 290: copyraster(src, spaces[i], tmp, spaces[i + 1]); 291: src = tmp; 292: } 293: 294: // The last conversion is done outside of the loop so that we can 295: // use the dest raster supplied, instead of creating our own temp raster 296: if (dest == null) 297: dest = createCompatibleDestRaster(src, spaces[spaces.length - 1], false, 298: DataBuffer.TYPE_BYTE); 299: copyraster(src, spaces[spaces.length - 2], dest, spaces[spaces.length - 1]); 300: 301: return dest; 302: } 303: 304: /** 305: * Creates an empty BufferedImage with the size equal to the source and the 306: * correct number of bands for the conversion defined in this Op. The newly 307: * created image is created with the specified ColorModel, or if no ColorModel 308: * is supplied, an appropriate one is chosen. 309: * 310: * @param src The source image. 311: * @param dstCM A color model for the destination image (may be null). 312: * @throws IllegalArgumentException if an appropriate colormodel cannot be 313: * chosen with the information given. 314: * @return The new compatible destination image. 315: */ 316: public BufferedImage createCompatibleDestImage(BufferedImage src, 317: ColorModel dstCM) 318: { 319: if (dstCM == null && spaces.length == 0) 320: throw new IllegalArgumentException("Don't know the destination " + 321: "colormodel"); 322: 323: if (dstCM == null) 324: { 325: dstCM = createCompatibleColorModel(src, spaces[spaces.length - 1]); 326: } 327: 328: return new BufferedImage(dstCM, 329: createCompatibleDestRaster(src.getRaster(), 330: dstCM.getColorSpace(), 331: src.getColorModel().hasAlpha, 332: dstCM.getTransferType()), 333: src.isPremultiplied, null); 334: } 335: 336: /** 337: * Creates a new WritableRaster with the size equal to the source and the 338: * correct number of bands. 339: * 340: * Note, the new Raster will always use a BYTE storage size, regardless of 341: * the color model or defined destination; this is for compatibility with 342: * the reference implementation. 343: * 344: * @param src The source Raster. 345: * @throws IllegalArgumentException if there isn't enough colorspace 346: * information to create a compatible Raster. 347: * @return The new compatible destination raster. 348: */ 349: public WritableRaster createCompatibleDestRaster(Raster src) 350: { 351: if (spaces.length < 2) 352: throw new IllegalArgumentException("Not enough destination colorspace " + 353: "information"); 354: 355: // Create a new raster with the last ColorSpace in the conversion 356: // chain, and with no alpha (implied) 357: return createCompatibleDestRaster(src, spaces[spaces.length-1], false, 358: DataBuffer.TYPE_BYTE); 359: } 360: 361: /** 362: * Returns the array of ICC_Profiles used to create this Op, or null if the 363: * Op was created using ColorSpace arguments. 364: * 365: * @return The array of ICC_Profiles, or null. 366: */ 367: public final ICC_Profile[] getICC_Profiles() 368: { 369: return profiles; 370: } 371: 372: /** 373: * Returns the rendering hints for this op. 374: * 375: * @return The rendering hints for this Op, or null. 376: */ 377: public final RenderingHints getRenderingHints() 378: { 379: return hints; 380: } 381: 382: /** 383: * Returns the corresponding destination point for a source point. 384: * Because this is not a geometric operation, the destination and source 385: * points will be identical. 386: * 387: * @param src The source point. 388: * @param dst The transformed destination point. 389: * @return The transformed destination point. 390: */ 391: public final Point2D getPoint2D(Point2D src, Point2D dst) 392: { 393: if (dst == null) 394: return (Point2D)src.clone(); 395: 396: dst.setLocation(src); 397: return dst; 398: } 399: 400: /** 401: * Returns the corresponding destination boundary of a source boundary. 402: * Because this is not a geometric operation, the destination and source 403: * boundaries will be identical. 404: * 405: * @param src The source boundary. 406: * @return The boundaries of the destination. 407: */ 408: public final Rectangle2D getBounds2D(BufferedImage src) 409: { 410: return src.getRaster().getBounds(); 411: } 412: 413: /** 414: * Returns the corresponding destination boundary of a source boundary. 415: * Because this is not a geometric operation, the destination and source 416: * boundaries will be identical. 417: * 418: * @param src The source boundary. 419: * @return The boundaries of the destination. 420: */ 421: public final Rectangle2D getBounds2D(Raster src) 422: { 423: return src.getBounds(); 424: } 425: 426: /** 427: * Copy a source image to a destination image, respecting their colorspaces 428: * and performing colorspace conversions if necessary. 429: * 430: * @param src The source image. 431: * @param dst The destination image. 432: */ 433: private void copyimage(BufferedImage src, BufferedImage dst) 434: { 435: // This is done using Graphics2D in order to respect the rendering hints. 436: Graphics2D gg = dst.createGraphics(); 437: 438: // If no hints are set there is no need to call 439: // setRenderingHints on the Graphics2D object. 440: if (hints != null) 441: gg.setRenderingHints(hints); 442: 443: gg.drawImage(src, 0, 0, null); 444: gg.dispose(); 445: } 446: 447: /** 448: * Copy a source raster to a destination raster, performing a colorspace 449: * conversion between the two. The conversion will respect the 450: * KEY_COLOR_RENDERING rendering hint if one is present. 451: * 452: * @param src The source raster. 453: * @param scs The colorspace of the source raster. 454: * @dst The destination raster. 455: * @dcs The colorspace of the destination raster. 456: */ 457: private void copyraster(Raster src, ColorSpace scs, WritableRaster dst, ColorSpace dcs) 458: { 459: float[] sbuf = new float[src.getNumBands()]; 460: 461: if (hints != null 462: && hints.get(RenderingHints.KEY_COLOR_RENDERING) == 463: RenderingHints.VALUE_COLOR_RENDER_QUALITY) 464: { 465: // use cie for accuracy 466: for (int y = src.getMinY(); y < src.getHeight() + src.getMinY(); y++) 467: for (int x = src.getMinX(); x < src.getWidth() + src.getMinX(); x++) 468: dst.setPixel(x, y, 469: dcs.fromCIEXYZ(scs.toCIEXYZ(src.getPixel(x, y, sbuf)))); 470: } 471: else 472: { 473: // use rgb - it's probably faster 474: for (int y = src.getMinY(); y < src.getHeight() + src.getMinY(); y++) 475: for (int x = src.getMinX(); x < src.getWidth() + src.getMinX(); x++) 476: dst.setPixel(x, y, 477: dcs.fromRGB(scs.toRGB(src.getPixel(x, y, sbuf)))); 478: } 479: } 480: 481: /** 482: * This method creates a color model with the same colorspace and alpha 483: * settings as the source image. The created color model will always be a 484: * ComponentColorModel and have a BYTE transfer type. 485: * 486: * @param img The source image. 487: * @param cs The ColorSpace to use. 488: * @return A color model compatible with the source image. 489: */ 490: private ColorModel createCompatibleColorModel(BufferedImage img, ColorSpace cs) 491: { 492: // The choice of ComponentColorModel and DataBuffer.TYPE_BYTE is based on 493: // Mauve testing of the reference implementation. 494: return new ComponentColorModel(cs, 495: img.getColorModel().hasAlpha(), 496: img.isAlphaPremultiplied(), 497: img.getColorModel().getTransparency(), 498: DataBuffer.TYPE_BYTE); 499: } 500: 501: /** 502: * This method creates a compatible Raster, given a source raster, colorspace, 503: * alpha value, and transfer type. 504: * 505: * @param src The source raster. 506: * @param cs The ColorSpace to use. 507: * @param hasAlpha Whether the raster should include a component for an alpha. 508: * @param transferType The size of a single data element. 509: * @return A compatible WritableRaster. 510: */ 511: private WritableRaster createCompatibleDestRaster(Raster src, ColorSpace cs, 512: boolean hasAlpha, 513: int transferType) 514: { 515: // The use of a PixelInterleavedSampleModel weas determined using mauve 516: // tests, based on the reference implementation 517: 518: int numComponents = cs.getNumComponents(); 519: if (hasAlpha) 520: numComponents++; 521: 522: int[] offsets = new int[numComponents]; 523: for (int i = 0; i < offsets.length; i++) 524: offsets[i] = i; 525: 526: DataBuffer db = Buffers.createBuffer(transferType, 527: src.getWidth() * src.getHeight() * numComponents, 528: 1); 529: return new WritableRaster(new PixelInterleavedSampleModel(transferType, 530: src.getWidth(), 531: src.getHeight(), 532: numComponents, 533: numComponents * src.getWidth(), 534: offsets), 535: db, new Point(src.getMinX(), src.getMinY())); 536: } 537: }