Java > Open Source Codes > java > awt > image > ColorConvertOp


1 /*
2  * @(#)ColorConvertOp.java 1.38 03/12/19
3  *
4  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
5  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
6  */
7
8 /**********************************************************************
9  **********************************************************************
10  **********************************************************************
11  *** COPYRIGHT (c) Eastman Kodak Company, 1997 ***
12  *** As an unpublished work pursuant to Title 17 of the United ***
13  *** States Code. All rights reserved. ***
14  **********************************************************************
15  **********************************************************************
16  **********************************************************************/
17
18 package java.awt.image;
19
20 import java.awt.Point ;
21 import java.awt.Graphics2D ;
22 import java.awt.color.*;
23 import sun.awt.color.ICC_Transform;
24 import sun.awt.color.ProfileDeferralMgr;
25 import java.awt.geom.Rectangle2D ;
26 import java.awt.geom.Point2D ;
27 import java.awt.RenderingHints ;
28
29 /**
30  * This class performs a pixel-by-pixel color conversion of the data in
31  * the source image. The resulting color values are scaled to the precision
32  * of the destination image. Color conversion can be specified
33  * via an array of ColorSpace objects or an array of ICC_Profile objects.
34  * <p>
35  * If the source is a BufferedImage with premultiplied alpha, the
36  * color components are divided by the alpha component before color conversion.
37  * If the destination is a BufferedImage with premultiplied alpha, the
38  * color components are multiplied by the alpha component after conversion.
39  * Rasters are treated as having no alpha channel, i.e. all bands are
40  * color bands.
41  * <p>
42  * If a RenderingHints object is specified in the constructor, the
43  * color rendering hint and the dithering hint may be used to control
44  * color conversion.
45  * <p>
46  * Note that Source and Destination may be the same object.
47  * <p>
48  * @see java.awt.RenderingHints#KEY_COLOR_RENDERING
49  * @see java.awt.RenderingHints#KEY_DITHERING
50  */
51 public class ColorConvertOp implements BufferedImageOp , RasterOp {
52     ICC_Profile[] profileList;
53     ColorSpace[] CSList;
54     ICC_Transform thisTransform, thisRasterTransform;
55     ICC_Profile thisSrcProfile, thisDestProfile;
56     RenderingHints hints;
57     boolean gotProfiles;
58     float[] srcMinVals, srcMaxVals, dstMinVals, dstMaxVals;
59
60     /* the class initializer */
61     static {
62         if (ProfileDeferralMgr.deferring) {
63             ProfileDeferralMgr.activateProfiles();
64         }
65     }
66
67     /**
68      * Constructs a new ColorConvertOp which will convert
69      * from a source color space to a destination color space.
70      * The RenderingHints argument may be null.
71      * This Op can be used only with BufferedImages, and will convert
72      * directly from the ColorSpace of the source image to that of the
73      * destination. The destination argument of the filter method
74      * cannot be specified as null.
75      * @param hints the <code>RenderingHints</code> object used to control
76      * the color conversion, or <code>null</code>
77      */
78     public ColorConvertOp (RenderingHints hints)
79     {
80         profileList = new ICC_Profile [0]; /* 0 length list */
81         this.hints = hints;
82     }
83
84     /**
85      * Constructs a new ColorConvertOp from a ColorSpace object.
86      * The RenderingHints argument may be null. This
87      * Op can be used only with BufferedImages, and is primarily useful
88      * when the {@link #filter(BufferedImage, BufferedImage) filter}
89      * method is invoked with a destination argument of null.
90      * In that case, the ColorSpace defines the destination color space
91      * for the destination created by the filter method. Otherwise, the
92      * ColorSpace defines an intermediate space to which the source is
93      * converted before being converted to the destination space.
94      * @param cspace defines the destination <code>ColorSpace</code> or an
95      * intermediate <code>ColorSpace</code>
96      * @param hints the <code>RenderingHints</code> object used to control
97      * the color conversion, or <code>null</code>
98      * @throws NullPointerException if cspace is null
99      */
100     public ColorConvertOp (ColorSpace cspace, RenderingHints hints)
101     {
102         if (cspace == null) {
103             throw new NullPointerException ("ColorSpace cannot be null");
104         }
105         if (cspace instanceof ICC_ColorSpace) {
106             profileList = new ICC_Profile [1]; /* 1 profile in the list */
107
108             profileList [0] = ((ICC_ColorSpace) cspace).getProfile();
109         }
110         else {
111             CSList = new ColorSpace[1]; /* non-ICC case: 1 ColorSpace in list */
112             CSList[0] = cspace;
113         }
114         this.hints = hints;
115     }
116
117
118     /**
119      * Constructs a new ColorConvertOp from two ColorSpace objects.
120      * The RenderingHints argument may be null.
121      * This Op is primarily useful for calling the filter method on
122      * Rasters, in which case the two ColorSpaces define the operation
123      * to be performed on the Rasters. In that case, the number of bands
124      * in the source Raster must match the number of components in
125      * srcCspace, and the number of bands in the destination Raster
126      * must match the number of components in dstCspace. For BufferedImages,
127      * the two ColorSpaces define intermediate spaces through which the
128      * source is converted before being converted to the destination space.
129      * @param srcCspace the source <code>ColorSpace</code>
130      * @param dstCspace the destination <code>ColorSpace</code>
131      * @param hints the <code>RenderingHints</code> object used to control
132      * the color conversion, or <code>null</code>
133      * @throws NullPointerException if either srcCspace or dstCspace is null
134      */
135     public ColorConvertOp(ColorSpace srcCspace, ColorSpace dstCspace,
136                            RenderingHints hints)
137     {
138         if ((srcCspace == null) || (dstCspace == null)) {
139             throw new NullPointerException ("ColorSpaces cannot be null");
140         }
141         if ((srcCspace instanceof ICC_ColorSpace) &&
142             (dstCspace instanceof ICC_ColorSpace)) {
143             profileList = new ICC_Profile [2]; /* 2 profiles in the list */
144
145             profileList [0] = ((ICC_ColorSpace) srcCspace).getProfile();
146             profileList [1] = ((ICC_ColorSpace) dstCspace).getProfile();
147
148             getMinMaxValsFromColorSpaces(srcCspace, dstCspace);
149         } else {
150             /* non-ICC case: 2 ColorSpaces in list */
151             CSList = new ColorSpace[2];
152             CSList[0] = srcCspace;
153             CSList[1] = dstCspace;
154         }
155         this.hints = hints;
156     }
157
158
159      /**
160      * Constructs a new ColorConvertOp from an array of ICC_Profiles.
161      * The RenderingHints argument may be null.
162      * The sequence of profiles may include profiles that represent color
163      * spaces, profiles that represent effects, etc. If the whole sequence
164      * does not represent a well-defined color conversion, an exception is
165      * thrown.
166      * <p>For BufferedImages, if the ColorSpace
167      * of the source BufferedImage does not match the requirements of the
168      * first profile in the array,
169      * the first conversion is to an appropriate ColorSpace.
170      * If the requirements of the last profile in the array are not met
171      * by the ColorSpace of the destination BufferedImage,
172      * the last conversion is to the destination's ColorSpace.
173      * <p>For Rasters, the number of bands in the source Raster must match
174      * the requirements of the first profile in the array, and the
175      * number of bands in the destination Raster must match the requirements
176      * of the last profile in the array. The array must have at least two
177      * elements or calling the filter method for Rasters will throw an
178      * IllegalArgumentException.
179      * @param profiles the array of <code>ICC_Profile</code> objects
180      * @param hints the <code>RenderingHints</code> object used to control
181      * the color conversion, or <code>null</code>
182      * @exception IllegalArgumentException when the profile sequence does not
183      * specify a well-defined color conversion
184      * @exception NullPointerException if profiles is null
185      */
186     public ColorConvertOp (ICC_Profile[] profiles, RenderingHints hints)
187     {
188         if (profiles == null) {
189             throw new NullPointerException ("Profiles cannot be null");
190         }
191         gotProfiles = true;
192         profileList = new ICC_Profile[profiles.length];
193         for (int i1 = 0; i1 < profiles.length; i1++) {
194         profileList[i1] = profiles[i1];
195     }
196         this.hints = hints;
197     }
198
199
200     /**
201      * Returns the array of ICC_Profiles used to construct this ColorConvertOp.
202      * Returns null if the ColorConvertOp was not constructed from such an
203      * array.
204      * @return the array of <code>ICC_Profile</code> objects of this
205      * <code>ColorConvertOp</code>, or <code>null</code> if this
206      * <code>ColorConvertOp</code> was not constructed with an
207      * array of <code>ICC_Profile</code> objects.
208      */
209     public final ICC_Profile[] getICC_Profiles() {
210         if (gotProfiles) {
211             ICC_Profile[] profiles = new ICC_Profile[profileList.length];
212             for (int i1 = 0; i1 < profileList.length; i1++) {
213                 profiles[i1] = profileList[i1];
214             }
215             return profiles;
216         }
217         return null;
218     }
219
220     /**
221      * ColorConverts the source BufferedImage.
222      * If the destination image is null,
223      * a BufferedImage will be created with an appropriate ColorModel.
224      * @param src the source <code>BufferedImage</code> to be converted
225      * @param dest the destination <code>BufferedImage</code>,
226      * or <code>null</code>
227      * @return <code>dest</code> color converted from <code>src</code>
228      * or a new, converted <code>BufferedImage</code>
229      * if <code>dest</code> is <code>null</code>
230      * @exception IllegalArgumentException if dest is null and this op was
231      * constructed using the constructor which takes only a
232      * RenderingHints argument, since the operation is ill defined.
233      */
234     public final BufferedImage filter(BufferedImage src, BufferedImage dest) {
235         ColorSpace srcColorSpace, destColorSpace;
236         BufferedImage savdest = null;
237
238         if (src.getColorModel() instanceof IndexColorModel ) {
239             IndexColorModel icm = (IndexColorModel ) src.getColorModel();
240             src = icm.convertToIntDiscrete(src.getRaster(), true);
241         }
242         srcColorSpace = src.getColorModel().getColorSpace();
243         if (dest != null) {
244             if (dest.getColorModel() instanceof IndexColorModel ) {
245                 savdest = dest;
246                 dest = null;
247                 destColorSpace = null;
248             } else {
249                 destColorSpace = dest.getColorModel().getColorSpace();
250             }
251         } else {
252             destColorSpace = null;
253         }
254
255         if ((CSList != null) ||
256             (!(srcColorSpace instanceof ICC_ColorSpace)) ||
257             ((dest != null) &&
258              (!(destColorSpace instanceof ICC_ColorSpace)))) {
259             /* non-ICC case */
260             dest = nonICCBIFilter(src, srcColorSpace, dest, destColorSpace);
261         } else {
262             dest = ICCBIFilter(src, srcColorSpace, dest, destColorSpace);
263         }
264
265         if (savdest != null) {
266             Graphics2D big = savdest.createGraphics();
267         try {
268             big.drawImage(dest, 0, 0, null);
269         } finally {
270             big.dispose();
271         }
272             return savdest;
273         } else {
274             return dest;
275         }
276     }
277
278     private final BufferedImage ICCBIFilter(BufferedImage src,
279                                             ColorSpace srcColorSpace,
280                                             BufferedImage dest,
281                                             ColorSpace destColorSpace) {
282     int nProfiles = profileList.length;
283     ICC_Profile srcProfile = null, destProfile = null;
284
285         srcProfile = ((ICC_ColorSpace) srcColorSpace).getProfile();
286
287         if (dest == null) { /* last profile in the list defines
288                                       the output color space */
289             if (nProfiles == 0) {
290                 throw new IllegalArgumentException (
291                     "Destination ColorSpace is undefined");
292             }
293             destProfile = profileList [nProfiles - 1];
294             dest = createCompatibleDestImage(src, null);
295         }
296         else {
297             if (src.getHeight() != dest.getHeight() ||
298                 src.getWidth() != dest.getWidth()) {
299                 throw new IllegalArgumentException (
300                     "Width or height of BufferedImages do not match");
301             }
302             destProfile = ((ICC_ColorSpace) destColorSpace).getProfile();
303         }
304
305         /* make a new transform if needed */
306         if ((thisTransform == null) || (thisSrcProfile != srcProfile) ||
307             (thisDestProfile != destProfile) ) {
308             updateBITransform(srcProfile, destProfile);
309         }
310
311         /* color convert the image */
312         thisTransform.colorConvert(src, dest);
313
314         return dest;
315     }
316
317     private void updateBITransform(ICC_Profile srcProfile,
318                                    ICC_Profile destProfile) {
319         ICC_Profile[] theProfiles;
320         int i1, nProfiles, nTransforms, whichTrans, renderState;
321         ICC_Transform[] theTransforms;
322         boolean useSrc = false, useDest = false;
323
324         nProfiles = profileList.length;
325         nTransforms = nProfiles;
326         if ((nProfiles == 0) || (srcProfile != profileList[0])) {
327             nTransforms += 1;
328             useSrc = true;
329         }
330         if ((nProfiles == 0) || (destProfile != profileList[nProfiles - 1]) ||
331             (nTransforms < 2)) {
332             nTransforms += 1;
333             useDest = true;
334         }
335
336         /* make the profile list */
337         theProfiles = new ICC_Profile[nTransforms]; /* the list of profiles
338                                                        for this Op */
339
340         int idx = 0;
341         if (useSrc) {
342             /* insert source as first profile */
343             theProfiles[idx++] = srcProfile;
344         }
345
346         for (i1 = 0; i1 < nProfiles; i1++) {
347                                    /* insert profiles defined in this Op */
348             theProfiles[idx++] = profileList [i1];
349         }
350
351         if (useDest) {
352             /* insert dest as last profile */
353             theProfiles[idx] = destProfile;
354         }
355
356         /* make the transform list */
357         theTransforms = new ICC_Transform [nTransforms];
358
359         /* initialize transform get loop */
360         if (theProfiles[0].getProfileClass() == ICC_Profile.CLASS_OUTPUT) {
361                                         /* if first profile is a printer
362                                            render as colorimetric */
363             renderState = ICC_Profile.icRelativeColorimetric;
364         }
365         else {
366             renderState = ICC_Profile.icPerceptual; /* render any other
367                                                        class perceptually */
368         }
369
370         whichTrans = ICC_Transform.In;
371
372         /* get the transforms from each profile */
373         for (i1 = 0; i1 < nTransforms; i1++) {
374             if (i1 == nTransforms -1) { /* last profile? */
375                 whichTrans = ICC_Transform.Out; /* get output transform */
376             }
377             else { /* check for abstract profile */
378                 if ((whichTrans == ICC_Transform.Simulation) &&
379                     (theProfiles[i1].getProfileClass () ==
380                      ICC_Profile.CLASS_ABSTRACT)) {
381                 renderState = ICC_Profile.icPerceptual;
382                     whichTrans = ICC_Transform.In;
383                 }
384             }
385
386             theTransforms[i1] = new ICC_Transform (theProfiles[i1],
387                                                    renderState, whichTrans);
388
389             /* get this profile's rendering intent to select transform
390                from next profile */
391             renderState = getRenderingIntent(theProfiles[i1]);
392
393             /* "middle" profiles use simulation transform */
394             whichTrans = ICC_Transform.Simulation;
395         }
396
397         /* make the net transform */
398         thisTransform = new ICC_Transform (theTransforms);
399
400         /* update corresponding source and dest profiles */
401         thisSrcProfile = srcProfile;
402         thisDestProfile = destProfile;
403     }
404
405     /**
406      * ColorConverts the image data in the source Raster.
407      * If the destination Raster is null, a new Raster will be created.
408      * The number of bands in the source and destination Rasters must
409      * meet the requirements explained above. The constructor used to
410      * create this ColorConvertOp must have provided enough information
411      * to define both source and destination color spaces. See above.
412      * Otherwise, an exception is thrown.
413      * @param src the source <code>Raster</code> to be converted
414      * @param dest the destination <code>WritableRaster</code>,
415      * or <code>null</code>
416      * @return <code>dest</code> color converted from <code>src</code>
417      * or a new, converted <code>WritableRaster</code>
418      * if <code>dest</code> is <code>null</code>
419      * @exception IllegalArgumentException if the number of source or
420      * destination bands is incorrect, the source or destination
421      * color spaces are undefined, or this op was constructed
422      * with one of the constructors that applies only to
423      * operations on BufferedImages.
424      */
425     public final WritableRaster filter (Raster src, WritableRaster dest) {
426
427         if (CSList != null) {
428             /* non-ICC case */
429             return nonICCRasterFilter(src, dest);
430         }
431         int nProfiles = profileList.length;
432         if (nProfiles < 2) {
433             throw new IllegalArgumentException (
434                 "Source or Destination ColorSpace is undefined");
435         }
436         if (src.getNumBands() != profileList[0].getNumComponents()) {
437             throw new IllegalArgumentException (
438                 "Numbers of source Raster bands and source color space " +
439                 "components do not match");
440         }
441         if (dest == null) {
442             dest = createCompatibleDestRaster(src);
443         }
444         else {
445             if (src.getHeight() != dest.getHeight() ||
446                 src.getWidth() != dest.getWidth()) {
447                 throw new IllegalArgumentException (
448                     "Width or height of Rasters do not match");
449             }
450             if (dest.getNumBands() !=
451                 profileList[nProfiles-1].getNumComponents()) {
452                 throw new IllegalArgumentException (
453                     "Numbers of destination Raster bands and destination " +
454                     "color space components do not match");
455             }
456         }
457
458         /* make a new transform if needed */
459         if (thisRasterTransform == null) {
460             int i1, whichTrans, renderState;
461             ICC_Transform[] theTransforms;
462
463             /* make the transform list */
464             theTransforms = new ICC_Transform [nProfiles];
465
466             /* initialize transform get loop */
467             if (profileList[0].getProfileClass() == ICC_Profile.CLASS_OUTPUT) {
468                                             /* if first profile is a printer
469                                                render as colorimetric */
470                 renderState = ICC_Profile.icRelativeColorimetric;
471             }
472             else {
473                 renderState = ICC_Profile.icPerceptual; /* render any other
474                                                            class perceptually */
475             }
476
477             whichTrans = ICC_Transform.In;
478
479             /* get the transforms from each profile */
480             for (i1 = 0; i1 < nProfiles; i1++) {
481                 if (i1 == nProfiles -1) { /* last profile? */
482                     whichTrans = ICC_Transform.Out; /* get output transform */
483                 }
484                 else { /* check for abstract profile */
485                     if ((whichTrans == ICC_Transform.Simulation) &&
486                         (profileList[i1].getProfileClass () ==
487                          ICC_Profile.CLASS_ABSTRACT)) {
488                     renderState = ICC_Profile.icPerceptual;
489                         whichTrans = ICC_Transform.In;
490                     }
491                 }
492
493                 theTransforms[i1] = new ICC_Transform (profileList[i1],
494                                                        renderState, whichTrans);
495
496                 /* get this profile's rendering intent to select transform
497                    from next profile */
498                 renderState = getRenderingIntent(profileList[i1]);
499
500                 /* "middle" profiles use simulation transform */
501                 whichTrans = ICC_Transform.Simulation;
502             }
503
504             /* make the net transform */
505             thisRasterTransform = new ICC_Transform (theTransforms);
506         }
507
508         int srcTransferType = src.getTransferType();
509         int dstTransferType = dest.getTransferType();
510         if ((srcTransferType == DataBuffer.TYPE_FLOAT) ||
511             (srcTransferType == DataBuffer.TYPE_DOUBLE) ||
512             (dstTransferType == DataBuffer.TYPE_FLOAT) ||
513             (dstTransferType == DataBuffer.TYPE_DOUBLE)) {
514             if (srcMinVals == null) {
515                 getMinMaxValsFromProfiles(profileList[0],
516                                           profileList[nProfiles-1]);
517             }
518             /* color convert the raster */
519             thisRasterTransform.colorConvert(src, dest,
520                                              srcMinVals, srcMaxVals,
521                                              dstMinVals, dstMaxVals);
522         } else {
523             /* color convert the raster */
524             thisRasterTransform.colorConvert(src, dest);
525         }
526
527
528         return dest;
529     }
530
531     /**
532      * Returns the bounding box of the destination, given this source.
533      * Note that this will be the same as the the bounding box of the
534      * source.
535      * @param src the source <code>BufferedImage</code>
536      * @return a <code>Rectangle2D</code> that is the bounding box
537      * of the destination, given the specified <code>src</code>
538      */
539     public final Rectangle2D getBounds2D (BufferedImage src) {
540         return getBounds2D(src.getRaster());
541     }
542
543     /**
544      * Returns the bounding box of the destination, given this source.
545      * Note that this will be the same as the the bounding box of the
546      * source.
547      * @param src the source <code>Raster</code>
548      * @return a <code>Rectangle2D</code> that is the bounding box
549      * of the destination, given the specified <code>src</code>
550      */
551     public final Rectangle2D getBounds2D (Raster src) {
552         /* return new Rectangle (src.getXOffset(),
553                               src.getYOffset(),
554                               src.getWidth(), src.getHeight()); */
555         return src.getBounds();
556     }
557
558     /**
559      * Creates a zeroed destination image with the correct size and number of
560      * bands, given this source.
561      * @param src Source image for the filter operation.
562      * @param destCM ColorModel of the destination. If null, an
563      * appropriate ColorModel will be used.
564      * @return a <code>BufferedImage</code> with the correct size and
565      * number of bands from the specified <code>src</code>.
566      * @throws IllegalArgumentException if <code>destCM</code> is
567      * <code>null</code> and this <code>ColorConvertOp</code> was
568      * created without any <code>ICC_Profile</code> or
569      * <code>ColorSpace</code> defined for the destination
570      */
571     public BufferedImage createCompatibleDestImage (BufferedImage src,
572                                                     ColorModel destCM) {
573         ColorSpace cs = null;;
574         if (destCM == null) {
575             if (CSList == null) {
576                 /* ICC case */
577                 int nProfiles = profileList.length;
578                 if (nProfiles == 0) {
579                     throw new IllegalArgumentException (
580                         "Destination ColorSpace is undefined");
581                 }
582                 ICC_Profile destProfile = profileList[nProfiles - 1];
583                 cs = new ICC_ColorSpace(destProfile);
584             } else {
585                 /* non-ICC case */
586                 int nSpaces = CSList.length;
587                 cs = CSList[nSpaces - 1];
588             }
589         }
590         return createCompatibleDestImage(src, destCM, cs);
591     }
592
593     private BufferedImage createCompatibleDestImage(BufferedImage src,
594                                                     ColorModel destCM,
595                                                     ColorSpace destCS) {
596         BufferedImage image;
597         if (destCM == null) {
598             ColorModel srcCM = src.getColorModel();
599             int nbands = destCS.getNumComponents();
600             boolean hasAlpha = srcCM.hasAlpha();
601             if (hasAlpha) {
602                nbands += 1;
603             }
604             int[] nbits = new int[nbands];
605             for (int i = 0; i < nbands; i++) {
606                 nbits[i] = 8;
607             }
608             destCM = new ComponentColorModel (destCS, nbits, hasAlpha,
609                                              srcCM.isAlphaPremultiplied(),
610                                              srcCM.getTransparency(),
611                                              DataBuffer.TYPE_BYTE);
612         }
613         int w = src.getWidth();
614         int h = src.getHeight();
615         image = new BufferedImage (destCM,
616                                   destCM.createCompatibleWritableRaster(w, h),
617                                   destCM.isAlphaPremultiplied(), null);
618         return image;
619     }
620
621
622     /**
623      * Creates a zeroed destination Raster with the correct size and number of
624      * bands, given this source.
625      * @param src the specified <code>Raster</code>
626      * @return a <code>WritableRaster</code> with the correct size and number
627      * of bands from the specified <code>src</code>
628      * @throws IllegalArgumentException if this <code>ColorConvertOp</code>
629      * was created without sufficient information to define the
630      * <code>dst</code> and <code>src</code> color spaces
631      */
632     public WritableRaster createCompatibleDestRaster (Raster src) {
633         int ncomponents;
634
635         if (CSList != null) {
636             /* non-ICC case */
637             if (CSList.length != 2) {
638                 throw new IllegalArgumentException (
639                     "Destination ColorSpace is undefined");
640             }
641             ncomponents = CSList[1].getNumComponents();
642         } else {
643             /* ICC case */
644             int nProfiles = profileList.length;
645             if (nProfiles < 2) {
646                 throw new IllegalArgumentException (
647                     "Destination ColorSpace is undefined");
648             }
649             ncomponents = profileList[nProfiles-1].getNumComponents();
650         }
651
652         WritableRaster dest =
653             Raster.createInterleavedRaster(DataBuffer.TYPE_BYTE,
654                                   src.getWidth(),
655                                   src.getHeight(),
656                                   ncomponents,
657                                   new Point (src.getMinX(), src.getMinY()));
658         return dest;
659     }
660
661     /**
662      * Returns the location of the destination point given a
663      * point in the source. If <code>dstPt</code> is non-null,
664      * it will be used to hold the return value. Note that
665      * for this class, the destination point will be the same
666      * as the source point.
667      * @param srcPt the specified source <code>Point2D</code>
668      * @param dstPt the destination <code>Point2D</code>
669      * @return <code>dstPt</code> after setting its location to be
670      * the same as <code>srcPt</code>
671      */
672     public final Point2D getPoint2D (Point2D srcPt, Point2D dstPt) {
673         if (dstPt == null) {
674             dstPt = new Point2D.Float ();
675         }
676         dstPt.setLocation(srcPt.getX(), srcPt.getY());
677
678         return dstPt;
679     }
680
681
682     /**
683      * Returns the RenderingIntent from the specified ICC Profile.
684      */
685     private int getRenderingIntent (ICC_Profile profile) {
686         byte[] header = profile.getData(ICC_Profile.icSigHead);
687         int index = ICC_Profile.icHdrRenderingIntent;
688         return (((header[index] & 0xff) << 24) |
689                 ((header[index+1] & 0xff) << 16) |
690                 ((header[index+2] & 0xff) << 8) |
691                  (header[index+3] & 0xff));
692     }
693
694     /**
695      * Returns the rendering hints used by this op.
696      * @return the <code>RenderingHints</code> object of this
697      * <code>ColorConvertOp</code>
698      */
699     public final RenderingHints getRenderingHints() {
700         return hints;
701     }
702
703     private final BufferedImage nonICCBIFilter(BufferedImage src,
704                                                ColorSpace srcColorSpace,
705                                                BufferedImage dst,
706                                                ColorSpace dstColorSpace) {
707
708         int w = src.getWidth();
709         int h = src.getHeight();
710         ICC_ColorSpace ciespace =
711             (ICC_ColorSpace) ColorSpace.getInstance(ColorSpace.CS_CIEXYZ);
712         if (dst == null) {
713             dst = createCompatibleDestImage(src, null);
714             dstColorSpace = dst.getColorModel().getColorSpace();
715         } else {
716             if ((h != dst.getHeight()) || (w != dst.getWidth())) {
717                 throw new IllegalArgumentException (
718                     "Width or height of BufferedImages do not match");
719             }
720         }
721         Raster srcRas = src.getRaster();
722         WritableRaster dstRas = dst.getRaster();
723         ColorModel srcCM = src.getColorModel();
724         ColorModel dstCM = dst.getColorModel();
725         int srcNumComp = srcCM.getNumColorComponents();
726         int dstNumComp = dstCM.getNumColorComponents();
727         boolean dstHasAlpha = dstCM.hasAlpha();
728         boolean needSrcAlpha = srcCM.hasAlpha() && dstHasAlpha;
729         ColorSpace[] list;
730         if ((CSList == null) && (profileList.length != 0)) {
731             /* possible non-ICC src, some profiles, possible non-ICC dst */
732             boolean nonICCSrc, nonICCDst;
733             ICC_Profile srcProfile, dstProfile;
734             if (!(srcColorSpace instanceof ICC_ColorSpace)) {
735                 nonICCSrc = true;
736                 srcProfile = ciespace.getProfile();
737             } else {
738                 nonICCSrc = false;
739                 srcProfile = ((ICC_ColorSpace) srcColorSpace).getProfile();
740             }
741             if (!(dstColorSpace instanceof ICC_ColorSpace)) {
742                 nonICCDst = true;
743                 dstProfile = ciespace.getProfile();
744             } else {
745                 nonICCDst = false;
746                 dstProfile = ((ICC_ColorSpace) dstColorSpace).getProfile();
747             }
748             /* make a new transform if needed */
749             if ((thisTransform == null) || (thisSrcProfile != srcProfile) ||
750                 (thisDestProfile != dstProfile) ) {
751                 updateBITransform(srcProfile, dstProfile);
752             }
753             // process per scanline
754 float maxNum = 65535.0f; // use 16-bit precision in CMM
755 ColorSpace cs;
756             int iccSrcNumComp;
757             if (nonICCSrc) {
758                 cs = ciespace;
759                 iccSrcNumComp = 3;
760             } else {
761                 cs = srcColorSpace;
762                 iccSrcNumComp = srcNumComp;
763             }
764             float[] srcMinVal = new float[iccSrcNumComp];
765             float[] srcInvDiffMinMax = new float[iccSrcNumComp];
766             for (int i = 0; i < srcNumComp; i++) {
767                 srcMinVal[i] = cs.getMinValue(i);
768                 srcInvDiffMinMax[i] = maxNum / (cs.getMaxValue(i) - srcMinVal[i]);
769             }
770             int iccDstNumComp;
771             if (nonICCDst) {
772                 cs = ciespace;
773  &