1 /*
2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3 *
4 * This code is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 only, as
6 * published by the Free Software Foundation. Oracle designates this
7 * particular file as subject to the "Classpath" exception as provided
8 * by Oracle in the LICENSE file that accompanied this code.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 */
24
25 // This file is available under and governed by the GNU General Public
26 // License version 2 only, as published by the Free Software Foundation.
27 // However, the following notice accompanied the original version of this
28 // file:
29 //
30 //---------------------------------------------------------------------------------
31 //
32 // Little Color Management System
33 // Copyright (c) 1998-2017 Marti Maria Saguer
34 //
35 // Permission is hereby granted, free of charge, to any person obtaining
36 // a copy of this software and associated documentation files (the "Software"),
37 // to deal in the Software without restriction, including without limitation
38 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
39 // and/or sell copies of the Software, and to permit persons to whom the Software
40 // is furnished to do so, subject to the following conditions:
41 //
42 // The above copyright notice and this permission notice shall be included in
43 // all copies or substantial portions of the Software.
44 //
45 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
46 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
47 // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
48 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
49 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
50 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
51 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
52 //
53 //---------------------------------------------------------------------------------
54 //
55
56 #include "lcms2_internal.h"
57
58 // inter PCS conversions XYZ <-> CIE L* a* b*
59 /*
60
61
62 CIE 15:2004 CIELab is defined as:
63
64 L* = 116*f(Y/Yn) - 16 0 <= L* <= 100
65 a* = 500*[f(X/Xn) - f(Y/Yn)]
66 b* = 200*[f(Y/Yn) - f(Z/Zn)]
67
68 and
69
70 f(t) = t^(1/3) 1 >= t > (24/116)^3
71 (841/108)*t + (16/116) 0 <= t <= (24/116)^3
72
73
74 Reverse transform is:
75
76 X = Xn*[a* / 500 + (L* + 16) / 116] ^ 3 if (X/Xn) > (24/116)
77 = Xn*(a* / 500 + L* / 116) / 7.787 if (X/Xn) <= (24/116)
78
79
80
81 PCS in Lab2 is encoded as:
82
83 8 bit Lab PCS:
84
85 L* 0..100 into a 0..ff byte.
86 a* t + 128 range is -128.0 +127.0
87 b*
88
89 16 bit Lab PCS:
90
91 L* 0..100 into a 0..ff00 word.
92 a* t + 128 range is -128.0 +127.9961
93 b*
94
95
96
97 Interchange Space Component Actual Range Encoded Range
98 CIE XYZ X 0 -> 1.99997 0x0000 -> 0xffff
99 CIE XYZ Y 0 -> 1.99997 0x0000 -> 0xffff
100 CIE XYZ Z 0 -> 1.99997 0x0000 -> 0xffff
101
102 Version 2,3
103 -----------
104
105 CIELAB (16 bit) L* 0 -> 100.0 0x0000 -> 0xff00
106 CIELAB (16 bit) a* -128.0 -> +127.996 0x0000 -> 0x8000 -> 0xffff
107 CIELAB (16 bit) b* -128.0 -> +127.996 0x0000 -> 0x8000 -> 0xffff
108
109
110 Version 4
111 ---------
112
113 CIELAB (16 bit) L* 0 -> 100.0 0x0000 -> 0xffff
114 CIELAB (16 bit) a* -128.0 -> +127 0x0000 -> 0x8080 -> 0xffff
115 CIELAB (16 bit) b* -128.0 -> +127 0x0000 -> 0x8080 -> 0xffff
116
117 */
118
119 // Conversions
120 void CMSEXPORT cmsXYZ2xyY(cmsCIExyY* Dest, const cmsCIEXYZ* Source)
121 {
122 cmsFloat64Number ISum;
123
124 ISum = 1./(Source -> X + Source -> Y + Source -> Z);
125
126 Dest -> x = (Source -> X) * ISum;
127 Dest -> y = (Source -> Y) * ISum;
128 Dest -> Y = Source -> Y;
129 }
130
131 void CMSEXPORT cmsxyY2XYZ(cmsCIEXYZ* Dest, const cmsCIExyY* Source)
132 {
133 Dest -> X = (Source -> x / Source -> y) * Source -> Y;
134 Dest -> Y = Source -> Y;
135 Dest -> Z = ((1 - Source -> x - Source -> y) / Source -> y) * Source -> Y;
136 }
137
138 /*
139 The break point (24/116)^3 = (6/29)^3 is a very small amount of tristimulus
140 primary (0.008856). Generally, this only happens for
141 nearly ideal blacks and for some orange / amber colors in transmission mode.
142 For example, the Z value of the orange turn indicator lamp lens on an
143 automobile will often be below this value. But the Z does not
144 contribute to the perceived color directly.
145 */
146
147 static
148 cmsFloat64Number f(cmsFloat64Number t)
149 {
150 const cmsFloat64Number Limit = (24.0/116.0) * (24.0/116.0) * (24.0/116.0);
151
152 if (t <= Limit)
153 return (841.0/108.0) * t + (16.0/116.0);
154 else
155 return pow(t, 1.0/3.0);
156 }
157
158 static
159 cmsFloat64Number f_1(cmsFloat64Number t)
160 {
161 const cmsFloat64Number Limit = (24.0/116.0);
162
163 if (t <= Limit) {
164 return (108.0/841.0) * (t - (16.0/116.0));
165 }
166
167 return t * t * t;
168 }
169
170
171 // Standard XYZ to Lab. it can handle negative XZY numbers in some cases
172 void CMSEXPORT cmsXYZ2Lab(const cmsCIEXYZ* WhitePoint, cmsCIELab* Lab, const cmsCIEXYZ* xyz)
173 {
174 cmsFloat64Number fx, fy, fz;
175
176 if (WhitePoint == NULL)
177 WhitePoint = cmsD50_XYZ();
178
179 fx = f(xyz->X / WhitePoint->X);
180 fy = f(xyz->Y / WhitePoint->Y);
181 fz = f(xyz->Z / WhitePoint->Z);
182
183 Lab->L = 116.0*fy - 16.0;
184 Lab->a = 500.0*(fx - fy);
185 Lab->b = 200.0*(fy - fz);
186 }
187
188
189 // Standard XYZ to Lab. It can return negative XYZ in some cases
190 void CMSEXPORT cmsLab2XYZ(const cmsCIEXYZ* WhitePoint, cmsCIEXYZ* xyz, const cmsCIELab* Lab)
191 {
192 cmsFloat64Number x, y, z;
193
194 if (WhitePoint == NULL)
195 WhitePoint = cmsD50_XYZ();
196
197 y = (Lab-> L + 16.0) / 116.0;
198 x = y + 0.002 * Lab -> a;
199 z = y - 0.005 * Lab -> b;
200
201 xyz -> X = f_1(x) * WhitePoint -> X;
202 xyz -> Y = f_1(y) * WhitePoint -> Y;
203 xyz -> Z = f_1(z) * WhitePoint -> Z;
204
205 }
206
207 static
208 cmsFloat64Number L2float2(cmsUInt16Number v)
209 {
210 return (cmsFloat64Number) v / 652.800;
211 }
212
213 // the a/b part
214 static
215 cmsFloat64Number ab2float2(cmsUInt16Number v)
216 {
217 return ((cmsFloat64Number) v / 256.0) - 128.0;
218 }
219
220 static
221 cmsUInt16Number L2Fix2(cmsFloat64Number L)
222 {
223 return _cmsQuickSaturateWord(L * 652.8);
224 }
225
226 static
227 cmsUInt16Number ab2Fix2(cmsFloat64Number ab)
228 {
229 return _cmsQuickSaturateWord((ab + 128.0) * 256.0);
230 }
231
232
233 static
234 cmsFloat64Number L2float4(cmsUInt16Number v)
235 {
236 return (cmsFloat64Number) v / 655.35;
237 }
238
239 // the a/b part
240 static
241 cmsFloat64Number ab2float4(cmsUInt16Number v)
242 {
243 return ((cmsFloat64Number) v / 257.0) - 128.0;
244 }
245
246
247 void CMSEXPORT cmsLabEncoded2FloatV2(cmsCIELab* Lab, const cmsUInt16Number wLab[3])
248 {
249 Lab->L = L2float2(wLab[0]);
250 Lab->a = ab2float2(wLab[1]);
251 Lab->b = ab2float2(wLab[2]);
252 }
253
254
255 void CMSEXPORT cmsLabEncoded2Float(cmsCIELab* Lab, const cmsUInt16Number wLab[3])
256 {
257 Lab->L = L2float4(wLab[0]);
258 Lab->a = ab2float4(wLab[1]);
259 Lab->b = ab2float4(wLab[2]);
260 }
261
262 static
263 cmsFloat64Number Clamp_L_doubleV2(cmsFloat64Number L)
264 {
265 const cmsFloat64Number L_max = (cmsFloat64Number) (0xFFFF * 100.0) / 0xFF00;
266
267 if (L < 0) L = 0;
268 if (L > L_max) L = L_max;
269
270 return L;
271 }
272
273
274 static
275 cmsFloat64Number Clamp_ab_doubleV2(cmsFloat64Number ab)
276 {
277 if (ab < MIN_ENCODEABLE_ab2) ab = MIN_ENCODEABLE_ab2;
278 if (ab > MAX_ENCODEABLE_ab2) ab = MAX_ENCODEABLE_ab2;
279
280 return ab;
281 }
282
283 void CMSEXPORT cmsFloat2LabEncodedV2(cmsUInt16Number wLab[3], const cmsCIELab* fLab)
284 {
285 cmsCIELab Lab;
286
287 Lab.L = Clamp_L_doubleV2(fLab ->L);
288 Lab.a = Clamp_ab_doubleV2(fLab ->a);
289 Lab.b = Clamp_ab_doubleV2(fLab ->b);
290
291 wLab[0] = L2Fix2(Lab.L);
292 wLab[1] = ab2Fix2(Lab.a);
293 wLab[2] = ab2Fix2(Lab.b);
294 }
295
296
297 static
298 cmsFloat64Number Clamp_L_doubleV4(cmsFloat64Number L)
299 {
300 if (L < 0) L = 0;
301 if (L > 100.0) L = 100.0;
302
303 return L;
304 }
305
306 static
307 cmsFloat64Number Clamp_ab_doubleV4(cmsFloat64Number ab)
308 {
309 if (ab < MIN_ENCODEABLE_ab4) ab = MIN_ENCODEABLE_ab4;
310 if (ab > MAX_ENCODEABLE_ab4) ab = MAX_ENCODEABLE_ab4;
311
312 return ab;
313 }
314
315 static
316 cmsUInt16Number L2Fix4(cmsFloat64Number L)
317 {
318 return _cmsQuickSaturateWord(L * 655.35);
319 }
320
321 static
322 cmsUInt16Number ab2Fix4(cmsFloat64Number ab)
323 {
324 return _cmsQuickSaturateWord((ab + 128.0) * 257.0);
325 }
326
327 void CMSEXPORT cmsFloat2LabEncoded(cmsUInt16Number wLab[3], const cmsCIELab* fLab)
328 {
329 cmsCIELab Lab;
330
331 Lab.L = Clamp_L_doubleV4(fLab ->L);
332 Lab.a = Clamp_ab_doubleV4(fLab ->a);
333 Lab.b = Clamp_ab_doubleV4(fLab ->b);
334
335 wLab[0] = L2Fix4(Lab.L);
336 wLab[1] = ab2Fix4(Lab.a);
337 wLab[2] = ab2Fix4(Lab.b);
338 }
339
340 // Auxiliary: convert to Radians
341 static
342 cmsFloat64Number RADIANS(cmsFloat64Number deg)
343 {
344 return (deg * M_PI) / 180.;
345 }
346
347
348 // Auxiliary: atan2 but operating in degrees and returning 0 if a==b==0
349 static
350 cmsFloat64Number atan2deg(cmsFloat64Number a, cmsFloat64Number b)
351 {
352 cmsFloat64Number h;
353
354 if (a == 0 && b == 0)
355 h = 0;
356 else
357 h = atan2(a, b);
358
359 h *= (180. / M_PI);
360
361 while (h > 360.)
362 h -= 360.;
363
364 while ( h < 0)
365 h += 360.;
366
367 return h;
368 }
369
370
371 // Auxiliary: Square
372 static
373 cmsFloat64Number Sqr(cmsFloat64Number v)
374 {
375 return v * v;
376 }
377 // From cylindrical coordinates. No check is performed, then negative values are allowed
378 void CMSEXPORT cmsLab2LCh(cmsCIELCh* LCh, const cmsCIELab* Lab)
379 {
380 LCh -> L = Lab -> L;
381 LCh -> C = pow(Sqr(Lab ->a) + Sqr(Lab ->b), 0.5);
382 LCh -> h = atan2deg(Lab ->b, Lab ->a);
383 }
384
385
386 // To cylindrical coordinates. No check is performed, then negative values are allowed
387 void CMSEXPORT cmsLCh2Lab(cmsCIELab* Lab, const cmsCIELCh* LCh)
388 {
389 cmsFloat64Number h = (LCh -> h * M_PI) / 180.0;
390
391 Lab -> L = LCh -> L;
392 Lab -> a = LCh -> C * cos(h);
393 Lab -> b = LCh -> C * sin(h);
394 }
395
396 // In XYZ All 3 components are encoded using 1.15 fixed point
397 static
398 cmsUInt16Number XYZ2Fix(cmsFloat64Number d)
399 {
400 return _cmsQuickSaturateWord(d * 32768.0);
401 }
402
403 void CMSEXPORT cmsFloat2XYZEncoded(cmsUInt16Number XYZ[3], const cmsCIEXYZ* fXYZ)
404 {
405 cmsCIEXYZ xyz;
406
407 xyz.X = fXYZ -> X;
408 xyz.Y = fXYZ -> Y;
409 xyz.Z = fXYZ -> Z;
410
411 // Clamp to encodeable values.
412 if (xyz.Y <= 0) {
413
414 xyz.X = 0;
415 xyz.Y = 0;
416 xyz.Z = 0;
417 }
418
419 if (xyz.X > MAX_ENCODEABLE_XYZ)
420 xyz.X = MAX_ENCODEABLE_XYZ;
421
422 if (xyz.X < 0)
423 xyz.X = 0;
424
425 if (xyz.Y > MAX_ENCODEABLE_XYZ)
426 xyz.Y = MAX_ENCODEABLE_XYZ;
427
428 if (xyz.Y < 0)
429 xyz.Y = 0;
430
431 if (xyz.Z > MAX_ENCODEABLE_XYZ)
432 xyz.Z = MAX_ENCODEABLE_XYZ;
433
434 if (xyz.Z < 0)
435 xyz.Z = 0;
436
437
438 XYZ[0] = XYZ2Fix(xyz.X);
439 XYZ[1] = XYZ2Fix(xyz.Y);
440 XYZ[2] = XYZ2Fix(xyz.Z);
441 }
442
443
444 // To convert from Fixed 1.15 point to cmsFloat64Number
445 static
446 cmsFloat64Number XYZ2float(cmsUInt16Number v)
447 {
448 cmsS15Fixed16Number fix32;
449
450 // From 1.15 to 15.16
451 fix32 = v << 1;
452
453 // From fixed 15.16 to cmsFloat64Number
454 return _cms15Fixed16toDouble(fix32);
455 }
456
457
458 void CMSEXPORT cmsXYZEncoded2Float(cmsCIEXYZ* fXYZ, const cmsUInt16Number XYZ[3])
459 {
460 fXYZ -> X = XYZ2float(XYZ[0]);
461 fXYZ -> Y = XYZ2float(XYZ[1]);
462 fXYZ -> Z = XYZ2float(XYZ[2]);
463 }
464
465
466 // Returns dE on two Lab values
467 cmsFloat64Number CMSEXPORT cmsDeltaE(const cmsCIELab* Lab1, const cmsCIELab* Lab2)
468 {
469 cmsFloat64Number dL, da, db;
470
471 dL = fabs(Lab1 -> L - Lab2 -> L);
472 da = fabs(Lab1 -> a - Lab2 -> a);
473 db = fabs(Lab1 -> b - Lab2 -> b);
474
475 return pow(Sqr(dL) + Sqr(da) + Sqr(db), 0.5);
476 }
477
478
479 // Return the CIE94 Delta E
480 cmsFloat64Number CMSEXPORT cmsCIE94DeltaE(const cmsCIELab* Lab1, const cmsCIELab* Lab2)
481 {
482 cmsCIELCh LCh1, LCh2;
483 cmsFloat64Number dE, dL, dC, dh, dhsq;
484 cmsFloat64Number c12, sc, sh;
485
486 dL = fabs(Lab1 ->L - Lab2 ->L);
487
488 cmsLab2LCh(&LCh1, Lab1);
489 cmsLab2LCh(&LCh2, Lab2);
490
491 dC = fabs(LCh1.C - LCh2.C);
492 dE = cmsDeltaE(Lab1, Lab2);
493
494 dhsq = Sqr(dE) - Sqr(dL) - Sqr(dC);
495 if (dhsq < 0)
496 dh = 0;
497 else
498 dh = pow(dhsq, 0.5);
499
500 c12 = sqrt(LCh1.C * LCh2.C);
501
502 sc = 1.0 + (0.048 * c12);
503 sh = 1.0 + (0.014 * c12);
504
505 return sqrt(Sqr(dL) + Sqr(dC) / Sqr(sc) + Sqr(dh) / Sqr(sh));
506 }
507
508
509 // Auxiliary
510 static
511 cmsFloat64Number ComputeLBFD(const cmsCIELab* Lab)
512 {
513 cmsFloat64Number yt;
514
515 if (Lab->L > 7.996969)
516 yt = (Sqr((Lab->L+16)/116)*((Lab->L+16)/116))*100;
517 else
518 yt = 100 * (Lab->L / 903.3);
519
520 return (54.6 * (M_LOG10E * (log(yt + 1.5))) - 9.6);
521 }
522
523
524
525 // bfd - gets BFD(1:1) difference between Lab1, Lab2
526 cmsFloat64Number CMSEXPORT cmsBFDdeltaE(const cmsCIELab* Lab1, const cmsCIELab* Lab2)
527 {
528 cmsFloat64Number lbfd1,lbfd2,AveC,Aveh,dE,deltaL,
529 deltaC,deltah,dc,t,g,dh,rh,rc,rt,bfd;
530 cmsCIELCh LCh1, LCh2;
531
532
533 lbfd1 = ComputeLBFD(Lab1);
534 lbfd2 = ComputeLBFD(Lab2);
535 deltaL = lbfd2 - lbfd1;
536
537 cmsLab2LCh(&LCh1, Lab1);
538 cmsLab2LCh(&LCh2, Lab2);
539
540 deltaC = LCh2.C - LCh1.C;
541 AveC = (LCh1.C+LCh2.C)/2;
542 Aveh = (LCh1.h+LCh2.h)/2;
543
544 dE = cmsDeltaE(Lab1, Lab2);
545
546 if (Sqr(dE)>(Sqr(Lab2->L-Lab1->L)+Sqr(deltaC)))
547 deltah = sqrt(Sqr(dE)-Sqr(Lab2->L-Lab1->L)-Sqr(deltaC));
548 else
549 deltah =0;
550
551
552 dc = 0.035 * AveC / (1 + 0.00365 * AveC)+0.521;
553 g = sqrt(Sqr(Sqr(AveC))/(Sqr(Sqr(AveC))+14000));
554 t = 0.627+(0.055*cos((Aveh-254)/(180/M_PI))-
555 0.040*cos((2*Aveh-136)/(180/M_PI))+
556 0.070*cos((3*Aveh-31)/(180/M_PI))+
557 0.049*cos((4*Aveh+114)/(180/M_PI))-
558 0.015*cos((5*Aveh-103)/(180/M_PI)));
559
560 dh = dc*(g*t+1-g);
561 rh = -0.260*cos((Aveh-308)/(180/M_PI))-
562 0.379*cos((2*Aveh-160)/(180/M_PI))-
563 0.636*cos((3*Aveh+254)/(180/M_PI))+
564 0.226*cos((4*Aveh+140)/(180/M_PI))-
565 0.194*cos((5*Aveh+280)/(180/M_PI));
566
567 rc = sqrt((AveC*AveC*AveC*AveC*AveC*AveC)/((AveC*AveC*AveC*AveC*AveC*AveC)+70000000));
568 rt = rh*rc;
569
570 bfd = sqrt(Sqr(deltaL)+Sqr(deltaC/dc)+Sqr(deltah/dh)+(rt*(deltaC/dc)*(deltah/dh)));
571
572 return bfd;
573 }
574
575
576 // cmc - CMC(l:c) difference between Lab1, Lab2
577 cmsFloat64Number CMSEXPORT cmsCMCdeltaE(const cmsCIELab* Lab1, const cmsCIELab* Lab2, cmsFloat64Number l, cmsFloat64Number c)
578 {
579 cmsFloat64Number dE,dL,dC,dh,sl,sc,sh,t,f,cmc;
580 cmsCIELCh LCh1, LCh2;
581
582 if (Lab1 ->L == 0 && Lab2 ->L == 0) return 0;
583
584 cmsLab2LCh(&LCh1, Lab1);
585 cmsLab2LCh(&LCh2, Lab2);
586
587
588 dL = Lab2->L-Lab1->L;
589 dC = LCh2.C-LCh1.C;
590
591 dE = cmsDeltaE(Lab1, Lab2);
592
593 if (Sqr(dE)>(Sqr(dL)+Sqr(dC)))
594 dh = sqrt(Sqr(dE)-Sqr(dL)-Sqr(dC));
595 else
596 dh =0;
597
598 if ((LCh1.h > 164) && (LCh1.h < 345))
599 t = 0.56 + fabs(0.2 * cos(((LCh1.h + 168)/(180/M_PI))));
600 else
601 t = 0.36 + fabs(0.4 * cos(((LCh1.h + 35 )/(180/M_PI))));
602
603 sc = 0.0638 * LCh1.C / (1 + 0.0131 * LCh1.C) + 0.638;
604 sl = 0.040975 * Lab1->L /(1 + 0.01765 * Lab1->L);
605
606 if (Lab1->L<16)
607 sl = 0.511;
608
609 f = sqrt((LCh1.C * LCh1.C * LCh1.C * LCh1.C)/((LCh1.C * LCh1.C * LCh1.C * LCh1.C)+1900));
610 sh = sc*(t*f+1-f);
611 cmc = sqrt(Sqr(dL/(l*sl))+Sqr(dC/(c*sc))+Sqr(dh/sh));
612
613 return cmc;
614 }
615
616 // dE2000 The weightings KL, KC and KH can be modified to reflect the relative
617 // importance of lightness, chroma and hue in different industrial applications
618 cmsFloat64Number CMSEXPORT cmsCIE2000DeltaE(const cmsCIELab* Lab1, const cmsCIELab* Lab2,
619 cmsFloat64Number Kl, cmsFloat64Number Kc, cmsFloat64Number Kh)
620 {
621 cmsFloat64Number L1 = Lab1->L;
622 cmsFloat64Number a1 = Lab1->a;
623 cmsFloat64Number b1 = Lab1->b;
624 cmsFloat64Number C = sqrt( Sqr(a1) + Sqr(b1) );
625
626 cmsFloat64Number Ls = Lab2 ->L;
627 cmsFloat64Number as = Lab2 ->a;
628 cmsFloat64Number bs = Lab2 ->b;
629 cmsFloat64Number Cs = sqrt( Sqr(as) + Sqr(bs) );
630
631 cmsFloat64Number G = 0.5 * ( 1 - sqrt(pow((C + Cs) / 2 , 7.0) / (pow((C + Cs) / 2, 7.0) + pow(25.0, 7.0) ) ));
632
633 cmsFloat64Number a_p = (1 + G ) * a1;
634 cmsFloat64Number b_p = b1;
635 cmsFloat64Number C_p = sqrt( Sqr(a_p) + Sqr(b_p));
636 cmsFloat64Number h_p = atan2deg(b_p, a_p);
637
638
639 cmsFloat64Number a_ps = (1 + G) * as;
640 cmsFloat64Number b_ps = bs;
641 cmsFloat64Number C_ps = sqrt(Sqr(a_ps) + Sqr(b_ps));
642 cmsFloat64Number h_ps = atan2deg(b_ps, a_ps);
643
644 cmsFloat64Number meanC_p =(C_p + C_ps) / 2;
645
646 cmsFloat64Number hps_plus_hp = h_ps + h_p;
647 cmsFloat64Number hps_minus_hp = h_ps - h_p;
648
649 cmsFloat64Number meanh_p = fabs(hps_minus_hp) <= 180.000001 ? (hps_plus_hp)/2 :
650 (hps_plus_hp) < 360 ? (hps_plus_hp + 360)/2 :
651 (hps_plus_hp - 360)/2;
652
653 cmsFloat64Number delta_h = (hps_minus_hp) <= -180.000001 ? (hps_minus_hp + 360) :
654 (hps_minus_hp) > 180 ? (hps_minus_hp - 360) :
655 (hps_minus_hp);
656 cmsFloat64Number delta_L = (Ls - L1);
657 cmsFloat64Number delta_C = (C_ps - C_p );
658
659
660 cmsFloat64Number delta_H =2 * sqrt(C_ps*C_p) * sin(RADIANS(delta_h) / 2);
661
662 cmsFloat64Number T = 1 - 0.17 * cos(RADIANS(meanh_p-30))
663 + 0.24 * cos(RADIANS(2*meanh_p))
664 + 0.32 * cos(RADIANS(3*meanh_p + 6))
665 - 0.2 * cos(RADIANS(4*meanh_p - 63));
666
667 cmsFloat64Number Sl = 1 + (0.015 * Sqr((Ls + L1) /2- 50) )/ sqrt(20 + Sqr( (Ls+L1)/2 - 50) );
668
669 cmsFloat64Number Sc = 1 + 0.045 * (C_p + C_ps)/2;
670 cmsFloat64Number Sh = 1 + 0.015 * ((C_ps + C_p)/2) * T;
671
672 cmsFloat64Number delta_ro = 30 * exp( -Sqr(((meanh_p - 275 ) / 25)));
673
674 cmsFloat64Number Rc = 2 * sqrt(( pow(meanC_p, 7.0) )/( pow(meanC_p, 7.0) + pow(25.0, 7.0)));
675
676 cmsFloat64Number Rt = -sin(2 * RADIANS(delta_ro)) * Rc;
677
678 cmsFloat64Number deltaE00 = sqrt( Sqr(delta_L /(Sl * Kl)) +
679 Sqr(delta_C/(Sc * Kc)) +
680 Sqr(delta_H/(Sh * Kh)) +
681 Rt*(delta_C/(Sc * Kc)) * (delta_H / (Sh * Kh)));
682
683 return deltaE00;
684 }
685
686 // This function returns a number of gridpoints to be used as LUT table. It assumes same number
687 // of gripdpoints in all dimensions. Flags may override the choice.
688 cmsUInt32Number _cmsReasonableGridpointsByColorspace(cmsColorSpaceSignature Colorspace, cmsUInt32Number dwFlags)
689 {
690 cmsUInt32Number nChannels;
691
692 // Already specified?
693 if (dwFlags & 0x00FF0000) {
694 // Yes, grab'em
695 return (dwFlags >> 16) & 0xFF;
696 }
697
698 nChannels = cmsChannelsOf(Colorspace);
699
700 // HighResPrecalc is maximum resolution
701 if (dwFlags & cmsFLAGS_HIGHRESPRECALC) {
702
703 if (nChannels > 4)
704 return 7; // 7 for Hifi
705
706 if (nChannels == 4) // 23 for CMYK
707 return 23;
708
709 return 49; // 49 for RGB and others
710 }
711
712
713 // LowResPrecal is lower resolution
714 if (dwFlags & cmsFLAGS_LOWRESPRECALC) {
715
716 if (nChannels > 4)
717 return 6; // 6 for more than 4 channels
718
719 if (nChannels == 1)
720 return 33; // For monochrome
721
722 return 17; // 17 for remaining
723 }
724
725 // Default values
726 if (nChannels > 4)
727 return 7; // 7 for Hifi
728
729 if (nChannels == 4)
730 return 17; // 17 for CMYK
731
732 return 33; // 33 for RGB
733 }
734
735
736 cmsBool _cmsEndPointsBySpace(cmsColorSpaceSignature Space,
737 cmsUInt16Number **White,
738 cmsUInt16Number **Black,
739 cmsUInt32Number *nOutputs)
740 {
741 // Only most common spaces
742
743 static cmsUInt16Number RGBblack[4] = { 0, 0, 0 };
744 static cmsUInt16Number RGBwhite[4] = { 0xffff, 0xffff, 0xffff };
745 static cmsUInt16Number CMYKblack[4] = { 0xffff, 0xffff, 0xffff, 0xffff }; // 400% of ink
746 static cmsUInt16Number CMYKwhite[4] = { 0, 0, 0, 0 };
747 static cmsUInt16Number LABblack[4] = { 0, 0x8080, 0x8080 }; // V4 Lab encoding
748 static cmsUInt16Number LABwhite[4] = { 0xFFFF, 0x8080, 0x8080 };
749 static cmsUInt16Number CMYblack[4] = { 0xffff, 0xffff, 0xffff };
750 static cmsUInt16Number CMYwhite[4] = { 0, 0, 0 };
751 static cmsUInt16Number Grayblack[4] = { 0 };
752 static cmsUInt16Number GrayWhite[4] = { 0xffff };
753
754 switch (Space) {
755
756 case cmsSigGrayData: if (White) *White = GrayWhite;
757 if (Black) *Black = Grayblack;
758 if (nOutputs) *nOutputs = 1;
759 return TRUE;
760
761 case cmsSigRgbData: if (White) *White = RGBwhite;
762 if (Black) *Black = RGBblack;
763 if (nOutputs) *nOutputs = 3;
764 return TRUE;
765
766 case cmsSigLabData: if (White) *White = LABwhite;
767 if (Black) *Black = LABblack;
768 if (nOutputs) *nOutputs = 3;
769 return TRUE;
770
771 case cmsSigCmykData: if (White) *White = CMYKwhite;
772 if (Black) *Black = CMYKblack;
773 if (nOutputs) *nOutputs = 4;
774 return TRUE;
775
776 case cmsSigCmyData: if (White) *White = CMYwhite;
777 if (Black) *Black = CMYblack;
778 if (nOutputs) *nOutputs = 3;
779 return TRUE;
780
781 default:;
782 }
783
784 return FALSE;
785 }
786
787
788
789 // Several utilities -------------------------------------------------------
790
791 // Translate from our colorspace to ICC representation
792
793 cmsColorSpaceSignature CMSEXPORT _cmsICCcolorSpace(int OurNotation)
794 {
795 switch (OurNotation) {
796
797 case 1:
798 case PT_GRAY: return cmsSigGrayData;
799
800 case 2:
801 case PT_RGB: return cmsSigRgbData;
802
803 case PT_CMY: return cmsSigCmyData;
804 case PT_CMYK: return cmsSigCmykData;
805 case PT_YCbCr:return cmsSigYCbCrData;
806 case PT_YUV: return cmsSigLuvData;
807 case PT_XYZ: return cmsSigXYZData;
808
809 case PT_LabV2:
810 case PT_Lab: return cmsSigLabData;
811
812 case PT_YUVK: return cmsSigLuvKData;
813 case PT_HSV: return cmsSigHsvData;
814 case PT_HLS: return cmsSigHlsData;
815 case PT_Yxy: return cmsSigYxyData;
816
817 case PT_MCH1: return cmsSigMCH1Data;
818 case PT_MCH2: return cmsSigMCH2Data;
819 case PT_MCH3: return cmsSigMCH3Data;
820 case PT_MCH4: return cmsSigMCH4Data;
821 case PT_MCH5: return cmsSigMCH5Data;
822 case PT_MCH6: return cmsSigMCH6Data;
823 case PT_MCH7: return cmsSigMCH7Data;
824 case PT_MCH8: return cmsSigMCH8Data;
825
826 case PT_MCH9: return cmsSigMCH9Data;
827 case PT_MCH10: return cmsSigMCHAData;
828 case PT_MCH11: return cmsSigMCHBData;
829 case PT_MCH12: return cmsSigMCHCData;
830 case PT_MCH13: return cmsSigMCHDData;
831 case PT_MCH14: return cmsSigMCHEData;
832 case PT_MCH15: return cmsSigMCHFData;
833
834 default: return (cmsColorSpaceSignature) 0;
835 }
836 }
837
838
839 int CMSEXPORT _cmsLCMScolorSpace(cmsColorSpaceSignature ProfileSpace)
840 {
841 switch (ProfileSpace) {
842
843 case cmsSigGrayData: return PT_GRAY;
844 case cmsSigRgbData: return PT_RGB;
845 case cmsSigCmyData: return PT_CMY;
846 case cmsSigCmykData: return PT_CMYK;
847 case cmsSigYCbCrData:return PT_YCbCr;
848 case cmsSigLuvData: return PT_YUV;
849 case cmsSigXYZData: return PT_XYZ;
850 case cmsSigLabData: return PT_Lab;
851 case cmsSigLuvKData: return PT_YUVK;
852 case cmsSigHsvData: return PT_HSV;
853 case cmsSigHlsData: return PT_HLS;
854 case cmsSigYxyData: return PT_Yxy;
855
856 case cmsSig1colorData:
857 case cmsSigMCH1Data: return PT_MCH1;
858
859 case cmsSig2colorData:
860 case cmsSigMCH2Data: return PT_MCH2;
861
862 case cmsSig3colorData:
863 case cmsSigMCH3Data: return PT_MCH3;
864
865 case cmsSig4colorData:
866 case cmsSigMCH4Data: return PT_MCH4;
867
868 case cmsSig5colorData:
869 case cmsSigMCH5Data: return PT_MCH5;
870
871 case cmsSig6colorData:
872 case cmsSigMCH6Data: return PT_MCH6;
873
874 case cmsSigMCH7Data:
875 case cmsSig7colorData:return PT_MCH7;
876
877 case cmsSigMCH8Data:
878 case cmsSig8colorData:return PT_MCH8;
879
880 case cmsSigMCH9Data:
881 case cmsSig9colorData:return PT_MCH9;
882
883 case cmsSigMCHAData:
884 case cmsSig10colorData:return PT_MCH10;
885
886 case cmsSigMCHBData:
887 case cmsSig11colorData:return PT_MCH11;
888
889 case cmsSigMCHCData:
890 case cmsSig12colorData:return PT_MCH12;
891
892 case cmsSigMCHDData:
893 case cmsSig13colorData:return PT_MCH13;
894
895 case cmsSigMCHEData:
896 case cmsSig14colorData:return PT_MCH14;
897
898 case cmsSigMCHFData:
899 case cmsSig15colorData:return PT_MCH15;
900
901 default: return (cmsColorSpaceSignature) 0;
902 }
903 }
904
905
906 cmsUInt32Number CMSEXPORT cmsChannelsOf(cmsColorSpaceSignature ColorSpace)
907 {
908 switch (ColorSpace) {
909
910 case cmsSigMCH1Data:
911 case cmsSig1colorData:
912 case cmsSigGrayData: return 1;
913
914 case cmsSigMCH2Data:
915 case cmsSig2colorData: return 2;
916
917 case cmsSigXYZData:
918 case cmsSigLabData:
919 case cmsSigLuvData:
920 case cmsSigYCbCrData:
921 case cmsSigYxyData:
922 case cmsSigRgbData:
923 case cmsSigHsvData:
924 case cmsSigHlsData:
925 case cmsSigCmyData:
926 case cmsSigMCH3Data:
927 case cmsSig3colorData: return 3;
928
929 case cmsSigLuvKData:
930 case cmsSigCmykData:
931 case cmsSigMCH4Data:
932 case cmsSig4colorData: return 4;
933
934 case cmsSigMCH5Data:
935 case cmsSig5colorData: return 5;
936
937 case cmsSigMCH6Data:
938 case cmsSig6colorData: return 6;
939
940 case cmsSigMCH7Data:
941 case cmsSig7colorData: return 7;
942
943 case cmsSigMCH8Data:
944 case cmsSig8colorData: return 8;
945
946 case cmsSigMCH9Data:
947 case cmsSig9colorData: return 9;
948
949 case cmsSigMCHAData:
950 case cmsSig10colorData: return 10;
951
952 case cmsSigMCHBData:
953 case cmsSig11colorData: return 11;
954
955 case cmsSigMCHCData:
956 case cmsSig12colorData: return 12;
957
958 case cmsSigMCHDData:
959 case cmsSig13colorData: return 13;
960
961 case cmsSigMCHEData:
962 case cmsSig14colorData: return 14;
963
964 case cmsSigMCHFData:
965 case cmsSig15colorData: return 15;
966
967 default: return 3;
968 }
969 }