Coverage Report

Created: 2023-03-26 06:45

/src/lcms/src/cmssamp.c
Line
Count
Source (jump to first uncovered line)
1
//---------------------------------------------------------------------------------
2
//
3
//  Little Color Management System
4
//  Copyright (c) 1998-2023 Marti Maria Saguer
5
//
6
// Permission is hereby granted, free of charge, to any person obtaining
7
// a copy of this software and associated documentation files (the "Software"),
8
// to deal in the Software without restriction, including without limitation
9
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
10
// and/or sell copies of the Software, and to permit persons to whom the Software
11
// is furnished to do so, subject to the following conditions:
12
//
13
// The above copyright notice and this permission notice shall be included in
14
// all copies or substantial portions of the Software.
15
//
16
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
18
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
20
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
21
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
22
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23
//
24
//---------------------------------------------------------------------------------
25
//
26
27
#include "lcms2_internal.h"
28
29
30
231k
#define cmsmin(a, b) (((a) < (b)) ? (a) : (b))
31
50
#define cmsmax(a, b) (((a) > (b)) ? (a) : (b))
32
33
// This file contains routines for resampling and LUT optimization, black point detection
34
// and black preservation.
35
36
// Black point detection -------------------------------------------------------------------------
37
38
39
// PCS -> PCS round trip transform, always uses relative intent on the device -> pcs
40
static
41
cmsHTRANSFORM CreateRoundtripXForm(cmsHPROFILE hProfile, cmsUInt32Number nIntent)
42
642
{
43
642
    cmsContext ContextID = cmsGetProfileContextID(hProfile);
44
642
    cmsHPROFILE hLab = cmsCreateLab4ProfileTHR(ContextID, NULL);
45
642
    cmsHTRANSFORM xform;
46
642
    cmsBool BPC[4] = { FALSE, FALSE, FALSE, FALSE };
47
642
    cmsFloat64Number States[4] = { 1.0, 1.0, 1.0, 1.0 };
48
642
    cmsHPROFILE hProfiles[4];
49
642
    cmsUInt32Number Intents[4];
50
51
642
    hProfiles[0] = hLab; hProfiles[1] = hProfile; hProfiles[2] = hProfile; hProfiles[3] = hLab;
52
642
    Intents[0]   = INTENT_RELATIVE_COLORIMETRIC; Intents[1] = nIntent; Intents[2] = INTENT_RELATIVE_COLORIMETRIC; Intents[3] = INTENT_RELATIVE_COLORIMETRIC;
53
54
642
    xform =  cmsCreateExtendedTransform(ContextID, 4, hProfiles, BPC, Intents,
55
642
        States, NULL, 0, TYPE_Lab_DBL, TYPE_Lab_DBL, cmsFLAGS_NOCACHE|cmsFLAGS_NOOPTIMIZE);
56
57
642
    cmsCloseProfile(hLab);
58
642
    return xform;
59
642
}
60
61
// Use darker colorants to obtain black point. This works in the relative colorimetric intent and
62
// assumes more ink results in darker colors. No ink limit is assumed.
63
static
64
cmsBool  BlackPointAsDarkerColorant(cmsHPROFILE    hInput,
65
                                    cmsUInt32Number Intent,
66
                                    cmsCIEXYZ* BlackPoint,
67
                                    cmsUInt32Number dwFlags)
