1 /* 2 * Copyright (c) 1997, 2017, 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 26 /* 27 ********************************************************************** 28 ********************************************************************** 29 ********************************************************************** 30 *** COPYRIGHT (c) Eastman Kodak Company, 1997 *** 31 *** As an unpublished work pursuant to Title 17 of the United *** 32 *** States Code. All rights reserved. *** 33 ********************************************************************** 34 ********************************************************************** 35 **********************************************************************/ 36 37 package java.awt.image; 38 39 import java.awt.Point; 40 import java.awt.Graphics2D; 41 import java.awt.color.*; 42 import sun.java2d.cmm.ColorTransform; 43 import sun.java2d.cmm.CMSManager; 44 import sun.java2d.cmm.ProfileDeferralMgr; 45 import sun.java2d.cmm.PCMM; 46 import java.awt.geom.Rectangle2D; 47 import java.awt.geom.Point2D; 48 import java.awt.RenderingHints; 49 50 /** 51 * This class performs a pixel-by-pixel color conversion of the data in 52 * the source image. The resulting color values are scaled to the precision 53 * of the destination image. Color conversion can be specified 54 * via an array of ColorSpace objects or an array of ICC_Profile objects. 55 * <p> 56 * If the source is a BufferedImage with premultiplied alpha, the 57 * color components are divided by the alpha component before color conversion. 58 * If the destination is a BufferedImage with premultiplied alpha, the 59 * color components are multiplied by the alpha component after conversion. 60 * Rasters are treated as having no alpha channel, i.e. all bands are 61 * color bands. 62 * <p> 63 * If a RenderingHints object is specified in the constructor, the 64 * color rendering hint and the dithering hint may be used to control 65 * color conversion. 66 * <p> 67 * Note that Source and Destination may be the same object. 68 * @see java.awt.RenderingHints#KEY_COLOR_RENDERING 69 * @see java.awt.RenderingHints#KEY_DITHERING 70 */ 71 public class ColorConvertOp implements BufferedImageOp, RasterOp { 72 ICC_Profile[] profileList; 73 ColorSpace[] CSList; 74 ColorTransform thisTransform, thisRasterTransform; 75 ICC_Profile thisSrcProfile, thisDestProfile; 76 RenderingHints hints; 77 boolean gotProfiles; 78 float[] srcMinVals, srcMaxVals, dstMinVals, dstMaxVals; 79 80 /* the class initializer */ 81 static { 82 if (ProfileDeferralMgr.deferring) { ProfileDeferralMgr.activateProfiles()83 ProfileDeferralMgr.activateProfiles(); 84 } 85 } 86 87 /** 88 * Constructs a new ColorConvertOp which will convert 89 * from a source color space to a destination color space. 90 * The RenderingHints argument may be null. 91 * This Op can be used only with BufferedImages, and will convert 92 * directly from the ColorSpace of the source image to that of the 93 * destination. The destination argument of the filter method 94 * cannot be specified as null. 95 * @param hints the {@code RenderingHints} object used to control 96 * the color conversion, or {@code null} 97 */ ColorConvertOp(RenderingHints hints)98 public ColorConvertOp (RenderingHints hints) 99 { 100 profileList = new ICC_Profile [0]; /* 0 length list */ 101 this.hints = hints; 102 } 103 104 /** 105 * Constructs a new ColorConvertOp from a ColorSpace object. 106 * The RenderingHints argument may be null. This 107 * Op can be used only with BufferedImages, and is primarily useful 108 * when the {@link #filter(BufferedImage, BufferedImage) filter} 109 * method is invoked with a destination argument of null. 110 * In that case, the ColorSpace defines the destination color space 111 * for the destination created by the filter method. Otherwise, the 112 * ColorSpace defines an intermediate space to which the source is 113 * converted before being converted to the destination space. 114 * @param cspace defines the destination {@code ColorSpace} or an 115 * intermediate {@code ColorSpace} 116 * @param hints the {@code RenderingHints} object used to control 117 * the color conversion, or {@code null} 118 * @throws NullPointerException if cspace is null 119 */ ColorConvertOp(ColorSpace cspace, RenderingHints hints)120 public ColorConvertOp (ColorSpace cspace, RenderingHints hints) 121 { 122 if (cspace == null) { 123 throw new NullPointerException("ColorSpace cannot be null"); 124 } 125 if (cspace instanceof ICC_ColorSpace) { 126 profileList = new ICC_Profile [1]; /* 1 profile in the list */ 127 128 profileList [0] = ((ICC_ColorSpace) cspace).getProfile(); 129 } 130 else { 131 CSList = new ColorSpace[1]; /* non-ICC case: 1 ColorSpace in list */ 132 CSList[0] = cspace; 133 } 134 this.hints = hints; 135 } 136 137 138 /** 139 * Constructs a new ColorConvertOp from two ColorSpace objects. 140 * The RenderingHints argument may be null. 141 * This Op is primarily useful for calling the filter method on 142 * Rasters, in which case the two ColorSpaces define the operation 143 * to be performed on the Rasters. In that case, the number of bands 144 * in the source Raster must match the number of components in 145 * srcCspace, and the number of bands in the destination Raster 146 * must match the number of components in dstCspace. For BufferedImages, 147 * the two ColorSpaces define intermediate spaces through which the 148 * source is converted before being converted to the destination space. 149 * @param srcCspace the source {@code ColorSpace} 150 * @param dstCspace the destination {@code ColorSpace} 151 * @param hints the {@code RenderingHints} object used to control 152 * the color conversion, or {@code null} 153 * @throws NullPointerException if either srcCspace or dstCspace is null 154 */ ColorConvertOp(ColorSpace srcCspace, ColorSpace dstCspace, RenderingHints hints)155 public ColorConvertOp(ColorSpace srcCspace, ColorSpace dstCspace, 156 RenderingHints hints) 157 { 158 if ((srcCspace == null) || (dstCspace == null)) { 159 throw new NullPointerException("ColorSpaces cannot be null"); 160 } 161 if ((srcCspace instanceof ICC_ColorSpace) && 162 (dstCspace instanceof ICC_ColorSpace)) { 163 profileList = new ICC_Profile [2]; /* 2 profiles in the list */ 164 165 profileList [0] = ((ICC_ColorSpace) srcCspace).getProfile(); 166 profileList [1] = ((ICC_ColorSpace) dstCspace).getProfile(); 167 168 getMinMaxValsFromColorSpaces(srcCspace, dstCspace); 169 } else { 170 /* non-ICC case: 2 ColorSpaces in list */ 171 CSList = new ColorSpace[2]; 172 CSList[0] = srcCspace; 173 CSList[1] = dstCspace; 174 } 175 this.hints = hints; 176 } 177 178 179 /** 180 * Constructs a new ColorConvertOp from an array of ICC_Profiles. 181 * The RenderingHints argument may be null. 182 * The sequence of profiles may include profiles that represent color 183 * spaces, profiles that represent effects, etc. If the whole sequence 184 * does not represent a well-defined color conversion, an exception is 185 * thrown. 186 * <p>For BufferedImages, if the ColorSpace 187 * of the source BufferedImage does not match the requirements of the 188 * first profile in the array, 189 * the first conversion is to an appropriate ColorSpace. 190 * If the requirements of the last profile in the array are not met 191 * by the ColorSpace of the destination BufferedImage, 192 * the last conversion is to the destination's ColorSpace. 193 * <p>For Rasters, the number of bands in the source Raster must match 194 * the requirements of the first profile in the array, and the 195 * number of bands in the destination Raster must match the requirements 196 * of the last profile in the array. The array must have at least two 197 * elements or calling the filter method for Rasters will throw an 198 * IllegalArgumentException. 199 * @param profiles the array of {@code ICC_Profile} objects 200 * @param hints the {@code RenderingHints} object used to control 201 * the color conversion, or {@code null} 202 * @exception IllegalArgumentException when the profile sequence does not 203 * specify a well-defined color conversion 204 * @exception NullPointerException if profiles is null 205 */ ColorConvertOp(ICC_Profile[] profiles, RenderingHints hints)206 public ColorConvertOp (ICC_Profile[] profiles, RenderingHints hints) 207 { 208 if (profiles == null) { 209 throw new NullPointerException("Profiles cannot be null"); 210 } 211 gotProfiles = true; 212 profileList = new ICC_Profile[profiles.length]; 213 for (int i1 = 0; i1 < profiles.length; i1++) { 214 profileList[i1] = profiles[i1]; 215 } 216 this.hints = hints; 217 } 218 219 220 /** 221 * Returns the array of ICC_Profiles used to construct this ColorConvertOp. 222 * Returns null if the ColorConvertOp was not constructed from such an 223 * array. 224 * @return the array of {@code ICC_Profile} objects of this 225 * {@code ColorConvertOp}, or {@code null} if this 226 * {@code ColorConvertOp} was not constructed with an 227 * array of {@code ICC_Profile} objects. 228 */ getICC_Profiles()229 public final ICC_Profile[] getICC_Profiles() { 230 if (gotProfiles) { 231 ICC_Profile[] profiles = new ICC_Profile[profileList.length]; 232 for (int i1 = 0; i1 < profileList.length; i1++) { 233 profiles[i1] = profileList[i1]; 234 } 235 return profiles; 236 } 237 return null; 238 } 239 240 /** 241 * ColorConverts the source BufferedImage. 242 * If the destination image is null, 243 * a BufferedImage will be created with an appropriate ColorModel. 244 * @param src the source {@code BufferedImage} to be converted 245 * @param dest the destination {@code BufferedImage}, 246 * or {@code null} 247 * @return {@code dest} color converted from {@code src} 248 * or a new, converted {@code BufferedImage} 249 * if {@code dest} is {@code null} 250 * @exception IllegalArgumentException if dest is null and this op was 251 * constructed using the constructor which takes only a 252 * RenderingHints argument, since the operation is ill defined. 253 */ filter(BufferedImage src, BufferedImage dest)254 public final BufferedImage filter(BufferedImage src, BufferedImage dest) { 255 ColorSpace srcColorSpace, destColorSpace; 256 BufferedImage savdest = null; 257 258 if (src.getColorModel() instanceof IndexColorModel) { 259 IndexColorModel icm = (IndexColorModel) src.getColorModel(); 260 src = icm.convertToIntDiscrete(src.getRaster(), true); 261 } 262 srcColorSpace = src.getColorModel().getColorSpace(); 263 if (dest != null) { 264 if (dest.getColorModel() instanceof IndexColorModel) { 265 savdest = dest; 266 dest = null; 267 destColorSpace = null; 268 } else { 269 destColorSpace = dest.getColorModel().getColorSpace(); 270 } 271 } else { 272 destColorSpace = null; 273 } 274 275 if ((CSList != null) || 276 (!(srcColorSpace instanceof ICC_ColorSpace)) || 277 ((dest != null) && 278 (!(destColorSpace instanceof ICC_ColorSpace)))) { 279 /* non-ICC case */ 280 dest = nonICCBIFilter(src, srcColorSpace, dest, destColorSpace); 281 } else { 282 dest = ICCBIFilter(src, srcColorSpace, dest, destColorSpace); 283 } 284 285 if (savdest != null) { 286 Graphics2D big = savdest.createGraphics(); 287 try { 288 big.drawImage(dest, 0, 0, null); 289 } finally { 290 big.dispose(); 291 } 292 return savdest; 293 } else { 294 return dest; 295 } 296 } 297 ICCBIFilter(BufferedImage src, ColorSpace srcColorSpace, BufferedImage dest, ColorSpace destColorSpace)298 private BufferedImage ICCBIFilter(BufferedImage src, 299 ColorSpace srcColorSpace, 300 BufferedImage dest, 301 ColorSpace destColorSpace) { 302 int nProfiles = profileList.length; 303 ICC_Profile srcProfile = null, destProfile = null; 304 305 srcProfile = ((ICC_ColorSpace) srcColorSpace).getProfile(); 306 307 if (dest == null) { /* last profile in the list defines 308 the output color space */ 309 if (nProfiles == 0) { 310 throw new IllegalArgumentException( 311 "Destination ColorSpace is undefined"); 312 } 313 destProfile = profileList [nProfiles - 1]; 314 dest = createCompatibleDestImage(src, null); 315 } 316 else { 317 if (src.getHeight() != dest.getHeight() || 318 src.getWidth() != dest.getWidth()) { 319 throw new IllegalArgumentException( 320 "Width or height of BufferedImages do not match"); 321 } 322 destProfile = ((ICC_ColorSpace) destColorSpace).getProfile(); 323 } 324 325 /* Checking if all profiles in the transform sequence are the same. 326 * If so, performing just copying the data. 327 */ 328 if (srcProfile == destProfile) { 329 boolean noTrans = true; 330 for (int i = 0; i < nProfiles; i++) { 331 if (srcProfile != profileList[i]) { 332 noTrans = false; 333 break; 334 } 335 } 336 if (noTrans) { 337 Graphics2D g = dest.createGraphics(); 338 try { 339 g.drawImage(src, 0, 0, null); 340 } finally { 341 g.dispose(); 342 } 343 344 return dest; 345 } 346 } 347 348 /* make a new transform if needed */ 349 if ((thisTransform == null) || (thisSrcProfile != srcProfile) || 350 (thisDestProfile != destProfile) ) { 351 updateBITransform(srcProfile, destProfile); 352 } 353 354 /* color convert the image */ 355 thisTransform.colorConvert(src, dest); 356 357 return dest; 358 } 359 updateBITransform(ICC_Profile srcProfile, ICC_Profile destProfile)360 private void updateBITransform(ICC_Profile srcProfile, 361 ICC_Profile destProfile) { 362 ICC_Profile[] theProfiles; 363 int i1, nProfiles, nTransforms, whichTrans, renderState; 364 ColorTransform[] theTransforms; 365 boolean useSrc = false, useDest = false; 366 367 nProfiles = profileList.length; 368 nTransforms = nProfiles; 369 if ((nProfiles == 0) || (srcProfile != profileList[0])) { 370 nTransforms += 1; 371 useSrc = true; 372 } 373 if ((nProfiles == 0) || (destProfile != profileList[nProfiles - 1]) || 374 (nTransforms < 2)) { 375 nTransforms += 1; 376 useDest = true; 377 } 378 379 /* make the profile list */ 380 theProfiles = new ICC_Profile[nTransforms]; /* the list of profiles 381 for this Op */ 382 383 int idx = 0; 384 if (useSrc) { 385 /* insert source as first profile */ 386 theProfiles[idx++] = srcProfile; 387 } 388 389 for (i1 = 0; i1 < nProfiles; i1++) { 390 /* insert profiles defined in this Op */ 391 theProfiles[idx++] = profileList [i1]; 392 } 393 394 if (useDest) { 395 /* insert dest as last profile */ 396 theProfiles[idx] = destProfile; 397 } 398 399 /* make the transform list */ 400 theTransforms = new ColorTransform [nTransforms]; 401 402 /* initialize transform get loop */ 403 if (theProfiles[0].getProfileClass() == ICC_Profile.CLASS_OUTPUT) { 404 /* if first profile is a printer 405 render as colorimetric */ 406 renderState = ICC_Profile.icRelativeColorimetric; 407 } 408 else { 409 renderState = ICC_Profile.icPerceptual; /* render any other 410 class perceptually */ 411 } 412 413 whichTrans = ColorTransform.In; 414 415 PCMM mdl = CMSManager.getModule(); 416 417 /* get the transforms from each profile */ 418 for (i1 = 0; i1 < nTransforms; i1++) { 419 if (i1 == nTransforms -1) { /* last profile? */ 420 whichTrans = ColorTransform.Out; /* get output transform */ 421 } 422 else { /* check for abstract profile */ 423 if ((whichTrans == ColorTransform.Simulation) && 424 (theProfiles[i1].getProfileClass () == 425 ICC_Profile.CLASS_ABSTRACT)) { 426 renderState = ICC_Profile.icPerceptual; 427 whichTrans = ColorTransform.In; 428 } 429 } 430 431 theTransforms[i1] = mdl.createTransform ( 432 theProfiles[i1], renderState, whichTrans); 433 434 /* get this profile's rendering intent to select transform 435 from next profile */ 436 renderState = getRenderingIntent(theProfiles[i1]); 437 438 /* "middle" profiles use simulation transform */ 439 whichTrans = ColorTransform.Simulation; 440 } 441 442 /* make the net transform */ 443 thisTransform = mdl.createTransform(theTransforms); 444 445 /* update corresponding source and dest profiles */ 446 thisSrcProfile = srcProfile; 447 thisDestProfile = destProfile; 448 } 449 450 /** 451 * ColorConverts the image data in the source Raster. 452 * If the destination Raster is null, a new Raster will be created. 453 * The number of bands in the source and destination Rasters must 454 * meet the requirements explained above. The constructor used to 455 * create this ColorConvertOp must have provided enough information 456 * to define both source and destination color spaces. See above. 457 * Otherwise, an exception is thrown. 458 * @param src the source {@code Raster} to be converted 459 * @param dest the destination {@code WritableRaster}, 460 * or {@code null} 461 * @return {@code dest} color converted from {@code src} 462 * or a new, converted {@code WritableRaster} 463 * if {@code dest} is {@code null} 464 * @exception IllegalArgumentException if the number of source or 465 * destination bands is incorrect, the source or destination 466 * color spaces are undefined, or this op was constructed 467 * with one of the constructors that applies only to 468 * operations on BufferedImages. 469 */ filter(Raster src, WritableRaster dest)470 public final WritableRaster filter (Raster src, WritableRaster dest) { 471 472 if (CSList != null) { 473 /* non-ICC case */ 474 return nonICCRasterFilter(src, dest); 475 } 476 int nProfiles = profileList.length; 477 if (nProfiles < 2) { 478 throw new IllegalArgumentException( 479 "Source or Destination ColorSpace is undefined"); 480 } 481 if (src.getNumBands() != profileList[0].getNumComponents()) { 482 throw new IllegalArgumentException( 483 "Numbers of source Raster bands and source color space " + 484 "components do not match"); 485 } 486 if (dest == null) { 487 dest = createCompatibleDestRaster(src); 488 } 489 else { 490 if (src.getHeight() != dest.getHeight() || 491 src.getWidth() != dest.getWidth()) { 492 throw new IllegalArgumentException( 493 "Width or height of Rasters do not match"); 494 } 495 if (dest.getNumBands() != 496 profileList[nProfiles-1].getNumComponents()) { 497 throw new IllegalArgumentException( 498 "Numbers of destination Raster bands and destination " + 499 "color space components do not match"); 500 } 501 } 502 503 /* make a new transform if needed */ 504 if (thisRasterTransform == null) { 505 int i1, whichTrans, renderState; 506 ColorTransform[] theTransforms; 507 508 /* make the transform list */ 509 theTransforms = new ColorTransform [nProfiles]; 510 511 /* initialize transform get loop */ 512 if (profileList[0].getProfileClass() == ICC_Profile.CLASS_OUTPUT) { 513 /* if first profile is a printer 514 render as colorimetric */ 515 renderState = ICC_Profile.icRelativeColorimetric; 516 } 517 else { 518 renderState = ICC_Profile.icPerceptual; /* render any other 519 class perceptually */ 520 } 521 522 whichTrans = ColorTransform.In; 523 524 PCMM mdl = CMSManager.getModule(); 525 526 /* get the transforms from each profile */ 527 for (i1 = 0; i1 < nProfiles; i1++) { 528 if (i1 == nProfiles -1) { /* last profile? */ 529 whichTrans = ColorTransform.Out; /* get output transform */ 530 } 531 else { /* check for abstract profile */ 532 if ((whichTrans == ColorTransform.Simulation) && 533 (profileList[i1].getProfileClass () == 534 ICC_Profile.CLASS_ABSTRACT)) { 535 renderState = ICC_Profile.icPerceptual; 536 whichTrans = ColorTransform.In; 537 } 538 } 539 540 theTransforms[i1] = mdl.createTransform ( 541 profileList[i1], renderState, whichTrans); 542 543 /* get this profile's rendering intent to select transform 544 from next profile */ 545 renderState = getRenderingIntent(profileList[i1]); 546 547 /* "middle" profiles use simulation transform */ 548 whichTrans = ColorTransform.Simulation; 549 } 550 551 /* make the net transform */ 552 thisRasterTransform = mdl.createTransform(theTransforms); 553 } 554 555 int srcTransferType = src.getTransferType(); 556 int dstTransferType = dest.getTransferType(); 557 if ((srcTransferType == DataBuffer.TYPE_FLOAT) || 558 (srcTransferType == DataBuffer.TYPE_DOUBLE) || 559 (dstTransferType == DataBuffer.TYPE_FLOAT) || 560 (dstTransferType == DataBuffer.TYPE_DOUBLE)) { 561 if (srcMinVals == null) { 562 getMinMaxValsFromProfiles(profileList[0], 563 profileList[nProfiles-1]); 564 } 565 /* color convert the raster */ 566 thisRasterTransform.colorConvert(src, dest, 567 srcMinVals, srcMaxVals, 568 dstMinVals, dstMaxVals); 569 } else { 570 /* color convert the raster */ 571 thisRasterTransform.colorConvert(src, dest); 572 } 573 574 575 return dest; 576 } 577 578 /** 579 * Returns the bounding box of the destination, given this source. 580 * Note that this will be the same as the bounding box of the 581 * source. 582 * @param src the source {@code BufferedImage} 583 * @return a {@code Rectangle2D} that is the bounding box 584 * of the destination, given the specified {@code src} 585 */ getBounds2D(BufferedImage src)586 public final Rectangle2D getBounds2D (BufferedImage src) { 587 return getBounds2D(src.getRaster()); 588 } 589 590 /** 591 * Returns the bounding box of the destination, given this source. 592 * Note that this will be the same as the bounding box of the 593 * source. 594 * @param src the source {@code Raster} 595 * @return a {@code Rectangle2D} that is the bounding box 596 * of the destination, given the specified {@code src} 597 */ getBounds2D(Raster src)598 public final Rectangle2D getBounds2D (Raster src) { 599 /* return new Rectangle (src.getXOffset(), 600 src.getYOffset(), 601 src.getWidth(), src.getHeight()); */ 602 return src.getBounds(); 603 } 604 605 /** 606 * Creates a zeroed destination image with the correct size and number of 607 * bands, given this source. 608 * @param src Source image for the filter operation. 609 * @param destCM ColorModel of the destination. If null, an 610 * appropriate ColorModel will be used. 611 * @return a {@code BufferedImage} with the correct size and 612 * number of bands from the specified {@code src}. 613 * @throws IllegalArgumentException if {@code destCM} is 614 * {@code null} and this {@code ColorConvertOp} was 615 * created without any {@code ICC_Profile} or 616 * {@code ColorSpace} defined for the destination 617 */ createCompatibleDestImage(BufferedImage src, ColorModel destCM)618 public BufferedImage createCompatibleDestImage (BufferedImage src, 619 ColorModel destCM) { 620 ColorSpace cs = null;; 621 if (destCM == null) { 622 if (CSList == null) { 623 /* ICC case */ 624 int nProfiles = profileList.length; 625 if (nProfiles == 0) { 626 throw new IllegalArgumentException( 627 "Destination ColorSpace is undefined"); 628 } 629 ICC_Profile destProfile = profileList[nProfiles - 1]; 630 cs = new ICC_ColorSpace(destProfile); 631 } else { 632 /* non-ICC case */ 633 int nSpaces = CSList.length; 634 cs = CSList[nSpaces - 1]; 635 } 636 } 637 return createCompatibleDestImage(src, destCM, cs); 638 } 639 createCompatibleDestImage(BufferedImage src, ColorModel destCM, ColorSpace destCS)640 private BufferedImage createCompatibleDestImage(BufferedImage src, 641 ColorModel destCM, 642 ColorSpace destCS) { 643 BufferedImage image; 644 if (destCM == null) { 645 ColorModel srcCM = src.getColorModel(); 646 int nbands = destCS.getNumComponents(); 647 boolean hasAlpha = srcCM.hasAlpha(); 648 if (hasAlpha) { 649 nbands += 1; 650 } 651 int[] nbits = new int[nbands]; 652 for (int i = 0; i < nbands; i++) { 653 nbits[i] = 8; 654 } 655 destCM = new ComponentColorModel(destCS, nbits, hasAlpha, 656 srcCM.isAlphaPremultiplied(), 657 srcCM.getTransparency(), 658 DataBuffer.TYPE_BYTE); 659 } 660 int w = src.getWidth(); 661 int h = src.getHeight(); 662 image = new BufferedImage(destCM, 663 destCM.createCompatibleWritableRaster(w, h), 664 destCM.isAlphaPremultiplied(), null); 665 return image; 666 } 667 668 669 /** 670 * Creates a zeroed destination Raster with the correct size and number of 671 * bands, given this source. 672 * @param src the specified {@code Raster} 673 * @return a {@code WritableRaster} with the correct size and number 674 * of bands from the specified {@code src} 675 * @throws IllegalArgumentException if this {@code ColorConvertOp} 676 * was created without sufficient information to define the 677 * {@code dst} and {@code src} color spaces 678 */ createCompatibleDestRaster(Raster src)679 public WritableRaster createCompatibleDestRaster (Raster src) { 680 int ncomponents; 681 682 if (CSList != null) { 683 /* non-ICC case */ 684 if (CSList.length != 2) { 685 throw new IllegalArgumentException( 686 "Destination ColorSpace is undefined"); 687 } 688 ncomponents = CSList[1].getNumComponents(); 689 } else { 690 /* ICC case */ 691 int nProfiles = profileList.length; 692 if (nProfiles < 2) { 693 throw new IllegalArgumentException( 694 "Destination ColorSpace is undefined"); 695 } 696 ncomponents = profileList[nProfiles-1].getNumComponents(); 697 } 698 699 WritableRaster dest = 700 Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE, 701 src.getWidth(), 702 src.getHeight(), 703 ncomponents, 704 new Point(src.getMinX(), src.getMinY())); 705 return dest; 706 } 707 708 /** 709 * Returns the location of the destination point given a 710 * point in the source. If {@code dstPt} is non-null, 711 * it will be used to hold the return value. Note that 712 * for this class, the destination point will be the same 713 * as the source point. 714 * @param srcPt the specified source {@code Point2D} 715 * @param dstPt the destination {@code Point2D} 716 * @return {@code dstPt} after setting its location to be 717 * the same as {@code srcPt} 718 */ getPoint2D(Point2D srcPt, Point2D dstPt)719 public final Point2D getPoint2D (Point2D srcPt, Point2D dstPt) { 720 if (dstPt == null) { 721 dstPt = new Point2D.Float(); 722 } 723 dstPt.setLocation(srcPt.getX(), srcPt.getY()); 724 725 return dstPt; 726 } 727 728 729 /** 730 * Returns the RenderingIntent from the specified ICC Profile. 731 */ getRenderingIntent(ICC_Profile profile)732 private int getRenderingIntent (ICC_Profile profile) { 733 byte[] header = profile.getData(ICC_Profile.icSigHead); 734 int index = ICC_Profile.icHdrRenderingIntent; 735 736 /* According to ICC spec, only the least-significant 16 bits shall be 737 * used to encode the rendering intent. The most significant 16 bits 738 * shall be set to zero. Thus, we are ignoring two most significant 739 * bytes here. 740 * 741 * See http://www.color.org/ICC1v42_2006-05.pdf, section 7.2.15. 742 */ 743 return ((header[index+2] & 0xff) << 8) | 744 (header[index+3] & 0xff); 745 } 746 747 /** 748 * Returns the rendering hints used by this op. 749 * @return the {@code RenderingHints} object of this 750 * {@code ColorConvertOp} 751 */ getRenderingHints()752 public final RenderingHints getRenderingHints() { 753 return hints; 754 } 755 nonICCBIFilter(BufferedImage src, ColorSpace srcColorSpace, BufferedImage dst, ColorSpace dstColorSpace)756 private BufferedImage nonICCBIFilter(BufferedImage src, 757 ColorSpace srcColorSpace, 758 BufferedImage dst, 759 ColorSpace dstColorSpace) { 760 761 int w = src.getWidth(); 762 int h = src.getHeight(); 763 ICC_ColorSpace ciespace = 764 (ICC_ColorSpace) ColorSpace.getInstance(ColorSpace.CS_CIEXYZ); 765 if (dst == null) { 766 dst = createCompatibleDestImage(src, null); 767 dstColorSpace = dst.getColorModel().getColorSpace(); 768 } else { 769 if ((h != dst.getHeight()) || (w != dst.getWidth())) { 770 throw new IllegalArgumentException( 771 "Width or height of BufferedImages do not match"); 772 } 773 } 774 Raster srcRas = src.getRaster(); 775 WritableRaster dstRas = dst.getRaster(); 776 ColorModel srcCM = src.getColorModel(); 777 ColorModel dstCM = dst.getColorModel(); 778 int srcNumComp = srcCM.getNumColorComponents(); 779 int dstNumComp = dstCM.getNumColorComponents(); 780 boolean dstHasAlpha = dstCM.hasAlpha(); 781 boolean needSrcAlpha = srcCM.hasAlpha() && dstHasAlpha; 782 ColorSpace[] list; 783 if ((CSList == null) && (profileList.length != 0)) { 784 /* possible non-ICC src, some profiles, possible non-ICC dst */ 785 boolean nonICCSrc, nonICCDst; 786 ICC_Profile srcProfile, dstProfile; 787 if (!(srcColorSpace instanceof ICC_ColorSpace)) { 788 nonICCSrc = true; 789 srcProfile = ciespace.getProfile(); 790 } else { 791 nonICCSrc = false; 792 srcProfile = ((ICC_ColorSpace) srcColorSpace).getProfile(); 793 } 794 if (!(dstColorSpace instanceof ICC_ColorSpace)) { 795 nonICCDst = true; 796 dstProfile = ciespace.getProfile(); 797 } else { 798 nonICCDst = false; 799 dstProfile = ((ICC_ColorSpace) dstColorSpace).getProfile(); 800 } 801 /* make a new transform if needed */ 802 if ((thisTransform == null) || (thisSrcProfile != srcProfile) || 803 (thisDestProfile != dstProfile) ) { 804 updateBITransform(srcProfile, dstProfile); 805 } 806 // process per scanline 807 float maxNum = 65535.0f; // use 16-bit precision in CMM 808 ColorSpace cs; 809 int iccSrcNumComp; 810 if (nonICCSrc) { 811 cs = ciespace; 812 iccSrcNumComp = 3; 813 } else { 814 cs = srcColorSpace; 815 iccSrcNumComp = srcNumComp; 816 } 817 float[] srcMinVal = new float[iccSrcNumComp]; 818 float[] srcInvDiffMinMax = new float[iccSrcNumComp]; 819 for (int i = 0; i < srcNumComp; i++) { 820 srcMinVal[i] = cs.getMinValue(i); 821 srcInvDiffMinMax[i] = maxNum / (cs.getMaxValue(i) - srcMinVal[i]); 822 } 823 int iccDstNumComp; 824 if (nonICCDst) { 825 cs = ciespace; 826 iccDstNumComp = 3; 827 } else { 828 cs = dstColorSpace; 829 iccDstNumComp = dstNumComp; 830 } 831 float[] dstMinVal = new float[iccDstNumComp]; 832 float[] dstDiffMinMax = new float[iccDstNumComp]; 833 for (int i = 0; i < dstNumComp; i++) { 834 dstMinVal[i] = cs.getMinValue(i); 835 dstDiffMinMax[i] = (cs.getMaxValue(i) - dstMinVal[i]) / maxNum; 836 } 837 float[] dstColor; 838 if (dstHasAlpha) { 839 int size = ((dstNumComp + 1) > 3) ? (dstNumComp + 1) : 3; 840 dstColor = new float[size]; 841 } else { 842 int size = (dstNumComp > 3) ? dstNumComp : 3; 843 dstColor = new float[size]; 844 } 845 short[] srcLine = new short[w * iccSrcNumComp]; 846 short[] dstLine = new short[w * iccDstNumComp]; 847 Object pixel; 848 float[] color; 849 float[] alpha = null; 850 if (needSrcAlpha) { 851 alpha = new float[w]; 852 } 853 int idx; 854 // process each scanline 855 for (int y = 0; y < h; y++) { 856 // convert src scanline 857 pixel = null; 858 color = null; 859 idx = 0; 860 for (int x = 0; x < w; x++) { 861 pixel = srcRas.getDataElements(x, y, pixel); 862 color = srcCM.getNormalizedComponents(pixel, color, 0); 863 if (needSrcAlpha) { 864 alpha[x] = color[srcNumComp]; 865 } 866 if (nonICCSrc) { 867 color = srcColorSpace.toCIEXYZ(color); 868 } 869 for (int i = 0; i < iccSrcNumComp; i++) { 870 srcLine[idx++] = (short) 871 ((color[i] - srcMinVal[i]) * srcInvDiffMinMax[i] + 872 0.5f); 873 } 874 } 875 // color convert srcLine to dstLine 876 thisTransform.colorConvert(srcLine, dstLine); 877 // convert dst scanline 878 pixel = null; 879 idx = 0; 880 for (int x = 0; x < w; x++) { 881 for (int i = 0; i < iccDstNumComp; i++) { 882 dstColor[i] = ((float) (dstLine[idx++] & 0xffff)) * 883 dstDiffMinMax[i] + dstMinVal[i]; 884 } 885 if (nonICCDst) { 886 color = srcColorSpace.fromCIEXYZ(dstColor); 887 for (int i = 0; i < dstNumComp; i++) { 888 dstColor[i] = color[i]; 889 } 890 } 891 if (needSrcAlpha) { 892 dstColor[dstNumComp] = alpha[x]; 893 } else if (dstHasAlpha) { 894 dstColor[dstNumComp] = 1.0f; 895 } 896 pixel = dstCM.getDataElements(dstColor, 0, pixel); 897 dstRas.setDataElements(x, y, pixel); 898 } 899 } 900 } else { 901 /* possible non-ICC src, possible CSList, possible non-ICC dst */ 902 // process per pixel 903 int numCS; 904 if (CSList == null) { 905 numCS = 0; 906 } else { 907 numCS = CSList.length; 908 } 909 float[] dstColor; 910 if (dstHasAlpha) { 911 dstColor = new float[dstNumComp + 1]; 912 } else { 913 dstColor = new float[dstNumComp]; 914 } 915 Object spixel = null; 916 Object dpixel = null; 917 float[] color = null; 918 float[] tmpColor; 919 // process each pixel 920 for (int y = 0; y < h; y++) { 921 for (int x = 0; x < w; x++) { 922 spixel = srcRas.getDataElements(x, y, spixel); 923 color = srcCM.getNormalizedComponents(spixel, color, 0); 924 tmpColor = srcColorSpace.toCIEXYZ(color); 925 for (int i = 0; i < numCS; i++) { 926 tmpColor = CSList[i].fromCIEXYZ(tmpColor); 927 tmpColor = CSList[i].toCIEXYZ(tmpColor); 928 } 929 tmpColor = dstColorSpace.fromCIEXYZ(tmpColor); 930 for (int i = 0; i < dstNumComp; i++) { 931 dstColor[i] = tmpColor[i]; 932 } 933 if (needSrcAlpha) { 934 dstColor[dstNumComp] = color[srcNumComp]; 935 } else if (dstHasAlpha) { 936 dstColor[dstNumComp] = 1.0f; 937 } 938 dpixel = dstCM.getDataElements(dstColor, 0, dpixel); 939 dstRas.setDataElements(x, y, dpixel); 940 941 } 942 } 943 } 944 945 return dst; 946 } 947 948 /* color convert a Raster - handles byte, ushort, int, short, float, 949 or double transferTypes */ nonICCRasterFilter(Raster src, WritableRaster dst)950 private WritableRaster nonICCRasterFilter(Raster src, 951 WritableRaster dst) { 952 953 if (CSList.length != 2) { 954 throw new IllegalArgumentException( 955 "Destination ColorSpace is undefined"); 956 } 957 if (src.getNumBands() != CSList[0].getNumComponents()) { 958 throw new IllegalArgumentException( 959 "Numbers of source Raster bands and source color space " + 960 "components do not match"); 961 } 962 if (dst == null) { 963 dst = createCompatibleDestRaster(src); 964 } else { 965 if (src.getHeight() != dst.getHeight() || 966 src.getWidth() != dst.getWidth()) { 967 throw new IllegalArgumentException( 968 "Width or height of Rasters do not match"); 969 } 970 if (dst.getNumBands() != CSList[1].getNumComponents()) { 971 throw new IllegalArgumentException( 972 "Numbers of destination Raster bands and destination " + 973 "color space components do not match"); 974 } 975 } 976 977 if (srcMinVals == null) { 978 getMinMaxValsFromColorSpaces(CSList[0], CSList[1]); 979 } 980 981 SampleModel srcSM = src.getSampleModel(); 982 SampleModel dstSM = dst.getSampleModel(); 983 boolean srcIsFloat, dstIsFloat; 984 int srcTransferType = src.getTransferType(); 985 int dstTransferType = dst.getTransferType(); 986 if ((srcTransferType == DataBuffer.TYPE_FLOAT) || 987 (srcTransferType == DataBuffer.TYPE_DOUBLE)) { 988 srcIsFloat = true; 989 } else { 990 srcIsFloat = false; 991 } 992 if ((dstTransferType == DataBuffer.TYPE_FLOAT) || 993 (dstTransferType == DataBuffer.TYPE_DOUBLE)) { 994 dstIsFloat = true; 995 } else { 996 dstIsFloat = false; 997 } 998 int w = src.getWidth(); 999 int h = src.getHeight(); 1000 int srcNumBands = src.getNumBands(); 1001 int dstNumBands = dst.getNumBands(); 1002 float[] srcScaleFactor = null; 1003 float[] dstScaleFactor = null; 1004 if (!srcIsFloat) { 1005 srcScaleFactor = new float[srcNumBands]; 1006 for (int i = 0; i < srcNumBands; i++) { 1007 if (srcTransferType == DataBuffer.TYPE_SHORT) { 1008 srcScaleFactor[i] = (srcMaxVals[i] - srcMinVals[i]) / 1009 32767.0f; 1010 } else { 1011 srcScaleFactor[i] = (srcMaxVals[i] - srcMinVals[i]) / 1012 ((float) ((1 << srcSM.getSampleSize(i)) - 1)); 1013 } 1014 } 1015 } 1016 if (!dstIsFloat) { 1017 dstScaleFactor = new float[dstNumBands]; 1018 for (int i = 0; i < dstNumBands; i++) { 1019 if (dstTransferType == DataBuffer.TYPE_SHORT) { 1020 dstScaleFactor[i] = 32767.0f / 1021 (dstMaxVals[i] - dstMinVals[i]); 1022 } else { 1023 dstScaleFactor[i] = 1024 ((float) ((1 << dstSM.getSampleSize(i)) - 1)) / 1025 (dstMaxVals[i] - dstMinVals[i]); 1026 } 1027 } 1028 } 1029 int ys = src.getMinY(); 1030 int yd = dst.getMinY(); 1031 int xs, xd; 1032 float sample; 1033 float[] color = new float[srcNumBands]; 1034 float[] tmpColor; 1035 ColorSpace srcColorSpace = CSList[0]; 1036 ColorSpace dstColorSpace = CSList[1]; 1037 // process each pixel 1038 for (int y = 0; y < h; y++, ys++, yd++) { 1039 // get src scanline 1040 xs = src.getMinX(); 1041 xd = dst.getMinX(); 1042 for (int x = 0; x < w; x++, xs++, xd++) { 1043 for (int i = 0; i < srcNumBands; i++) { 1044 sample = src.getSampleFloat(xs, ys, i); 1045 if (!srcIsFloat) { 1046 sample = sample * srcScaleFactor[i] + srcMinVals[i]; 1047 } 1048 color[i] = sample; 1049 } 1050 tmpColor = srcColorSpace.toCIEXYZ(color); 1051 tmpColor = dstColorSpace.fromCIEXYZ(tmpColor); 1052 for (int i = 0; i < dstNumBands; i++) { 1053 sample = tmpColor[i]; 1054 if (!dstIsFloat) { 1055 sample = (sample - dstMinVals[i]) * dstScaleFactor[i]; 1056 } 1057 dst.setSample(xd, yd, i, sample); 1058 } 1059 } 1060 } 1061 return dst; 1062 } 1063 getMinMaxValsFromProfiles(ICC_Profile srcProfile, ICC_Profile dstProfile)1064 private void getMinMaxValsFromProfiles(ICC_Profile srcProfile, 1065 ICC_Profile dstProfile) { 1066 int type = srcProfile.getColorSpaceType(); 1067 int nc = srcProfile.getNumComponents(); 1068 srcMinVals = new float[nc]; 1069 srcMaxVals = new float[nc]; 1070 setMinMax(type, nc, srcMinVals, srcMaxVals); 1071 type = dstProfile.getColorSpaceType(); 1072 nc = dstProfile.getNumComponents(); 1073 dstMinVals = new float[nc]; 1074 dstMaxVals = new float[nc]; 1075 setMinMax(type, nc, dstMinVals, dstMaxVals); 1076 } 1077 setMinMax(int type, int nc, float[] minVals, float[] maxVals)1078 private void setMinMax(int type, int nc, float[] minVals, float[] maxVals) { 1079 if (type == ColorSpace.TYPE_Lab) { 1080 minVals[0] = 0.0f; // L 1081 maxVals[0] = 100.0f; 1082 minVals[1] = -128.0f; // a 1083 maxVals[1] = 127.0f; 1084 minVals[2] = -128.0f; // b 1085 maxVals[2] = 127.0f; 1086 } else if (type == ColorSpace.TYPE_XYZ) { 1087 minVals[0] = minVals[1] = minVals[2] = 0.0f; // X, Y, Z 1088 maxVals[0] = maxVals[1] = maxVals[2] = 1.0f + (32767.0f/ 32768.0f); 1089 } else { 1090 for (int i = 0; i < nc; i++) { 1091 minVals[i] = 0.0f; 1092 maxVals[i] = 1.0f; 1093 } 1094 } 1095 } 1096 getMinMaxValsFromColorSpaces(ColorSpace srcCspace, ColorSpace dstCspace)1097 private void getMinMaxValsFromColorSpaces(ColorSpace srcCspace, 1098 ColorSpace dstCspace) { 1099 int nc = srcCspace.getNumComponents(); 1100 srcMinVals = new float[nc]; 1101 srcMaxVals = new float[nc]; 1102 for (int i = 0; i < nc; i++) { 1103 srcMinVals[i] = srcCspace.getMinValue(i); 1104 srcMaxVals[i] = srcCspace.getMaxValue(i); 1105 } 1106 nc = dstCspace.getNumComponents(); 1107 dstMinVals = new float[nc]; 1108 dstMaxVals = new float[nc]; 1109 for (int i = 0; i < nc; i++) { 1110 dstMinVals[i] = dstCspace.getMinValue(i); 1111 dstMaxVals[i] = dstCspace.getMaxValue(i); 1112 } 1113 } 1114 1115 } 1116