diff options
Diffstat (limited to 'debian/lcms/lcms-1.19.dfsg2/src/cmsgmt.c')
| -rwxr-xr-x | debian/lcms/lcms-1.19.dfsg2/src/cmsgmt.c | 1243 |
1 files changed, 1243 insertions, 0 deletions
diff --git a/debian/lcms/lcms-1.19.dfsg2/src/cmsgmt.c b/debian/lcms/lcms-1.19.dfsg2/src/cmsgmt.c new file mode 100755 index 00000000..74cde8b9 --- /dev/null +++ b/debian/lcms/lcms-1.19.dfsg2/src/cmsgmt.c @@ -0,0 +1,1243 @@ +// +// Little cms +// Copyright (C) 1998-2007 Marti Maria +// +// Permission is hereby granted, free of charge, to any person obtaining +// a copy of this software and associated documentation files (the "Software"), +// to deal in the Software without restriction, including without limitation +// the rights to use, copy, modify, merge, publish, distribute, sublicense, +// and/or sell copies of the Software, and to permit persons to whom the Software +// is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO +// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + +#include "lcms.h" + +/* +Gamut check by default is a catching of 0xFFFF/0xFFFF/0xFFFF PCS values, used +internally by lcms to hold invalid values. Matrix LUT's, operates in a way that +unencodeable values are marked as this combination, if PCS is XYZ, this is a very +high value since encoding is a 1.15 fixed point, something like 1.9997, 1.9997, 1.9997 +not a very common color after all. Lab PCS is not to be a problem, since L>100 are truely +undefined. There is a posibility than ICC comitee defines L>100 as a valid means +to use highlights, then it will be lost. + +(1.10 - Actually ICC did it, so this should be checked for full ICC 4.0 support) + +*/ + + +LCMSBOOL _cmsEndPointsBySpace(icColorSpaceSignature Space, WORD **White, WORD **Black, + int *nOutputs) +{ + // Only most common spaces + + static WORD RGBblack[4] = { 0, 0, 0 }; + static WORD RGBwhite[4] = { 0xffff, 0xffff, 0xffff }; + static WORD CMYKblack[4] = { 0xffff, 0xffff, 0xffff, 0xffff }; // 400% of ink + static WORD CMYKwhite[4] = { 0, 0, 0, 0 }; + static WORD LABblack[4] = { 0, 0x8000, 0x8000 }; + static WORD LABwhite[4] = { 0xFF00, 0x8000, 0x8000 }; + static WORD CMYblack[4] = { 0xffff, 0xffff, 0xffff }; + static WORD CMYwhite[4] = { 0, 0, 0 }; + static WORD Grayblack[4] = { 0 }; + static WORD GrayWhite[4] = { 0xffff }; + + switch (Space) { + + case icSigGrayData: if (White) *White = GrayWhite; + if (Black) *Black = Grayblack; + if (nOutputs) *nOutputs = 1; + return TRUE; + + case icSigRgbData: if (White) *White = RGBwhite; + if (Black) *Black = RGBblack; + if (nOutputs) *nOutputs = 3; + return TRUE; + + case icSigLabData: if (White) *White = LABwhite; + if (Black) *Black = LABblack; + if (nOutputs) *nOutputs = 3; + return TRUE; + + case icSigCmykData: if (White) *White = CMYKwhite; + if (Black) *Black = CMYKblack; + if (nOutputs) *nOutputs = 4; + return TRUE; + + case icSigCmyData: if (White) *White = CMYwhite; + if (Black) *Black = CMYblack; + if (nOutputs) *nOutputs = 3; + return TRUE; + + default:; + } + + return FALSE; +} + + +WORD *_cmsWhiteBySpace(icColorSpaceSignature Space) +{ + WORD *White= NULL, *Black = NULL; + int Dummy; + static WORD Default[MAXCHANNELS]; + + if (_cmsEndPointsBySpace(Space, &White, &Black, &Dummy)) + return White; + + return Default; + +} + + + + +WORD Clamp_L(Fixed32 in) +{ + if (in == 0xFFFF) return 0xFFFFU; // Marker + + if (in > 0xFF00) return 0xFF00U; // L* = 100.0 + return (WORD) in; +} + + +#define ENCODE_AB(x) (WORD) (((x) + 128.0) * 256.0 + 0.5) + +WORD Clamp_ab(Fixed32 in) +{ + if (in == 0xFFFF) return 0xFFFFU; // Marker + + if (in < 0) return ENCODE_AB(-128.0); // Max negative number + if (in > 0xFFFF) return ENCODE_AB(+127.9961); // Max positive number + return (WORD) in; +} + + + +// Returns dE on two Lab values + +double LCMSEXPORT cmsDeltaE(LPcmsCIELab Lab1, LPcmsCIELab Lab2) +{ + double dL, da, db; + + if (Lab1 -> L < 0 || + Lab2 -> L < 0) return 65536.; + + if (Lab1 -> a < -200 || Lab1 -> a > 200) return 65536.; + if (Lab1 -> b < -200 || Lab1 -> b > 200) return 65536.; + + if (Lab2 -> a < -200 || Lab2 -> a > 200) return 65536.; + if (Lab2 -> b < -200 || Lab2 -> b > 200) return 65536.; + + if (Lab1 ->L == 0 && Lab2 ->L == 0) return 0; + + dL = fabs(Lab1 -> L - Lab2 -> L); + da = fabs(Lab1 -> a - Lab2 -> a); + db = fabs(Lab1 -> b - Lab2 -> b); + + return pow(dL*dL + da * da + db * db, 0.5); + +} + + +// Square +static +double Sqr(double v) +{ + return v * v; +} + +// Return the CIE94 Delta E +double LCMSEXPORT cmsCIE94DeltaE(LPcmsCIELab Lab1, LPcmsCIELab Lab2) +{ + cmsCIELCh LCh1, LCh2; + double dE, dL, dC, dh, dhsq; + double c12, sc, sh; + + if (Lab1 ->L == 0 && Lab2 ->L == 0) return 0; + + dL = fabs(Lab1 ->L - Lab2 ->L); + + cmsLab2LCh(&LCh1, Lab1); + cmsLab2LCh(&LCh2, Lab2); + + dC = fabs(LCh1.C - LCh2.C); + dE = cmsDeltaE(Lab1, Lab2); + + dhsq = Sqr(dE) - Sqr(dL) - Sqr(dC); + if (dhsq < 0) + dh = 0; + else + dh = pow(dhsq, 0.5); + + c12 = sqrt(LCh1.C * LCh2.C); + + sc = 1.0 + (0.048 * c12); + sh = 1.0 + (0.014 * c12); + + return sqrt(Sqr(dL) + Sqr(dC) / Sqr(sc) + Sqr(dh) / Sqr(sh)); +} + + +// Auxiliary + +static +double ComputeLBFD(LPcmsCIELab Lab) +{ + double yt; + + if (Lab->L > 7.996969) + yt = (Sqr((Lab->L+16)/116)*((Lab->L+16)/116))*100; + else + yt = 100 * (Lab->L / 903.3); + + return (54.6 * (LOGE * (log(yt + 1.5))) - 9.6); +} + + + +// bfd - gets BFD(1:1) difference between Lab1, Lab2 +double LCMSEXPORT cmsBFDdeltaE(LPcmsCIELab Lab1, LPcmsCIELab Lab2) +{ + double lbfd1,lbfd2,AveC,Aveh,dE,deltaL, + deltaC,deltah,dc,t,g,dh,rh,rc,rt,bfd; + cmsCIELCh LCh1, LCh2; + + + if (Lab1 ->L == 0 && Lab2 ->L == 0) return 0; + + lbfd1 = ComputeLBFD(Lab1); + lbfd2 = ComputeLBFD(Lab2); + deltaL = lbfd2 - lbfd1; + + cmsLab2LCh(&LCh1, Lab1); + cmsLab2LCh(&LCh2, Lab2); + + deltaC = LCh2.C - LCh1.C; + AveC = (LCh1.C+LCh2.C)/2; + Aveh = (LCh1.h+LCh2.h)/2; + + dE = cmsDeltaE(Lab1, Lab2); + + if (Sqr(dE)>(Sqr(Lab2->L-Lab1->L)+Sqr(deltaC))) + deltah = sqrt(Sqr(dE)-Sqr(Lab2->L-Lab1->L)-Sqr(deltaC)); + else + deltah =0; + + + dc = 0.035 * AveC / (1 + 0.00365 * AveC)+0.521; + g = sqrt(Sqr(Sqr(AveC))/(Sqr(Sqr(AveC))+14000)); + t = 0.627+(0.055*cos((Aveh-254)/(180/M_PI))- + 0.040*cos((2*Aveh-136)/(180/M_PI))+ + 0.070*cos((3*Aveh-31)/(180/M_PI))+ + 0.049*cos((4*Aveh+114)/(180/M_PI))- + 0.015*cos((5*Aveh-103)/(180/M_PI))); + + dh = dc*(g*t+1-g); + rh = -0.260*cos((Aveh-308)/(180/M_PI))- + 0.379*cos((2*Aveh-160)/(180/M_PI))- + 0.636*cos((3*Aveh+254)/(180/M_PI))+ + 0.226*cos((4*Aveh+140)/(180/M_PI))- + 0.194*cos((5*Aveh+280)/(180/M_PI)); + + rc = sqrt((AveC*AveC*AveC*AveC*AveC*AveC)/((AveC*AveC*AveC*AveC*AveC*AveC)+70000000)); + rt = rh*rc; + + bfd = sqrt(Sqr(deltaL)+Sqr(deltaC/dc)+Sqr(deltah/dh)+(rt*(deltaC/dc)*(deltah/dh))); + + return bfd; +} + + +// cmc - CMC(1:1) difference between Lab1, Lab2 +double LCMSEXPORT cmsCMCdeltaE(LPcmsCIELab Lab1, LPcmsCIELab Lab2) +{ + double dE,dL,dC,dh,sl,sc,sh,t,f,cmc; + cmsCIELCh LCh1, LCh2; + + if (Lab1 ->L == 0 && Lab2 ->L == 0) return 0; + + cmsLab2LCh(&LCh1, Lab1); + cmsLab2LCh(&LCh2, Lab2); + + + dL = Lab2->L-Lab1->L; + dC = LCh2.C-LCh1.C; + + dE = cmsDeltaE(Lab1, Lab2); + if (Sqr(dE)>(Sqr(dL)+Sqr(dC))) + dh = sqrt(Sqr(dE)-Sqr(dL)-Sqr(dC)); + else + dh =0; + + if ((LCh1.h > 164) && (LCh1.h<345)) + t = 0.56 + fabs(0.2 * cos(((LCh1.h + 168)/(180/M_PI)))); + else + t = 0.36 + fabs(0.4 * cos(((LCh1.h + 35 )/(180/M_PI)))); + + sc = 0.0638 * LCh1.C / (1 + 0.0131 * LCh1.C) + 0.638; + sl = 0.040975 * Lab1->L /(1 + 0.01765 * Lab1->L); + + if (Lab1->L<16) + sl = 0.511; + + f = sqrt((LCh1.C * LCh1.C * LCh1.C * LCh1.C)/((LCh1.C * LCh1.C * LCh1.C * LCh1.C)+1900)); + sh = sc*(t*f+1-f); + cmc = sqrt(Sqr(dL/sl)+Sqr(dC/sc)+Sqr(dh/sh)); + + return cmc; +} + + + +static +double atan2deg(double b, double a) +{ + double h; + + if (a == 0 && b == 0) + h = 0; + else + h = atan2(a, b); + + h *= (180. / M_PI); + + while (h > 360.) + h -= 360.; + + while ( h < 0) + h += 360.; + + return h; + +} + + +static +double RADIANES(double deg) +{ + return (deg * M_PI) / 180.; +} + + +// dE2000 The weightings KL, KC and KH can be modified to reflect the relative +// importance of lightness, chroma and hue in different industrial applications + +double LCMSEXPORT cmsCIE2000DeltaE(LPcmsCIELab Lab1, LPcmsCIELab Lab2, + double Kl, double Kc, double Kh) +{ + double L1 = Lab1->L; + double a1 = Lab1->a; + double b1 = Lab1->b; + double C = sqrt( Sqr(a1) + Sqr(b1) ); + + double Ls = Lab2 ->L; + double as = Lab2 ->a; + double bs = Lab2 ->b; + double Cs = sqrt( Sqr(as) + Sqr(bs) ); + + double G = 0.5 * ( 1 - sqrt(pow((C + Cs) / 2 , 7.0) / (pow((C + Cs) / 2, 7.0) + pow(25.0, 7.0) ) )); + + double a_p = (1 + G ) * a1; + double b_p = b1; + double C_p = sqrt( Sqr(a_p) + Sqr(b_p)); + double h_p = atan2deg(a_p, b_p); + + + double a_ps = (1 + G) * as; + double b_ps = bs; + double C_ps = sqrt(Sqr(a_ps) + Sqr(b_ps)); + double h_ps = atan2deg(a_ps, b_ps); + + double meanC_p =(C_p + C_ps) / 2; + + double hps_plus_hp = h_ps + h_p; + double hps_minus_hp = h_ps - h_p; + + double meanh_p = fabs(hps_minus_hp) <= 180.000001 ? (hps_plus_hp)/2 : + (hps_plus_hp) < 360 ? (hps_plus_hp + 360)/2 : + (hps_plus_hp - 360)/2; + + double delta_h = (hps_minus_hp) <= -180.000001 ? (hps_minus_hp + 360) : + (hps_minus_hp) > 180 ? (hps_minus_hp - 360) : + (hps_minus_hp); + double delta_L = (Ls - L1); + double delta_C = (C_ps - C_p ); + + + double delta_H =2 * sqrt(C_ps*C_p) * sin(RADIANES(delta_h) / 2); + + double T = 1 - 0.17 * cos(RADIANES(meanh_p-30)) + + 0.24 * cos(RADIANES(2*meanh_p)) + + 0.32 * cos(RADIANES(3*meanh_p + 6)) + - 0.2 * cos(RADIANES(4*meanh_p - 63)); + + double Sl = 1 + (0.015 * Sqr((Ls + L1) /2- 50) )/ sqrt(20 + Sqr( (Ls+L1)/2 - 50) ); + + double Sc = 1 + 0.045 * (C_p + C_ps)/2; + double Sh = 1 + 0.015 * ((C_ps + C_p)/2) * T; + + double delta_ro = 30 * exp( -Sqr(((meanh_p - 275 ) / 25))); + + double Rc = 2 * sqrt(( pow(meanC_p, 7.0) )/( pow(meanC_p, 7.0) + pow(25.0, 7.0))); + + double Rt = -sin(2 * RADIANES(delta_ro)) * Rc; + + double deltaE00 = sqrt( Sqr(delta_L /(Sl * Kl)) + + Sqr(delta_C/(Sc * Kc)) + + Sqr(delta_H/(Sh * Kh)) + + Rt*(delta_C/(Sc * Kc)) * (delta_H / (Sh * Kh))); + + return deltaE00; +} + + + +// Carefully, clamp on CIELab space. + +void LCMSEXPORT cmsClampLab(LPcmsCIELab Lab, double amax, double amin, + double bmax, double bmin) +{ + + // Whole Luma surface to zero + + if (Lab -> L < 0) { + + Lab-> L = Lab->a = Lab-> b = 0.0; + return; + } + + // Clamp white, DISCARD HIGHLIGHTS. This is done + // in such way because icc spec doesn't allow the + // use of L>100 as a highlight means. + + if (Lab->L > 100) + Lab -> L = 100; + + // Check out gamut prism, on a, b faces + + if (Lab -> a < amin || Lab->a > amax|| + Lab -> b < bmin || Lab->b > bmax) { + + cmsCIELCh LCh; + double h, slope; + + // Falls outside a, b limits. Transports to LCh space, + // and then do the clipping + + + if (Lab -> a == 0.0) { // Is hue exactly 90? + + // atan will not work, so clamp here + Lab -> b = Lab->b < 0 ? bmin : bmax; + return; + } + + cmsLab2LCh(&LCh, Lab); + + slope = Lab -> b / Lab -> a; + h = LCh.h; + + // There are 4 zones + + if ((h >= 0. && h < 45.) || + (h >= 315 && h <= 360.)) { + + // clip by amax + Lab -> a = amax; + Lab -> b = amax * slope; + } + else + if (h >= 45. && h < 135) + { + // clip by bmax + Lab -> b = bmax; + Lab -> a = bmax / slope; + } + else + if (h >= 135 && h < 225) { + // clip by amin + Lab -> a = amin; + Lab -> b = amin * slope; + + } + else + if (h >= 225 && h < 315) { + // clip by bmin + Lab -> b = bmin; + Lab -> a = bmin / slope; + } + else + cmsSignalError(LCMS_ERRC_ABORTED, "Invalid angle"); + + } +} + +// Several utilities ------------------------------------------------------- + +// Translate from our colorspace to ICC representation + +icColorSpaceSignature LCMSEXPORT _cmsICCcolorSpace(int OurNotation) +{ + switch (OurNotation) { + + case 1: + case PT_GRAY: return icSigGrayData; + + case 2: + case PT_RGB: return icSigRgbData; + + case PT_CMY: return icSigCmyData; + case PT_CMYK: return icSigCmykData; + case PT_YCbCr:return icSigYCbCrData; + case PT_YUV: return icSigLuvData; + case PT_XYZ: return icSigXYZData; + case PT_Lab: return icSigLabData; + case PT_YUVK: return icSigLuvKData; + case PT_HSV: return icSigHsvData; + case PT_HLS: return icSigHlsData; + case PT_Yxy: return icSigYxyData; + case PT_HiFi: return icSigHexachromeData; + case PT_HiFi7: return icSigHeptachromeData; + case PT_HiFi8: return icSigOctachromeData; + + case PT_HiFi9: return icSigMCH9Data; + case PT_HiFi10: return icSigMCHAData; + case PT_HiFi11: return icSigMCHBData; + case PT_HiFi12: return icSigMCHCData; + case PT_HiFi13: return icSigMCHDData; + case PT_HiFi14: return icSigMCHEData; + case PT_HiFi15: return icSigMCHFData; + + default: return icMaxEnumData; + } +} + + +int LCMSEXPORT _cmsLCMScolorSpace(icColorSpaceSignature ProfileSpace) +{ + switch (ProfileSpace) { + + case icSigGrayData: return PT_GRAY; + case icSigRgbData: return PT_RGB; + case icSigCmyData: return PT_CMY; + case icSigCmykData: return PT_CMYK; + case icSigYCbCrData:return PT_YCbCr; + case icSigLuvData: return PT_YUV; + case icSigXYZData: return PT_XYZ; + case icSigLabData: return PT_Lab; + case icSigLuvKData: return PT_YUVK; + case icSigHsvData: return PT_HSV; + case icSigHlsData: return PT_HLS; + case icSigYxyData: return PT_Yxy; + + case icSig6colorData: + case icSigHexachromeData: return PT_HiFi; + + case icSigHeptachromeData: + case icSig7colorData: return PT_HiFi7; + + case icSigOctachromeData: + case icSig8colorData: return PT_HiFi8; + + case icSigMCH9Data: + case icSig9colorData: return PT_HiFi9; + + case icSigMCHAData: + case icSig10colorData: return PT_HiFi10; + + case icSigMCHBData: + case icSig11colorData: return PT_HiFi11; + + case icSigMCHCData: + case icSig12colorData: return PT_HiFi12; + + case icSigMCHDData: + case icSig13colorData: return PT_HiFi13; + + case icSigMCHEData: + case icSig14colorData: return PT_HiFi14; + + case icSigMCHFData: + case icSig15colorData: return PT_HiFi15; + + default: return icMaxEnumData; + } +} + + +int LCMSEXPORT _cmsChannelsOf(icColorSpaceSignature ColorSpace) +{ + + switch (ColorSpace) { + + case icSigGrayData: return 1; + + case icSig2colorData: return 2; + + case icSigXYZData: + case icSigLabData: + case icSigLuvData: + case icSigYCbCrData: + case icSigYxyData: + case icSigRgbData: + case icSigHsvData: + case icSigHlsData: + case icSigCmyData: + case icSig3colorData: return 3; + + case icSigLuvKData: + case icSigCmykData: + case icSig4colorData: return 4; + + case icSigMCH5Data: + case icSig5colorData: return 5; + + case icSigHexachromeData: + case icSig6colorData: return 6; + + case icSigHeptachromeData: + case icSig7colorData: return 7; + + case icSigOctachromeData: + case icSig8colorData: return 8; + + case icSigMCH9Data: + case icSig9colorData: return 9; + + case icSigMCHAData: + case icSig10colorData: return 10; + + case icSigMCHBData: + case icSig11colorData: return 11; + + case icSigMCHCData: + case icSig12colorData: return 12; + + case icSigMCHDData: + case icSig13colorData: return 13; + + case icSigMCHEData: + case icSig14colorData: return 14; + + case icSigMCHFData: + case icSig15colorData: return 15; + + default: return 3; + } + +} + + +// v2 L=100 is supposed to be placed on 0xFF00. There is no reasonable +// number of gridpoints that would make exact match. However, a +// prelinearization of 258 entries, would map 0xFF00 on entry 257. +// This is almost what we need, unfortunately, the rest of entries +// should be scaled by (255*257/256) and this is not exact. +// +// An intermediate solution would be to use 257 entries. This does not +// map 0xFF00 exactly on a node, but so close that the dE induced is +// negligible. AND the rest of curve is exact. + +static +void CreateLabPrelinearization(LPGAMMATABLE LabTable[]) +{ + int i; + + LabTable[0] = cmsAllocGamma(257); + LabTable[1] = cmsBuildGamma(257, 1.0); + LabTable[2] = cmsBuildGamma(257, 1.0); + + // L* uses 257 entries. Entry 256 holds 0xFFFF, so, the effective range + // is 0..0xFF00. Last entry (257) is also collapsed to 0xFFFF + + // From 0 to 0xFF00 + for (i=0; i < 256; i++) + LabTable[0]->GammaTable[i] = RGB_8_TO_16(i); + + // Repeat last for 0xFFFF + LabTable[0] ->GammaTable[256] = 0xFFFF; +} + + +// Used by gamut & softproofing + +typedef struct { + + cmsHTRANSFORM hInput; // From whatever input color space. NULL for Lab + cmsHTRANSFORM hForward, hReverse; // Transforms going from Lab to colorant and back + double Thereshold; // The thereshold after which is considered out of gamut + + } GAMUTCHAIN,FAR* LPGAMUTCHAIN; + +// This sampler does compute gamut boundaries by comparing original +// values with a transform going back and forth. Values above ERR_THERESHOLD +// of maximum are considered out of gamut. + + +#define ERR_THERESHOLD 5 + + +static +int GamutSampler(register WORD In[], register WORD Out[], register LPVOID Cargo) +{ + LPGAMUTCHAIN t = (LPGAMUTCHAIN) Cargo; + WORD Proof[MAXCHANNELS], Check[MAXCHANNELS]; + WORD Proof2[MAXCHANNELS], Check2[MAXCHANNELS]; + cmsCIELab LabIn1, LabOut1; + cmsCIELab LabIn2, LabOut2; + double dE1, dE2, ErrorRatio; + + // Assume in-gamut by default. + dE1 = 0.; + dE2 = 0; + ErrorRatio = 1.0; + + + // Any input space? I can use In[] no matter channels + // because is just one pixel + + if (t -> hInput != NULL) cmsDoTransform(t -> hInput, In, In, 1); + + // converts from PCS to colorant. This always + // does return in-gamut values, + cmsDoTransform(t -> hForward, In, Proof, 1); + + // Now, do the inverse, from colorant to PCS. + cmsDoTransform(t -> hReverse, Proof, Check, 1); + + + // Try again, but this time taking Check as input + cmsDoTransform(t -> hForward, Check, Proof2, 1); + cmsDoTransform(t -> hReverse, Proof2, Check2, 1); + + + + // Does the transform returns out-of-gamut? + if (Check[0] == 0xFFFF && + Check[1] == 0xFFFF && + Check[2] == 0xFFFF) + + Out[0] = 0xFF00; // Out of gamut! + else { + + // Transport encoded values + cmsLabEncoded2Float(&LabIn1, In); + cmsLabEncoded2Float(&LabOut1, Check); + + // Take difference of direct value + dE1 = cmsDeltaE(&LabIn1, &LabOut1); + + cmsLabEncoded2Float(&LabIn2, Check); + cmsLabEncoded2Float(&LabOut2, Check2); + + // Take difference of converted value + dE2 = cmsDeltaE(&LabIn2, &LabOut2); + + + // if dE1 is small and dE2 is small, value is likely to be in gamut + if (dE1 < t->Thereshold && dE2 < t->Thereshold) + Out[0] = 0; + else + // if dE1 is small and dE2 is big, undefined. Assume in gamut + if (dE1 < t->Thereshold && dE2 > t->Thereshold) + Out[0] = 0; + else + // dE1 is big and dE2 is small, clearly out of gamut + if (dE1 > t->Thereshold && dE2 < t->Thereshold) + Out[0] = (WORD) _cmsQuickFloor((dE1 - t->Thereshold) + .5); + else { + + // dE1 is big and dE2 is also big, could be due to perceptual mapping + // so take error ratio + if (dE2 == 0.0) + ErrorRatio = dE1; + else + ErrorRatio = dE1 / dE2; + + if (ErrorRatio > t->Thereshold) + Out[0] = (WORD) _cmsQuickFloor((ErrorRatio - t->Thereshold) + .5); + else + Out[0] = 0; + } + + } + + return TRUE; +} + + +// Does compute a gamut LUT going back and forth across +// pcs -> relativ. colorimetric intent -> pcs +// the dE obtained is then annotated on the LUT. +// values truely out of gamut, are clipped to dE = 0xFFFE +// and values changed are supposed to be handled by +// any gamut remapping, so, are out of gamut as well. +// +// **WARNING: This algorithm does assume that gamut +// remapping algorithms does NOT move in-gamut colors, +// of course, many perceptual and saturation intents does +// not work in such way, but relativ. ones should. + +static +LPLUT ComputeGamutWithInput(cmsHPROFILE hInput, cmsHPROFILE hProfile, int Intent) +{ + cmsHPROFILE hLab; + LPLUT Gamut; + DWORD dwFormat; + GAMUTCHAIN Chain; + int nErrState, nChannels, nGridpoints; + LPGAMMATABLE Trans[3]; + icColorSpaceSignature ColorSpace; + + + ZeroMemory(&Chain, sizeof(GAMUTCHAIN)); + + hLab = cmsCreateLabProfile(NULL); + + // Safeguard against early abortion + nErrState = cmsErrorAction(LCMS_ERROR_IGNORE); + + // The figure of merit. On matrix-shaper profiles, should be almost zero as + // the conversion is pretty exact. On LUT based profiles, different resolutions + // of input and output CLUT may result in differences. + + if (!cmsIsIntentSupported(hProfile, Intent, LCMS_USED_AS_INPUT) && + !cmsIsIntentSupported(hProfile, Intent, LCMS_USED_AS_OUTPUT)) + + Chain.Thereshold = 1.0; + else + Chain.Thereshold = ERR_THERESHOLD; + + ColorSpace = cmsGetColorSpace(hProfile); + + // If input profile specified, create a transform from such profile to Lab + if (hInput != NULL) { + + nChannels = _cmsChannelsOf(ColorSpace); + nGridpoints = _cmsReasonableGridpointsByColorspace(ColorSpace, cmsFLAGS_HIGHRESPRECALC); + dwFormat = (CHANNELS_SH(nChannels)|BYTES_SH(2)); + + Chain.hInput = cmsCreateTransform(hInput, dwFormat, + hLab, TYPE_Lab_16, + Intent, + cmsFLAGS_NOTPRECALC); + } + else { + // Input transform=NULL (Lab) Used to compute the gamut tag + // This table will take 53 points to give some accurancy, + // 53 * 53 * 53 * 2 = 291K + + nChannels = 3; // For Lab + nGridpoints = 53; + Chain.hInput = NULL; + dwFormat = (CHANNELS_SH(_cmsChannelsOf(ColorSpace))|BYTES_SH(2)); + } + + + // Does create the forward step + Chain.hForward = cmsCreateTransform(hLab, TYPE_Lab_16, + hProfile, dwFormat, + INTENT_RELATIVE_COLORIMETRIC, + cmsFLAGS_NOTPRECALC); + + // Does create the backwards step + Chain.hReverse = cmsCreateTransform(hProfile, dwFormat, + hLab, TYPE_Lab_16, + INTENT_RELATIVE_COLORIMETRIC, + cmsFLAGS_NOTPRECALC); + + // Restores error handler previous state + cmsErrorAction(nErrState); + + + // All ok? + if (Chain.hForward && Chain.hReverse) { + + // Go on, try to compute gamut LUT from PCS. + // This consist on a single channel containing + // dE when doing a transform back and forth on + // the colorimetric intent. + + Gamut = cmsAllocLUT(); + Gamut = cmsAlloc3DGrid(Gamut, nGridpoints, nChannels, 1); + + // If no input, then this is a gamut tag operated by Lab, + // so include pertinent prelinearization + if (hInput == NULL) { + + CreateLabPrelinearization(Trans); + cmsAllocLinearTable(Gamut, Trans, 1); + cmsFreeGammaTriple(Trans); + } + + + cmsSample3DGrid(Gamut, GamutSampler, (LPVOID) &Chain, Gamut ->wFlags); + } + else + Gamut = NULL; // Didn't work... + + // Free all needed stuff. + if (Chain.hInput) cmsDeleteTransform(Chain.hInput); + if (Chain.hForward) cmsDeleteTransform(Chain.hForward); + if (Chain.hReverse) cmsDeleteTransform(Chain.hReverse); + + cmsCloseProfile(hLab); + + // And return computed hull + return Gamut; +} + + +// Wrapper + +LPLUT _cmsComputeGamutLUT(cmsHPROFILE hProfile, int Intent) +{ + return ComputeGamutWithInput(NULL, hProfile, Intent); +} + + +// This routine does compute the gamut check CLUT. This CLUT goes from whatever +// input space to the 0 or != 0 gamut check. + +LPLUT _cmsPrecalculateGamutCheck(cmsHTRANSFORM h) +{ + _LPcmsTRANSFORM p = (_LPcmsTRANSFORM) h; + + return ComputeGamutWithInput(p->InputProfile, p ->PreviewProfile, p->Intent); +} + + +// SoftProofing. Convert from Lab to device, then back to Lab, +// any gamut remapping is applied + +static +int SoftProofSampler(register WORD In[], register WORD Out[], register LPVOID Cargo) +{ + LPGAMUTCHAIN t = (LPGAMUTCHAIN) Cargo; + WORD Colorant[MAXCHANNELS]; + + // From pcs to colorant + cmsDoTransform(t -> hForward, In, Colorant, 1); + + // Now, do the inverse, from colorant to pcs. + cmsDoTransform(t -> hReverse, Colorant, Out, 1); + + return TRUE; +} + +// Does return Softproofing LUT on desired intent + +LPLUT _cmsComputeSoftProofLUT(cmsHPROFILE hProfile, int nIntent) +{ + cmsHPROFILE hLab; + LPLUT SoftProof; + DWORD dwFormat; + GAMUTCHAIN Chain; + int nErrState; + LPGAMMATABLE Trans[3]; + + + // LUTs are never abs. colorimetric, is the transform who + // is responsible of generating white point displacement + if (nIntent == INTENT_ABSOLUTE_COLORIMETRIC) + nIntent = INTENT_RELATIVE_COLORIMETRIC; + + ZeroMemory(&Chain, sizeof(GAMUTCHAIN)); + + hLab = cmsCreateLabProfile(NULL); + + // ONLY 4 channels + dwFormat = (CHANNELS_SH(4)|BYTES_SH(2)); + + // Safeguard against early abortion + nErrState = cmsErrorAction(LCMS_ERROR_IGNORE); + + // Does create the first step + Chain.hForward = cmsCreateTransform(hLab, TYPE_Lab_16, + hProfile, dwFormat, + nIntent, + cmsFLAGS_NOTPRECALC); + + // Does create the last step + Chain.hReverse = cmsCreateTransform(hProfile, dwFormat, + hLab, TYPE_Lab_16, + INTENT_RELATIVE_COLORIMETRIC, + cmsFLAGS_NOTPRECALC); + + // Restores error handler previous state + cmsErrorAction(nErrState); + + // All ok? + if (Chain.hForward && Chain.hReverse) { + + // This is Lab -> Lab, so 33 point should hold anything + SoftProof = cmsAllocLUT(); + SoftProof = cmsAlloc3DGrid(SoftProof, 33, 3, 3); + + CreateLabPrelinearization(Trans); + cmsAllocLinearTable(SoftProof, Trans, 1); + cmsFreeGammaTriple(Trans); + + cmsSample3DGrid(SoftProof, SoftProofSampler, (LPVOID) &Chain, SoftProof->wFlags); + } + else + SoftProof = NULL; // Didn't work... + + // Free all needed stuff. + if (Chain.hForward) cmsDeleteTransform(Chain.hForward); + if (Chain.hReverse) cmsDeleteTransform(Chain.hReverse); + + cmsCloseProfile(hLab); + + return SoftProof; +} + + +static +int MostlyLinear(WORD Table[], int nEntries) +{ + register int i; + int diff; + + for (i=5; i < nEntries; i++) { + + diff = abs((int) Table[i] - (int) _cmsQuantizeVal(i, nEntries)); + if (diff > 0x0300) + return 0; + } + + return 1; +} + + +static +void SlopeLimiting(WORD Table[], int nEntries) +{ + int At = (int) floor((double) nEntries * 0.02 + 0.5); // Cutoff at 2% + double Val, Slope; + int i; + + Val = Table[At]; + Slope = Val / At; + + for (i=0; i < At; i++) + Table[i] = (WORD) floor(i * Slope + 0.5); + +} + + +// Check for monotonicity. + +static +LCMSBOOL IsMonotonic(LPGAMMATABLE t) +{ + int n = t -> nEntries; + int i, last; + + last = t ->GammaTable[n-1]; + + for (i = n-2; i >= 0; --i) { + + if (t ->GammaTable[i] > last) + + return FALSE; + else + last = t ->GammaTable[i]; + + } + + return TRUE; +} + +// Check for endpoints + +static +LCMSBOOL HasProperEndpoints(LPGAMMATABLE t) +{ + if (t ->GammaTable[0] != 0) return FALSE; + if (t ->GammaTable[t ->nEntries-1] != 0xFFFF) return FALSE; + + return TRUE; +} + + + +#define PRELINEARIZATION_POINTS 4096 + +// Fixes the gamma balancing of transform. Thanks to Mike Chaney +// for pointing this subtle bug. + +void _cmsComputePrelinearizationTablesFromXFORM(cmsHTRANSFORM h[], int nTransforms, LPLUT Grid) +{ + LPGAMMATABLE Trans[MAXCHANNELS]; + unsigned int t, i, v; + int j; + WORD In[MAXCHANNELS], Out[MAXCHANNELS]; + LCMSBOOL lIsSuitable; + _LPcmsTRANSFORM InputXForm = (_LPcmsTRANSFORM) h[0]; + _LPcmsTRANSFORM OutputXForm = (_LPcmsTRANSFORM) h[nTransforms-1]; + + + // First space is *Lab, use our specialized curves for v2 Lab + + if (InputXForm ->EntryColorSpace == icSigLabData && + OutputXForm->ExitColorSpace != icSigLabData) { + + CreateLabPrelinearization(Trans); + cmsAllocLinearTable(Grid, Trans, 1); + cmsFreeGammaTriple(Trans); + return; + } + + + // Do nothing on all but Gray/RGB to Gray/RGB transforms + + if (((InputXForm ->EntryColorSpace != icSigRgbData) && (InputXForm ->EntryColorSpace != icSigGrayData)) || + ((OutputXForm->ExitColorSpace != icSigRgbData) && (OutputXForm->ExitColorSpace != icSigGrayData))) return; + + + for (t = 0; t < Grid -> InputChan; t++) + Trans[t] = cmsAllocGamma(PRELINEARIZATION_POINTS); + + for (i=0; i < PRELINEARIZATION_POINTS; i++) { + + v = _cmsQuantizeVal(i, PRELINEARIZATION_POINTS); + + for (t=0; t < Grid -> InputChan; t++) + In[t] = (WORD) v; + + cmsDoTransform(h[0], In, Out, 1); + for (j=1; j < nTransforms; j++) + cmsDoTransform(h[j], Out, Out, 1); + + for (t=0; t < Grid -> InputChan; t++) + Trans[t] ->GammaTable[i] = Out[t]; + + } + + + // Check transfer curves + lIsSuitable = TRUE; + for (t=0; (lIsSuitable && (t < Grid->InputChan)); t++) { + + + // Exclude if already linear + if (MostlyLinear(Trans[t]->GammaTable, PRELINEARIZATION_POINTS)) + lIsSuitable = FALSE; + + // Exclude if non-monotonic + if (!IsMonotonic(Trans[t])) + lIsSuitable = FALSE; + + // Exclude if weird endpoints + if (!HasProperEndpoints(Trans[t])) + lIsSuitable = FALSE; + + /* + // Exclude if transfer function is not smooth enough + // to be modelled as a gamma function, or the gamma is reversed + + if (cmsEstimateGamma(Trans[t]) < 1.0) + lIsSuitable = FALSE; + */ + + } + + if (lIsSuitable) { + + for (t = 0; t < Grid ->InputChan; t++) + SlopeLimiting(Trans[t]->GammaTable, Trans[t]->nEntries); + } + + if (lIsSuitable) cmsAllocLinearTable(Grid, Trans, 1); + + + for (t = 0; t < Grid ->InputChan; t++) + cmsFreeGamma(Trans[t]); + + +} + + +// Compute K -> L* relationship. Flags may include black point compensation. In this case, +// the relationship is assumed from the profile with BPC to a black point zero. +static +LPGAMMATABLE ComputeKToLstar(cmsHPROFILE hProfile, int nPoints, int Intent, DWORD dwFlags) +{ + LPGAMMATABLE out; + int i; + WORD cmyk[4], wLab[3]; + cmsHPROFILE hLab = cmsCreateLabProfile(NULL); + cmsHTRANSFORM xform = cmsCreateTransform(hProfile, TYPE_CMYK_16, + hLab, TYPE_Lab_16, + Intent, (dwFlags|cmsFLAGS_NOTPRECALC)); + + + out = cmsAllocGamma(nPoints); + for (i=0; i < nPoints; i++) { + + cmyk[0] = 0; + cmyk[1] = 0; + cmyk[2] = 0; + cmyk[3] = _cmsQuantizeVal(i, nPoints); + + cmsDoTransform(xform, cmyk, wLab, 1); + out->GammaTable[i] = (WORD) (0xFFFF - wLab[0]); + } + + cmsDeleteTransform(xform); + cmsCloseProfile(hLab); + + return out; +} + + + +// Compute Black tone curve on a CMYK -> CMYK transform. This is done by +// using the proof direction on both profiles to find K->L* relationship +// then joining both curves. dwFlags may include black point compensation. + +LPGAMMATABLE _cmsBuildKToneCurve(cmsHTRANSFORM hCMYK2CMYK, int nPoints) +{ + LPGAMMATABLE in, out; + LPGAMMATABLE KTone; + _LPcmsTRANSFORM p = (_LPcmsTRANSFORM) hCMYK2CMYK; + + + // Make sure CMYK -> CMYK + if (p -> EntryColorSpace != icSigCmykData || + p -> ExitColorSpace != icSigCmykData) return NULL; + + // Create individual curves. BPC works also as each K to L* is + // computed as a BPC to zero black point in case of L* + in = ComputeKToLstar(p ->InputProfile, nPoints, p->Intent, p -> dwOriginalFlags); + out = ComputeKToLstar(p ->OutputProfile, nPoints, p->Intent, p -> dwOriginalFlags); + + // Build the relationship + KTone = cmsJoinGamma(in, out); + + cmsFreeGamma(in); cmsFreeGamma(out); + + // Make sure it is monotonic + + if (!IsMonotonic(KTone)) { + + cmsFreeGamma(KTone); + return NULL; + } + + + return KTone; +} |