548 lines
17 KiB
C
548 lines
17 KiB
C
//---------------------------------------------------------------------------------
|
|
//
|
|
// Little Color Management System
|
|
// Copyright (c) 1998-2016 Marti Maria Saguer
|
|
//
|
|
// 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 "lcms2_internal.h"
|
|
|
|
|
|
#define cmsmin(a, b) (((a) < (b)) ? (a) : (b))
|
|
#define cmsmax(a, b) (((a) > (b)) ? (a) : (b))
|
|
|
|
// This file contains routines for resampling and LUT optimization, black point detection
|
|
// and black preservation.
|
|
|
|
// Black point detection -------------------------------------------------------------------------
|
|
|
|
|
|
// PCS -> PCS round trip transform, always uses relative intent on the device -> pcs
|
|
static
|
|
cmsHTRANSFORM CreateRoundtripXForm(cmsHPROFILE hProfile, cmsUInt32Number nIntent)
|
|
{
|
|
cmsContext ContextID = cmsGetProfileContextID(hProfile);
|
|
cmsHPROFILE hLab = cmsCreateLab4ProfileTHR(ContextID, NULL);
|
|
cmsHTRANSFORM xform;
|
|
cmsBool BPC[4] = { FALSE, FALSE, FALSE, FALSE };
|
|
cmsFloat64Number States[4] = { 1.0, 1.0, 1.0, 1.0 };
|
|
cmsHPROFILE hProfiles[4];
|
|
cmsUInt32Number Intents[4];
|
|
|
|
hProfiles[0] = hLab; hProfiles[1] = hProfile; hProfiles[2] = hProfile; hProfiles[3] = hLab;
|
|
Intents[0] = INTENT_RELATIVE_COLORIMETRIC; Intents[1] = nIntent; Intents[2] = INTENT_RELATIVE_COLORIMETRIC; Intents[3] = INTENT_RELATIVE_COLORIMETRIC;
|
|
|
|
xform = cmsCreateExtendedTransform(ContextID, 4, hProfiles, BPC, Intents,
|
|
States, NULL, 0, TYPE_Lab_DBL, TYPE_Lab_DBL, cmsFLAGS_NOCACHE|cmsFLAGS_NOOPTIMIZE);
|
|
|
|
cmsCloseProfile(hLab);
|
|
return xform;
|
|
}
|
|
|
|
// Use darker colorants to obtain black point. This works in the relative colorimetric intent and
|
|
// assumes more ink results in darker colors. No ink limit is assumed.
|
|
static
|
|
cmsBool BlackPointAsDarkerColorant(cmsHPROFILE hInput,
|
|
cmsUInt32Number Intent,
|
|
cmsCIEXYZ* BlackPoint,
|
|
cmsUInt32Number dwFlags)
|
|
{
|
|
cmsUInt16Number *Black;
|
|
cmsHTRANSFORM xform;
|
|
cmsColorSpaceSignature Space;
|
|
cmsUInt32Number nChannels;
|
|
cmsUInt32Number dwFormat;
|
|
cmsHPROFILE hLab;
|
|
cmsCIELab Lab;
|
|
cmsCIEXYZ BlackXYZ;
|
|
cmsContext ContextID = cmsGetProfileContextID(hInput);
|
|
|
|
// If the profile does not support input direction, assume Black point 0
|
|
if (!cmsIsIntentSupported(hInput, Intent, LCMS_USED_AS_INPUT)) {
|
|
|
|
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
|
|
return FALSE;
|
|
}
|
|
|
|
// Create a formatter which has n channels and floating point
|
|
dwFormat = cmsFormatterForColorspaceOfProfile(hInput, 2, FALSE);
|
|
|
|
// Try to get black by using black colorant
|
|
Space = cmsGetColorSpace(hInput);
|
|
|
|
// This function returns darker colorant in 16 bits for several spaces
|
|
if (!_cmsEndPointsBySpace(Space, NULL, &Black, &nChannels)) {
|
|
|
|
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
|
|
return FALSE;
|
|
}
|
|
|
|
if (nChannels != T_CHANNELS(dwFormat)) {
|
|
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
|
|
return FALSE;
|
|
}
|
|
|
|
// Lab will be used as the output space, but lab2 will avoid recursion
|
|
hLab = cmsCreateLab2ProfileTHR(ContextID, NULL);
|
|
if (hLab == NULL) {
|
|
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
|
|
return FALSE;
|
|
}
|
|
|
|
// Create the transform
|
|
xform = cmsCreateTransformTHR(ContextID, hInput, dwFormat,
|
|
hLab, TYPE_Lab_DBL, Intent, cmsFLAGS_NOOPTIMIZE|cmsFLAGS_NOCACHE);
|
|
cmsCloseProfile(hLab);
|
|
|
|
if (xform == NULL) {
|
|
|
|
// Something went wrong. Get rid of open resources and return zero as black
|
|
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
|
|
return FALSE;
|
|
}
|
|
|
|
// Convert black to Lab
|
|
cmsDoTransform(xform, Black, &Lab, 1);
|
|
|
|
// Force it to be neutral, clip to max. L* of 50
|
|
Lab.a = Lab.b = 0;
|
|
if (Lab.L > 50) Lab.L = 50;
|
|
|
|
// Free the resources
|
|
cmsDeleteTransform(xform);
|
|
|
|
// Convert from Lab (which is now clipped) to XYZ.
|
|
cmsLab2XYZ(NULL, &BlackXYZ, &Lab);
|
|
|
|
if (BlackPoint != NULL)
|
|
*BlackPoint = BlackXYZ;
|
|
|
|
return TRUE;
|
|
|
|
cmsUNUSED_PARAMETER(dwFlags);
|
|
}
|
|
|
|
// Get a black point of output CMYK profile, discounting any ink-limiting embedded
|
|
// in the profile. For doing that, we use perceptual intent in input direction:
|
|
// Lab (0, 0, 0) -> [Perceptual] Profile -> CMYK -> [Rel. colorimetric] Profile -> Lab
|
|
static
|
|
cmsBool BlackPointUsingPerceptualBlack(cmsCIEXYZ* BlackPoint, cmsHPROFILE hProfile)
|
|
{
|
|
cmsHTRANSFORM hRoundTrip;
|
|
cmsCIELab LabIn, LabOut;
|
|
cmsCIEXYZ BlackXYZ;
|
|
|
|
// Is the intent supported by the profile?
|
|
if (!cmsIsIntentSupported(hProfile, INTENT_PERCEPTUAL, LCMS_USED_AS_INPUT)) {
|
|
|
|
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
|
|
return TRUE;
|
|
}
|
|
|
|
hRoundTrip = CreateRoundtripXForm(hProfile, INTENT_PERCEPTUAL);
|
|
if (hRoundTrip == NULL) {
|
|
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
|
|
return FALSE;
|
|
}
|
|
|
|
LabIn.L = LabIn.a = LabIn.b = 0;
|
|
cmsDoTransform(hRoundTrip, &LabIn, &LabOut, 1);
|
|
|
|
// Clip Lab to reasonable limits
|
|
if (LabOut.L > 50) LabOut.L = 50;
|
|
LabOut.a = LabOut.b = 0;
|
|
|
|
cmsDeleteTransform(hRoundTrip);
|
|
|
|
// Convert it to XYZ
|
|
cmsLab2XYZ(NULL, &BlackXYZ, &LabOut);
|
|
|
|
if (BlackPoint != NULL)
|
|
*BlackPoint = BlackXYZ;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// This function shouldn't exist at all -- there is such quantity of broken
|
|
// profiles on black point tag, that we must somehow fix chromaticity to
|
|
// avoid huge tint when doing Black point compensation. This function does
|
|
// just that. There is a special flag for using black point tag, but turned
|
|
// off by default because it is bogus on most profiles. The detection algorithm
|
|
// involves to turn BP to neutral and to use only L component.
|
|
cmsBool CMSEXPORT cmsDetectBlackPoint(cmsCIEXYZ* BlackPoint, cmsHPROFILE hProfile, cmsUInt32Number Intent, cmsUInt32Number dwFlags)
|
|
{
|
|
cmsProfileClassSignature devClass;
|
|
|
|
// Make sure the device class is adequate
|
|
devClass = cmsGetDeviceClass(hProfile);
|
|
if (devClass == cmsSigLinkClass ||
|
|
devClass == cmsSigAbstractClass ||
|
|
devClass == cmsSigNamedColorClass) {
|
|
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
|
|
return FALSE;
|
|
}
|
|
|
|
// Make sure intent is adequate
|
|
if (Intent != INTENT_PERCEPTUAL &&
|
|
Intent != INTENT_RELATIVE_COLORIMETRIC &&
|
|
Intent != INTENT_SATURATION) {
|
|
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
|
|
return FALSE;
|
|
}
|
|
|
|
// v4 + perceptual & saturation intents does have its own black point, and it is
|
|
// well specified enough to use it. Black point tag is deprecated in V4.
|
|
if ((cmsGetEncodedICCversion(hProfile) >= 0x4000000) &&
|
|
(Intent == INTENT_PERCEPTUAL || Intent == INTENT_SATURATION)) {
|
|
|
|
// Matrix shaper share MRC & perceptual intents
|
|
if (cmsIsMatrixShaper(hProfile))
|
|
return BlackPointAsDarkerColorant(hProfile, INTENT_RELATIVE_COLORIMETRIC, BlackPoint, 0);
|
|
|
|
// Get Perceptual black out of v4 profiles. That is fixed for perceptual & saturation intents
|
|
BlackPoint -> X = cmsPERCEPTUAL_BLACK_X;
|
|
BlackPoint -> Y = cmsPERCEPTUAL_BLACK_Y;
|
|
BlackPoint -> Z = cmsPERCEPTUAL_BLACK_Z;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
#ifdef CMS_USE_PROFILE_BLACK_POINT_TAG
|
|
|
|
// v2, v4 rel/abs colorimetric
|
|
if (cmsIsTag(hProfile, cmsSigMediaBlackPointTag) &&
|
|
Intent == INTENT_RELATIVE_COLORIMETRIC) {
|
|
|
|
cmsCIEXYZ *BlackPtr, BlackXYZ, UntrustedBlackPoint, TrustedBlackPoint, MediaWhite;
|
|
cmsCIELab Lab;
|
|
|
|
// If black point is specified, then use it,
|
|
|
|
BlackPtr = cmsReadTag(hProfile, cmsSigMediaBlackPointTag);
|
|
if (BlackPtr != NULL) {
|
|
|
|
BlackXYZ = *BlackPtr;
|
|
_cmsReadMediaWhitePoint(&MediaWhite, hProfile);
|
|
|
|
// Black point is absolute XYZ, so adapt to D50 to get PCS value
|
|
cmsAdaptToIlluminant(&UntrustedBlackPoint, &MediaWhite, cmsD50_XYZ(), &BlackXYZ);
|
|
|
|
// Force a=b=0 to get rid of any chroma
|
|
cmsXYZ2Lab(NULL, &Lab, &UntrustedBlackPoint);
|
|
Lab.a = Lab.b = 0;
|
|
if (Lab.L > 50) Lab.L = 50; // Clip to L* <= 50
|
|
cmsLab2XYZ(NULL, &TrustedBlackPoint, &Lab);
|
|
|
|
if (BlackPoint != NULL)
|
|
*BlackPoint = TrustedBlackPoint;
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// That is about v2 profiles.
|
|
|
|
// If output profile, discount ink-limiting and that's all
|
|
if (Intent == INTENT_RELATIVE_COLORIMETRIC &&
|
|
(cmsGetDeviceClass(hProfile) == cmsSigOutputClass) &&
|
|
(cmsGetColorSpace(hProfile) == cmsSigCmykData))
|
|
return BlackPointUsingPerceptualBlack(BlackPoint, hProfile);
|
|
|
|
// Nope, compute BP using current intent.
|
|
return BlackPointAsDarkerColorant(hProfile, Intent, BlackPoint, dwFlags);
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------------------------------------
|
|
|
|
// Least Squares Fit of a Quadratic Curve to Data
|
|
// http://www.personal.psu.edu/jhm/f90/lectures/lsq2.html
|
|
|
|
static
|
|
cmsFloat64Number RootOfLeastSquaresFitQuadraticCurve(int n, cmsFloat64Number x[], cmsFloat64Number y[])
|
|
{
|
|
double sum_x = 0, sum_x2 = 0, sum_x3 = 0, sum_x4 = 0;
|
|
double sum_y = 0, sum_yx = 0, sum_yx2 = 0;
|
|
double d, a, b, c;
|
|
int i;
|
|
cmsMAT3 m;
|
|
cmsVEC3 v, res;
|
|
|
|
if (n < 4) return 0;
|
|
|
|
for (i=0; i < n; i++) {
|
|
|
|
double xn = x[i];
|
|
double yn = y[i];
|
|
|
|
sum_x += xn;
|
|
sum_x2 += xn*xn;
|
|
sum_x3 += xn*xn*xn;
|
|
sum_x4 += xn*xn*xn*xn;
|
|
|
|
sum_y += yn;
|
|
sum_yx += yn*xn;
|
|
sum_yx2 += yn*xn*xn;
|
|
}
|
|
|
|
_cmsVEC3init(&m.v[0], n, sum_x, sum_x2);
|
|
_cmsVEC3init(&m.v[1], sum_x, sum_x2, sum_x3);
|
|
_cmsVEC3init(&m.v[2], sum_x2, sum_x3, sum_x4);
|
|
|
|
_cmsVEC3init(&v, sum_y, sum_yx, sum_yx2);
|
|
|
|
if (!_cmsMAT3solve(&res, &m, &v)) return 0;
|
|
|
|
|
|
a = res.n[2];
|
|
b = res.n[1];
|
|
c = res.n[0];
|
|
|
|
if (fabs(a) < 1.0E-10) {
|
|
|
|
return cmsmin(0, cmsmax(50, -c/b ));
|
|
}
|
|
else {
|
|
|
|
d = b*b - 4.0 * a * c;
|
|
if (d <= 0) {
|
|
return 0;
|
|
}
|
|
else {
|
|
|
|
double rt = (-b + sqrt(d)) / (2.0 * a);
|
|
|
|
return cmsmax(0, cmsmin(50, rt));
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Calculates the black point of a destination profile.
|
|
// This algorithm comes from the Adobe paper disclosing its black point compensation method.
|
|
cmsBool CMSEXPORT cmsDetectDestinationBlackPoint(cmsCIEXYZ* BlackPoint, cmsHPROFILE hProfile, cmsUInt32Number Intent, cmsUInt32Number dwFlags)
|
|
{
|
|
cmsColorSpaceSignature ColorSpace;
|
|
cmsHTRANSFORM hRoundTrip = NULL;
|
|
cmsCIELab InitialLab, destLab, Lab;
|
|
cmsFloat64Number inRamp[256], outRamp[256];
|
|
cmsFloat64Number MinL, MaxL;
|
|
cmsBool NearlyStraightMidrange = TRUE;
|
|
cmsFloat64Number yRamp[256];
|
|
cmsFloat64Number x[256], y[256];
|
|
cmsFloat64Number lo, hi;
|
|
int n, l;
|
|
cmsProfileClassSignature devClass;
|
|
|
|
// Make sure the device class is adequate
|
|
devClass = cmsGetDeviceClass(hProfile);
|
|
if (devClass == cmsSigLinkClass ||
|
|
devClass == cmsSigAbstractClass ||
|
|
devClass == cmsSigNamedColorClass) {
|
|
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
|
|
return FALSE;
|
|
}
|
|
|
|
// Make sure intent is adequate
|
|
if (Intent != INTENT_PERCEPTUAL &&
|
|
Intent != INTENT_RELATIVE_COLORIMETRIC &&
|
|
Intent != INTENT_SATURATION) {
|
|
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// v4 + perceptual & saturation intents does have its own black point, and it is
|
|
// well specified enough to use it. Black point tag is deprecated in V4.
|
|
if ((cmsGetEncodedICCversion(hProfile) >= 0x4000000) &&
|
|
(Intent == INTENT_PERCEPTUAL || Intent == INTENT_SATURATION)) {
|
|
|
|
// Matrix shaper share MRC & perceptual intents
|
|
if (cmsIsMatrixShaper(hProfile))
|
|
return BlackPointAsDarkerColorant(hProfile, INTENT_RELATIVE_COLORIMETRIC, BlackPoint, 0);
|
|
|
|
// Get Perceptual black out of v4 profiles. That is fixed for perceptual & saturation intents
|
|
BlackPoint -> X = cmsPERCEPTUAL_BLACK_X;
|
|
BlackPoint -> Y = cmsPERCEPTUAL_BLACK_Y;
|
|
BlackPoint -> Z = cmsPERCEPTUAL_BLACK_Z;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// Check if the profile is lut based and gray, rgb or cmyk (7.2 in Adobe's document)
|
|
ColorSpace = cmsGetColorSpace(hProfile);
|
|
if (!cmsIsCLUT(hProfile, Intent, LCMS_USED_AS_OUTPUT ) ||
|
|
(ColorSpace != cmsSigGrayData &&
|
|
ColorSpace != cmsSigRgbData &&
|
|
ColorSpace != cmsSigCmykData)) {
|
|
|
|
// In this case, handle as input case
|
|
return cmsDetectBlackPoint(BlackPoint, hProfile, Intent, dwFlags);
|
|
}
|
|
|
|
// It is one of the valid cases!, use Adobe algorithm
|
|
|
|
|
|
// Set a first guess, that should work on good profiles.
|
|
if (Intent == INTENT_RELATIVE_COLORIMETRIC) {
|
|
|
|
cmsCIEXYZ IniXYZ;
|
|
|
|
// calculate initial Lab as source black point
|
|
if (!cmsDetectBlackPoint(&IniXYZ, hProfile, Intent, dwFlags)) {
|
|
return FALSE;
|
|
}
|
|
|
|
// convert the XYZ to lab
|
|
cmsXYZ2Lab(NULL, &InitialLab, &IniXYZ);
|
|
|
|
} else {
|
|
|
|
// set the initial Lab to zero, that should be the black point for perceptual and saturation
|
|
InitialLab.L = 0;
|
|
InitialLab.a = 0;
|
|
InitialLab.b = 0;
|
|
}
|
|
|
|
|
|
// Step 2
|
|
// ======
|
|
|
|
// Create a roundtrip. Define a Transform BT for all x in L*a*b*
|
|
hRoundTrip = CreateRoundtripXForm(hProfile, Intent);
|
|
if (hRoundTrip == NULL) return FALSE;
|
|
|
|
// Compute ramps
|
|
|
|
for (l=0; l < 256; l++) {
|
|
|
|
Lab.L = (cmsFloat64Number) (l * 100.0) / 255.0;
|
|
Lab.a = cmsmin(50, cmsmax(-50, InitialLab.a));
|
|
Lab.b = cmsmin(50, cmsmax(-50, InitialLab.b));
|
|
|
|
cmsDoTransform(hRoundTrip, &Lab, &destLab, 1);
|
|
|
|
inRamp[l] = Lab.L;
|
|
outRamp[l] = destLab.L;
|
|
}
|
|
|
|
// Make monotonic
|
|
for (l = 254; l > 0; --l) {
|
|
outRamp[l] = cmsmin(outRamp[l], outRamp[l+1]);
|
|
}
|
|
|
|
// Check
|
|
if (! (outRamp[0] < outRamp[255])) {
|
|
|
|
cmsDeleteTransform(hRoundTrip);
|
|
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// Test for mid range straight (only on relative colorimetric)
|
|
NearlyStraightMidrange = TRUE;
|
|
MinL = outRamp[0]; MaxL = outRamp[255];
|
|
if (Intent == INTENT_RELATIVE_COLORIMETRIC) {
|
|
|
|
for (l=0; l < 256; l++) {
|
|
|
|
if (! ((inRamp[l] <= MinL + 0.2 * (MaxL - MinL) ) ||
|
|
(fabs(inRamp[l] - outRamp[l]) < 4.0 )))
|
|
NearlyStraightMidrange = FALSE;
|
|
}
|
|
|
|
// If the mid range is straight (as determined above) then the
|
|
// DestinationBlackPoint shall be the same as initialLab.
|
|
// Otherwise, the DestinationBlackPoint shall be determined
|
|
// using curve fitting.
|
|
if (NearlyStraightMidrange) {
|
|
|
|
cmsLab2XYZ(NULL, BlackPoint, &InitialLab);
|
|
cmsDeleteTransform(hRoundTrip);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
// curve fitting: The round-trip curve normally looks like a nearly constant section at the black point,
|
|
// with a corner and a nearly straight line to the white point.
|
|
for (l=0; l < 256; l++) {
|
|
|
|
yRamp[l] = (outRamp[l] - MinL) / (MaxL - MinL);
|
|
}
|
|
|
|
// find the black point using the least squares error quadratic curve fitting
|
|
if (Intent == INTENT_RELATIVE_COLORIMETRIC) {
|
|
lo = 0.1;
|
|
hi = 0.5;
|
|
}
|
|
else {
|
|
|
|
// Perceptual and saturation
|
|
lo = 0.03;
|
|
hi = 0.25;
|
|
}
|
|
|
|
// Capture shadow points for the fitting.
|
|
n = 0;
|
|
for (l=0; l < 256; l++) {
|
|
|
|
cmsFloat64Number ff = yRamp[l];
|
|
|
|
if (ff >= lo && ff < hi) {
|
|
x[n] = inRamp[l];
|
|
y[n] = yRamp[l];
|
|
n++;
|
|
}
|
|
}
|
|
|
|
|
|
// No suitable points
|
|
if (n < 3 ) {
|
|
cmsDeleteTransform(hRoundTrip);
|
|
BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// fit and get the vertex of quadratic curve
|
|
Lab.L = RootOfLeastSquaresFitQuadraticCurve(n, x, y);
|
|
|
|
if (Lab.L < 0.0) { // clip to zero L* if the vertex is negative
|
|
Lab.L = 0;
|
|
}
|
|
|
|
Lab.a = InitialLab.a;
|
|
Lab.b = InitialLab.b;
|
|
|
|
cmsLab2XYZ(NULL, BlackPoint, &Lab);
|
|
|
|
cmsDeleteTransform(hRoundTrip);
|
|
return TRUE;
|
|
}
|