68
5.81k
{
69
5.81k
    cmsUInt16Number *Black;
70
5.81k
    cmsHTRANSFORM xform;
71
5.81k
    cmsColorSpaceSignature Space;
72
5.81k
    cmsUInt32Number nChannels;
73
5.81k
    cmsUInt32Number dwFormat;
74
5.81k
    cmsHPROFILE hLab;
75
5.81k
    cmsCIELab  Lab;
76
5.81k
    cmsCIEXYZ  BlackXYZ;
77
5.81k
    cmsContext ContextID = cmsGetProfileContextID(hInput);
78
79
    // If the profile does not support input direction, assume Black point 0
80
5.81k
    if (!cmsIsIntentSupported(hInput, Intent, LCMS_USED_AS_INPUT)) {
81
82
692
        BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
83
692
        return FALSE;
84
692
    }
85
86
    // Create a formatter which has n channels and no floating point
87
5.12k
    dwFormat = cmsFormatterForColorspaceOfProfile(hInput, 2, FALSE);
88
89
    // Try to get black by using black colorant
90
5.12k
    Space = cmsGetColorSpace(hInput);
91
92
    // This function returns darker colorant in 16 bits for several spaces
93
5.12k
    if (!_cmsEndPointsBySpace(Space, NULL, &Black, &nChannels)) {
94
95
1.29k
        BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
96
1.29k
        return FALSE;
97
1.29k
    }
98
99
3.82k
    if (nChannels != T_CHANNELS(dwFormat)) {
100
0
       BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
101
0
       return FALSE;
102
0
    }
103
104
    // Lab will be used as the output space, but lab2 will avoid recursion
105
3.82k
    hLab = cmsCreateLab2ProfileTHR(ContextID, NULL);
106
3.82k
    if (hLab == NULL) {
107
0
       BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
108
0
       return FALSE;
109
0
    }
110
111
    // Create the transform
112
3.82k
    xform = cmsCreateTransformTHR(ContextID, hInput, dwFormat,
113
3.82k
                                hLab, TYPE_Lab_DBL, Intent, cmsFLAGS_NOOPTIMIZE|cmsFLAGS_NOCACHE);
114
3.82k
    cmsCloseProfile(hLab);
115
116
3.82k
    if (xform == NULL) {
117
118
        // Something went wrong. Get rid of open resources and return zero as black
119
256
        BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
120
256
        return FALSE;
121
256
    }
122
123
    // Convert black to Lab
124
3.56k
    cmsDoTransform(xform, Black, &Lab, 1);
125
126
    // Force it to be neutral, check for inconsistences
127
3.56k
    Lab.a = Lab.b = 0;
128
3.56k
    if (Lab.L > 50 || Lab.L < 0) Lab.L = 0;
129
130
    // Free the resources
131
3.56k
    cmsDeleteTransform(xform);
132
133
    // Convert from Lab (which is now clipped) to XYZ.
134
3.56k
    cmsLab2XYZ(NULL, &BlackXYZ, &Lab);
135
136
3.56k
    if (BlackPoint != NULL)
137
3.56k
        *BlackPoint = BlackXYZ;
138
139
3.56k
    return TRUE;
140
141
0
    cmsUNUSED_PARAMETER(dwFlags);
142
0
}
143
144
// Get a black point of output CMYK profile, discounting any ink-limiting embedded
145
// in the profile. For doing that, we use perceptual intent in input direction:
146
// Lab (0, 0, 0) -> [Perceptual] Profile -> CMYK -> [Rel. colorimetric] Profile -> Lab
147
static
148
cmsBool BlackPointUsingPerceptualBlack(cmsCIEXYZ* BlackPoint, cmsHPROFILE hProfile)
149
409
{
150
409
    cmsHTRANSFORM hRoundTrip;
151
409
    cmsCIELab LabIn, LabOut;
152
409
    cmsCIEXYZ  BlackXYZ;
153
154
     // Is the intent supported by the profile?
155
409
    if (!cmsIsIntentSupported(hProfile, INTENT_PERCEPTUAL, LCMS_USED_AS_INPUT)) {
156
157
11
        BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
158
11
        return TRUE;
159
11
    }
160
161
398
    hRoundTrip = CreateRoundtripXForm(hProfile, INTENT_PERCEPTUAL);
162
398
    if (hRoundTrip == NULL) {
163
261
        BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
164
261
        return FALSE;
165
261
    }
166
167
137
    LabIn.L = LabIn.a = LabIn.b = 0;
168
137
    cmsDoTransform(hRoundTrip, &LabIn, &LabOut, 1);
169
170
    // Clip Lab to reasonable limits
171
137
    if (LabOut.L > 50) LabOut.L = 50;
172
137
    LabOut.a = LabOut.b = 0;
173
174
137
    cmsDeleteTransform(hRoundTrip);
175
176
    // Convert it to XYZ
177
137
    cmsLab2XYZ(NULL, &BlackXYZ, &LabOut);
178
179
137
    if (BlackPoint != NULL)
180
137
        *BlackPoint = BlackXYZ;
181
182
137
    return TRUE;
183
398
}
184
185
// This function shouldn't exist at all -- there is such quantity of broken
186
// profiles on black point tag, that we must somehow fix chromaticity to
187
// avoid huge tint when doing Black point compensation. This function does
188
// just that. There is a special flag for using black point tag, but turned
189
// off by default because it is bogus on most profiles. The detection algorithm
190
// involves to turn BP to neutral and to use only L component.
191
cmsBool CMSEXPORT cmsDetectBlackPoint(cmsCIEXYZ* BlackPoint, cmsHPROFILE hProfile, cmsUInt32Number Intent, cmsUInt32Number dwFlags)
192
5.16k
{
193
5.16k
    cmsProfileClassSignature devClass;
194
195
    // Make sure the device class is adequate
196
5.16k
    devClass = cmsGetDeviceClass(hProfile);
197
5.16k
    if (devClass == cmsSigLinkClass ||
198
5.16k
        devClass == cmsSigAbstractClass ||
199
5.16k
        devClass == cmsSigNamedColorClass) {
200
769
            BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
201
769
            return FALSE;
202
769
    }
203
204
    // Make sure intent is adequate
205
4.39k
    if (Intent != INTENT_PERCEPTUAL &&
206
4.39k
        Intent != INTENT_RELATIVE_COLORIMETRIC &&
207
4.39k
        Intent != INTENT_SATURATION) {
208
0
            BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
209
0
            return FALSE;
210
0
    }
211
212
    // v4 + perceptual & saturation intents does have its own black point, and it is
213
    // well specified enough to use it. Black point tag is deprecated in V4.
214
4.39k
    if ((cmsGetEncodedICCversion(hProfile) >= 0x4000000) &&
215
4.39k
        (Intent == INTENT_PERCEPTUAL || Intent == INTENT_SATURATION)) {
216
217
            // Matrix shaper share MRC & perceptual intents
218
387
            if (cmsIsMatrixShaper(hProfile))
219
71
                return BlackPointAsDarkerColorant(hProfile, INTENT_RELATIVE_COLORIMETRIC, BlackPoint, 0);
220
221
            // Get Perceptual black out of v4 profiles. That is fixed for perceptual & saturation intents
222
316
            BlackPoint -> X = cmsPERCEPTUAL_BLACK_X;
223
316
            BlackPoint -> Y = cmsPERCEPTUAL_BLACK_Y;
224
316
            BlackPoint -> Z = cmsPERCEPTUAL_BLACK_Z;
225
226
316
            return TRUE;
227
387
    }
228
229
230
#ifdef CMS_USE_PROFILE_BLACK_POINT_TAG
231
232
    // v2, v4 rel/abs colorimetric
233
    if (cmsIsTag(hProfile, cmsSigMediaBlackPointTag) &&
234
        Intent == INTENT_RELATIVE_COLORIMETRIC) {
235
236
            cmsCIEXYZ *BlackPtr, BlackXYZ, UntrustedBlackPoint, TrustedBlackPoint, MediaWhite;
237
            cmsCIELab Lab;
238
239
            // If black point is specified, then use it,
240
241
            BlackPtr = cmsReadTag(hProfile, cmsSigMediaBlackPointTag);
242
            if (BlackPtr != NULL) {
243
244
                BlackXYZ = *BlackPtr;
245
                _cmsReadMediaWhitePoint(&MediaWhite, hProfile);
246
247
                // Black point is absolute XYZ, so adapt to D50 to get PCS value
248
                cmsAdaptToIlluminant(&UntrustedBlackPoint, &MediaWhite, cmsD50_XYZ(), &BlackXYZ);
249
250
                // Force a=b=0 to get rid of any chroma
251
                cmsXYZ2Lab(NULL, &Lab, &UntrustedBlackPoint);
252
                Lab.a = Lab.b = 0;
253
                if (Lab.L > 50) Lab.L = 50; // Clip to L* <= 50
254
                cmsLab2XYZ(NULL, &TrustedBlackPoint, &Lab);
255
256
                if (BlackPoint != NULL)
257
                    *BlackPoint = TrustedBlackPoint;
258
259
                return TRUE;
260
            }
261
    }
262
#endif
263
264
    // That is about v2 profiles.
265
266
    // If output profile, discount ink-limiting and that's all
267
4.00k
    if (Intent == INTENT_RELATIVE_COLORIMETRIC &&
268
4.00k
        (cmsGetDeviceClass(hProfile) == cmsSigOutputClass) &&
269
4.00k
        (cmsGetColorSpace(hProfile)  == cmsSigCmykData))
270
409
        return BlackPointUsingPerceptualBlack(BlackPoint, hProfile);
271
272
    // Nope, compute BP using current intent.
273
3.59k
    return BlackPointAsDarkerColorant(hProfile, Intent, BlackPoint, dwFlags);
274
4.00k
}
275
276
277
278
// ---------------------------------------------------------------------------------------------------------
279
280
// Least Squares Fit of a Quadratic Curve to Data
281
// http://www.personal.psu.edu/jhm/f90/lectures/lsq2.html
282
283
static
284
cmsFloat64Number RootOfLeastSquaresFitQuadraticCurve(int n, cmsFloat64Number x[], cmsFloat64Number y[])
285
48
{
286
48
    double sum_x = 0, sum_x2 = 0, sum_x3 = 0, sum_x4 = 0;
287
48
    double sum_y = 0, sum_yx = 0, sum_yx2 = 0;
288
48
    double d, a, b, c;
289
48
    int i;
290
48
    cmsMAT3 m;
291
48
    cmsVEC3 v, res;
292
293
48
    if (n < 4) return 0;
294
295
2.38k
    for (i=0; i < n; i++) {
296
297
2.33k
        double xn = x[i];
298
2.33k
        double yn = y[i];
299
300
2.33k
        sum_x  += xn;
301
2.33k
        sum_x2 += xn*xn;
302
2.33k
        sum_x3 += xn*xn*xn;
303
2.33k
        sum_x4 += xn*xn*xn*xn;
304
305
2.33k
        sum_y += yn;
306
2.33k
        sum_yx += yn*xn;
307
2.33k
        sum_yx2 += yn*xn*xn;
308
2.33k
    }
309
310
45
    _cmsVEC3init(&m.v[0], n,      sum_x,  sum_x2);
311
45
    _cmsVEC3init(&m.v[1], sum_x,  sum_x2, sum_x3);
312
45
    _cmsVEC3init(&m.v[2], sum_x2, sum_x3, sum_x4);
313
314
45
    _cmsVEC3init(&v, sum_y, sum_yx, sum_yx2);
315
316
45
    if (!_cmsMAT3solve(&res, &m, &v)) return 0;
317
318
      
319
45
    a = res.n[2];
320
45
    b = res.n[1];
321
45
    c = res.n[0];
322
323
45
    if (fabs(a) < 1.0E-10) {
324
    
325
8
        if (fabs(b) < 1.0E-10) return 0;
326
4
        return cmsmin(0, cmsmax(50, -c/b ));
327
8
    }
328
37
    else {
329
330
37
         d = b*b - 4.0 * a * c;
331
37
         if (d <= 0) {
332
12
             return 0;
333
12
         }
334
25
         else {
335
336
25
             double rt;
337
             
338
25
             if (fabs(a) < 1.0E-10) return 0;
339
340
25
             rt = (-b + sqrt(d)) / (2.0 * a);
341
342
25
             return cmsmax(0, cmsmin(50, rt));
343
25
         }
344
37
   }
345
346
45
}
347
348
349
350
// Calculates the black point of a destination profile.
351
// This algorithm comes from the Adobe paper disclosing its black point compensation method.
352
cmsBool CMSEXPORT cmsDetectDestinationBlackPoint(cmsCIEXYZ* BlackPoint, cmsHPROFILE hProfile, cmsUInt32Number Intent, cmsUInt32Number dwFlags)
353
4.18k
{
354
4.18k
    cmsColorSpaceSignature ColorSpace;
355
4.18k
    cmsHTRANSFORM hRoundTrip = NULL;
356
4.18k
    cmsCIELab InitialLab, destLab, Lab;
357
4.18k
    cmsFloat64Number inRamp[256], outRamp[256];
358
4.18k
    cmsFloat64Number MinL, MaxL;
359
4.18k
    cmsBool NearlyStraightMidrange = TRUE;  
360
4.18k
    cmsFloat64Number yRamp[256];
361
4.18k
    cmsFloat64Number x[256], y[256];
362
4.18k
    cmsFloat64Number lo, hi;
363
4.18k
    int n, l;
364
4.18k
    cmsProfileClassSignature devClass;
365
366
    // Make sure the device class is adequate
367
4.18k
    devClass = cmsGetDeviceClass(hProfile);
368
4.18k
    if (devClass == cmsSigLinkClass ||
369
4.18k
        devClass == cmsSigAbstractClass ||
370
4.18k
        devClass == cmsSigNamedColorClass) {
371
787
            BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
372
787
            return FALSE;
373
787
    }
374
375
    // Make sure intent is adequate
376
3.39k
    if (Intent != INTENT_PERCEPTUAL &&
377
3.39k
        Intent != INTENT_RELATIVE_COLORIMETRIC &&
378
3.39k
        Intent != INTENT_SATURATION) {
379
0
            BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
380
0
            return FALSE;
381
0
    }
382
383
384
    // v4 + perceptual & saturation intents does have its own black point, and it is
385
    // well specified enough to use it. Black point tag is deprecated in V4.
386
3.39k
    if ((cmsGetEncodedICCversion(hProfile) >= 0x4000000) &&
387
3.39k
        (Intent == INTENT_PERCEPTUAL || Intent == INTENT_SATURATION)) {
388
389
            // Matrix shaper share MRC & perceptual intents
390
2.38k
            if (cmsIsMatrixShaper(hProfile))
391
2.14k
                return BlackPointAsDarkerColorant(hProfile, INTENT_RELATIVE_COLORIMETRIC, BlackPoint, 0);
392
393
            // Get Perceptual black out of v4 profiles. That is fixed for perceptual & saturation intents
394
241
            BlackPoint -> X = cmsPERCEPTUAL_BLACK_X;
395
241
            BlackPoint -> Y = cmsPERCEPTUAL_BLACK_Y;
396
241
            BlackPoint -> Z = cmsPERCEPTUAL_BLACK_Z;
397
241
            return TRUE;
398
2.38k
    }
399
400
401
    // Check if the profile is lut based and gray, rgb or cmyk (7.2 in Adobe's document)
402
1.01k
    ColorSpace = cmsGetColorSpace(hProfile);
403
1.01k
    if (!cmsIsCLUT(hProfile, Intent, LCMS_USED_AS_OUTPUT ) ||
404
1.01k
        (ColorSpace != cmsSigGrayData &&
405
616
         ColorSpace != cmsSigRgbData  &&
406
684
         ColorSpace != cmsSigCmykData)) {
407
408
        // In this case, handle as input case
409
684
        return cmsDetectBlackPoint(BlackPoint, hProfile, Intent, dwFlags);
410
684
    }
411
412
    // It is one of the valid cases!, use Adobe algorithm
413
414
    
415
    // Set a first guess, that should work on good profiles.
416
330
    if (Intent == INTENT_RELATIVE_COLORIMETRIC) {
417
418
296
        cmsCIEXYZ IniXYZ;
419
420
        // calculate initial Lab as source black point
421
296
        if (!cmsDetectBlackPoint(&IniXYZ, hProfile, Intent, dwFlags)) {
422
86
            return FALSE;
423
86
        }
424
425
        // convert the XYZ to lab
426
210
        cmsXYZ2Lab(NULL, &InitialLab, &IniXYZ);
427
428
210
    } else {
429
430
        // set the initial Lab to zero, that should be the black point for perceptual and saturation
431
34
        InitialLab.L = 0;
432
34
        InitialLab.a = 0;
433
34
        InitialLab.b = 0;
434
34
    }
435
436
437
    // Step 2
438
    // ======
439
440
    // Create a roundtrip. Define a Transform BT for all x in L*a*b*
441
244
    hRoundTrip = CreateRoundtripXForm(hProfile, Intent);
442
244
    if (hRoundTrip == NULL)  return FALSE;
443
444
    // Compute ramps
445
446
58.0k
    for (l=0; l < 256; l++) {
447
448
57.8k
        Lab.L = (cmsFloat64Number) (l * 100.0) / 255.0;
449
57.8k
        Lab.a = cmsmin(50, cmsmax(-50, InitialLab.a));
450
57.8k
        Lab.b = cmsmin(50, cmsmax(-50, InitialLab.b));
451
452
57.8k
        cmsDoTransform(hRoundTrip, &Lab, &destLab, 1);
453
454
57.8k
        inRamp[l]  = Lab.L;
455
57.8k
        outRamp[l] = destLab.L;
456
57.8k
    }
457
458
    // Make monotonic
459
57.6k
    for (l = 254; l > 0; --l) {
460
57.4k
        outRamp[l] = cmsmin(outRamp[l], outRamp[l+1]);
461
57.4k
    }
462
463
    // Check
464
226
    if (! (outRamp[0] < outRamp[255])) {
465
466
74
        cmsDeleteTransform(hRoundTrip);
467
74
        BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
468
74
        return FALSE;
469
74
    }
470
471
472
    // Test for mid range straight (only on relative colorimetric)
473
152
    NearlyStraightMidrange = TRUE;
474
152
    MinL = outRamp[0]; MaxL = outRamp[255];
475
152
    if (Intent == INTENT_RELATIVE_COLORIMETRIC) {
476
      
477
35.9k
        for (l=0; l < 256; l++) {
478
479
35.8k
            if (! ((inRamp[l] <= MinL + 0.2 * (MaxL - MinL) ) ||   
480
35.8k
                (fabs(inRamp[l] - outRamp[l]) < 4.0 )))
481
16.9k
                NearlyStraightMidrange = FALSE;
482
35.8k
        }
483
484
        // If the mid range is straight (as determined above) then the 
485
        // DestinationBlackPoint shall be the same as initialLab. 
486
        // Otherwise, the DestinationBlackPoint shall be determined 
487
        // using curve fitting.
488
140
        if (NearlyStraightMidrange) {
489
490
22
            cmsLab2XYZ(NULL, BlackPoint, &InitialLab);
491
22
            cmsDeleteTransform(hRoundTrip);
492
22
            return TRUE;
493
22
        }
494
140
    }
495
496
 
497
    // curve fitting: The round-trip curve normally looks like a nearly constant section at the black point,
498
    // with a corner and a nearly straight line to the white point.  
499
33.4k
    for (l=0; l < 256; l++) {
500
    
501
33.2k
        yRamp[l] = (outRamp[l] - MinL) / (MaxL - MinL);
502
33.2k
    }
503
504
    // find the black point using the least squares error quadratic curve fitting
505
130
    if (Intent == INTENT_RELATIVE_COLORIMETRIC) {
506
118
        lo = 0.1;
507
118
        hi = 0.5;
508
118
    }
509
12
    else {
510
511
        // Perceptual and saturation
512
12
        lo = 0.03;
513
12
        hi = 0.25;
514
12
    }
515
516
    // Capture shadow points for the fitting.
517
130
    n = 0;
518
33.4k
    for (l=0; l < 256; l++) {
519
    
520
33.2k
        cmsFloat64Number ff = yRamp[l];
521
522
33.2k
        if (ff >= lo && ff < hi) {
523
2.35k
            x[n] = inRamp[l];
524
2.35k
            y[n] = yRamp[l];
525
2.35k
            n++;
526
2.35k
        }    
527
33.2k
    }
528
529
    
530
    // No suitable points
531
130
    if (n < 3 ) {
532
82
        cmsDeleteTransform(hRoundTrip);
533
82
        BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
534
82
        return FALSE;
535
82
    }
536
537
  
538
    // fit and get the vertex of quadratic curve
539
48
    Lab.L = RootOfLeastSquaresFitQuadraticCurve(n, x, y);
540
541
48
    if (Lab.L < 0.0) { // clip to zero L* if the vertex is negative
542
0
        Lab.L = 0;
543
0
    }
544
545
48
    Lab.a = InitialLab.a;
546
48
    Lab.b = InitialLab.b;
547
548
48
    cmsLab2XYZ(NULL, BlackPoint, &Lab);
549
550
48
    cmsDeleteTransform(hRoundTrip);
551
48
    return TRUE;
552
130
}