591 lines
20 KiB
C
591 lines
20 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"
|
|
|
|
|
|
// Auxiliary: append a Lab identity after the given sequence of profiles
|
|
// and return the transform. Lab profile is closed, rest of profiles are kept open.
|
|
cmsHTRANSFORM _cmsChain2Lab(cmsContext ContextID,
|
|
cmsUInt32Number nProfiles,
|
|
cmsUInt32Number InputFormat,
|
|
cmsUInt32Number OutputFormat,
|
|
const cmsUInt32Number Intents[],
|
|
const cmsHPROFILE hProfiles[],
|
|
const cmsBool BPC[],
|
|
const cmsFloat64Number AdaptationStates[],
|
|
cmsUInt32Number dwFlags)
|
|
{
|
|
cmsHTRANSFORM xform;
|
|
cmsHPROFILE hLab;
|
|
cmsHPROFILE ProfileList[256];
|
|
cmsBool BPCList[256];
|
|
cmsFloat64Number AdaptationList[256];
|
|
cmsUInt32Number IntentList[256];
|
|
cmsUInt32Number i;
|
|
|
|
// This is a rather big number and there is no need of dynamic memory
|
|
// since we are adding a profile, 254 + 1 = 255 and this is the limit
|
|
if (nProfiles > 254) return NULL;
|
|
|
|
// The output space
|
|
hLab = cmsCreateLab4ProfileTHR(ContextID, NULL);
|
|
if (hLab == NULL) return NULL;
|
|
|
|
// Create a copy of parameters
|
|
for (i=0; i < nProfiles; i++) {
|
|
|
|
ProfileList[i] = hProfiles[i];
|
|
BPCList[i] = BPC[i];
|
|
AdaptationList[i] = AdaptationStates[i];
|
|
IntentList[i] = Intents[i];
|
|
}
|
|
|
|
// Place Lab identity at chain's end.
|
|
ProfileList[nProfiles] = hLab;
|
|
BPCList[nProfiles] = 0;
|
|
AdaptationList[nProfiles] = 1.0;
|
|
IntentList[nProfiles] = INTENT_RELATIVE_COLORIMETRIC;
|
|
|
|
// Create the transform
|
|
xform = cmsCreateExtendedTransform(ContextID, nProfiles + 1, ProfileList,
|
|
BPCList,
|
|
IntentList,
|
|
AdaptationList,
|
|
NULL, 0,
|
|
InputFormat,
|
|
OutputFormat,
|
|
dwFlags);
|
|
|
|
cmsCloseProfile(hLab);
|
|
|
|
return xform;
|
|
}
|
|
|
|
|
|
// 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
|
|
cmsToneCurve* ComputeKToLstar(cmsContext ContextID,
|
|
cmsUInt32Number nPoints,
|
|
cmsUInt32Number nProfiles,
|
|
const cmsUInt32Number Intents[],
|
|
const cmsHPROFILE hProfiles[],
|
|
const cmsBool BPC[],
|
|
const cmsFloat64Number AdaptationStates[],
|
|
cmsUInt32Number dwFlags)
|
|
{
|
|
cmsToneCurve* out = NULL;
|
|
cmsUInt32Number i;
|
|
cmsHTRANSFORM xform;
|
|
cmsCIELab Lab;
|
|
cmsFloat32Number cmyk[4];
|
|
cmsFloat32Number* SampledPoints;
|
|
|
|
xform = _cmsChain2Lab(ContextID, nProfiles, TYPE_CMYK_FLT, TYPE_Lab_DBL, Intents, hProfiles, BPC, AdaptationStates, dwFlags);
|
|
if (xform == NULL) return NULL;
|
|
|
|
SampledPoints = (cmsFloat32Number*) _cmsCalloc(ContextID, nPoints, sizeof(cmsFloat32Number));
|
|
if (SampledPoints == NULL) goto Error;
|
|
|
|
for (i=0; i < nPoints; i++) {
|
|
|
|
cmyk[0] = 0;
|
|
cmyk[1] = 0;
|
|
cmyk[2] = 0;
|
|
cmyk[3] = (cmsFloat32Number) ((i * 100.0) / (nPoints-1));
|
|
|
|
cmsDoTransform(xform, cmyk, &Lab, 1);
|
|
SampledPoints[i]= (cmsFloat32Number) (1.0 - Lab.L / 100.0); // Negate K for easier operation
|
|
}
|
|
|
|
out = cmsBuildTabulatedToneCurveFloat(ContextID, nPoints, SampledPoints);
|
|
|
|
Error:
|
|
|
|
cmsDeleteTransform(xform);
|
|
if (SampledPoints) _cmsFree(ContextID, SampledPoints);
|
|
|
|
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.
|
|
cmsToneCurve* _cmsBuildKToneCurve(cmsContext ContextID,
|
|
cmsUInt32Number nPoints,
|
|
cmsUInt32Number nProfiles,
|
|
const cmsUInt32Number Intents[],
|
|
const cmsHPROFILE hProfiles[],
|
|
const cmsBool BPC[],
|
|
const cmsFloat64Number AdaptationStates[],
|
|
cmsUInt32Number dwFlags)
|
|
{
|
|
cmsToneCurve *in, *out, *KTone;
|
|
|
|
// Make sure CMYK -> CMYK
|
|
if (cmsGetColorSpace(hProfiles[0]) != cmsSigCmykData ||
|
|
cmsGetColorSpace(hProfiles[nProfiles-1])!= cmsSigCmykData) return NULL;
|
|
|
|
|
|
// Make sure last is an output profile
|
|
if (cmsGetDeviceClass(hProfiles[nProfiles - 1]) != cmsSigOutputClass) 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(ContextID, nPoints, nProfiles - 1, Intents, hProfiles, BPC, AdaptationStates, dwFlags);
|
|
if (in == NULL) return NULL;
|
|
|
|
out = ComputeKToLstar(ContextID, nPoints, 1,
|
|
Intents + (nProfiles - 1),
|
|
&hProfiles [nProfiles - 1],
|
|
BPC + (nProfiles - 1),
|
|
AdaptationStates + (nProfiles - 1),
|
|
dwFlags);
|
|
if (out == NULL) {
|
|
cmsFreeToneCurve(in);
|
|
return NULL;
|
|
}
|
|
|
|
// Build the relationship. This effectively limits the maximum accuracy to 16 bits, but
|
|
// since this is used on black-preserving LUTs, we are not losing accuracy in any case
|
|
KTone = cmsJoinToneCurve(ContextID, in, out, nPoints);
|
|
|
|
// Get rid of components
|
|
cmsFreeToneCurve(in); cmsFreeToneCurve(out);
|
|
|
|
// Something went wrong...
|
|
if (KTone == NULL) return NULL;
|
|
|
|
// Make sure it is monotonic
|
|
if (!cmsIsToneCurveMonotonic(KTone)) {
|
|
cmsFreeToneCurve(KTone);
|
|
return NULL;
|
|
}
|
|
|
|
return KTone;
|
|
}
|
|
|
|
|
|
// Gamut LUT Creation -----------------------------------------------------------------------------------------
|
|
|
|
// Used by gamut & softproofing
|
|
|
|
typedef struct {
|
|
|
|
cmsHTRANSFORM hInput; // From whatever input color space. 16 bits to DBL
|
|
cmsHTRANSFORM hForward, hReverse; // Transforms going from Lab to colorant and back
|
|
cmsFloat64Number Thereshold; // The thereshold after which is considered out of gamut
|
|
|
|
} GAMUTCHAIN;
|
|
|
|
// 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 const cmsUInt16Number In[], register cmsUInt16Number Out[], register void* Cargo)
|
|
{
|
|
GAMUTCHAIN* t = (GAMUTCHAIN* ) Cargo;
|
|
cmsCIELab LabIn1, LabOut1;
|
|
cmsCIELab LabIn2, LabOut2;
|
|
cmsUInt16Number Proof[cmsMAXCHANNELS], Proof2[cmsMAXCHANNELS];
|
|
cmsFloat64Number dE1, dE2, ErrorRatio;
|
|
|
|
// Assume in-gamut by default.
|
|
ErrorRatio = 1.0;
|
|
|
|
// Convert input to Lab
|
|
cmsDoTransform(t -> hInput, In, &LabIn1, 1);
|
|
|
|
// converts from PCS to colorant. This always
|
|
// does return in-gamut values,
|
|
cmsDoTransform(t -> hForward, &LabIn1, Proof, 1);
|
|
|
|
// Now, do the inverse, from colorant to PCS.
|
|
cmsDoTransform(t -> hReverse, Proof, &LabOut1, 1);
|
|
|
|
memmove(&LabIn2, &LabOut1, sizeof(cmsCIELab));
|
|
|
|
// Try again, but this time taking Check as input
|
|
cmsDoTransform(t -> hForward, &LabOut1, Proof2, 1);
|
|
cmsDoTransform(t -> hReverse, Proof2, &LabOut2, 1);
|
|
|
|
// Take difference of direct value
|
|
dE1 = cmsDeltaE(&LabIn1, &LabOut1);
|
|
|
|
// 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] = (cmsUInt16Number) _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] = (cmsUInt16Number) _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 truly 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.
|
|
|
|
cmsPipeline* _cmsCreateGamutCheckPipeline(cmsContext ContextID,
|
|
cmsHPROFILE hProfiles[],
|
|
cmsBool BPC[],
|
|
cmsUInt32Number Intents[],
|
|
cmsFloat64Number AdaptationStates[],
|
|
cmsUInt32Number nGamutPCSposition,
|
|
cmsHPROFILE hGamut)
|
|
{
|
|
cmsHPROFILE hLab;
|
|
cmsPipeline* Gamut;
|
|
cmsStage* CLUT;
|
|
cmsUInt32Number dwFormat;
|
|
GAMUTCHAIN Chain;
|
|
int nChannels, nGridpoints;
|
|
cmsColorSpaceSignature ColorSpace;
|
|
cmsUInt32Number i;
|
|
cmsHPROFILE ProfileList[256];
|
|
cmsBool BPCList[256];
|
|
cmsFloat64Number AdaptationList[256];
|
|
cmsUInt32Number IntentList[256];
|
|
|
|
memset(&Chain, 0, sizeof(GAMUTCHAIN));
|
|
|
|
|
|
if (nGamutPCSposition <= 0 || nGamutPCSposition > 255) {
|
|
cmsSignalError(ContextID, cmsERROR_RANGE, "Wrong position of PCS. 1..255 expected, %d found.", nGamutPCSposition);
|
|
return NULL;
|
|
}
|
|
|
|
hLab = cmsCreateLab4ProfileTHR(ContextID, NULL);
|
|
if (hLab == NULL) return NULL;
|
|
|
|
|
|
// 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 (cmsIsMatrixShaper(hGamut)) {
|
|
|
|
Chain.Thereshold = 1.0;
|
|
}
|
|
else {
|
|
Chain.Thereshold = ERR_THERESHOLD;
|
|
}
|
|
|
|
|
|
// Create a copy of parameters
|
|
for (i=0; i < nGamutPCSposition; i++) {
|
|
ProfileList[i] = hProfiles[i];
|
|
BPCList[i] = BPC[i];
|
|
AdaptationList[i] = AdaptationStates[i];
|
|
IntentList[i] = Intents[i];
|
|
}
|
|
|
|
// Fill Lab identity
|
|
ProfileList[nGamutPCSposition] = hLab;
|
|
BPCList[nGamutPCSposition] = 0;
|
|
AdaptationList[nGamutPCSposition] = 1.0;
|
|
IntentList[nGamutPCSposition] = INTENT_RELATIVE_COLORIMETRIC;
|
|
|
|
|
|
ColorSpace = cmsGetColorSpace(hGamut);
|
|
|
|
nChannels = cmsChannelsOf(ColorSpace);
|
|
nGridpoints = _cmsReasonableGridpointsByColorspace(ColorSpace, cmsFLAGS_HIGHRESPRECALC);
|
|
dwFormat = (CHANNELS_SH(nChannels)|BYTES_SH(2));
|
|
|
|
// 16 bits to Lab double
|
|
Chain.hInput = cmsCreateExtendedTransform(ContextID,
|
|
nGamutPCSposition + 1,
|
|
ProfileList,
|
|
BPCList,
|
|
IntentList,
|
|
AdaptationList,
|
|
NULL, 0,
|
|
dwFormat, TYPE_Lab_DBL,
|
|
cmsFLAGS_NOCACHE);
|
|
|
|
|
|
// Does create the forward step. Lab double to device
|
|
dwFormat = (CHANNELS_SH(nChannels)|BYTES_SH(2));
|
|
Chain.hForward = cmsCreateTransformTHR(ContextID,
|
|
hLab, TYPE_Lab_DBL,
|
|
hGamut, dwFormat,
|
|
INTENT_RELATIVE_COLORIMETRIC,
|
|
cmsFLAGS_NOCACHE);
|
|
|
|
// Does create the backwards step
|
|
Chain.hReverse = cmsCreateTransformTHR(ContextID, hGamut, dwFormat,
|
|
hLab, TYPE_Lab_DBL,
|
|
INTENT_RELATIVE_COLORIMETRIC,
|
|
cmsFLAGS_NOCACHE);
|
|
|
|
|
|
// All ok?
|
|
if (Chain.hInput && 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 = cmsPipelineAlloc(ContextID, 3, 1);
|
|
if (Gamut != NULL) {
|
|
|
|
CLUT = cmsStageAllocCLut16bit(ContextID, nGridpoints, nChannels, 1, NULL);
|
|
if (!cmsPipelineInsertStage(Gamut, cmsAT_BEGIN, CLUT)) {
|
|
cmsPipelineFree(Gamut);
|
|
Gamut = NULL;
|
|
}
|
|
else {
|
|
cmsStageSampleCLut16bit(CLUT, GamutSampler, (void*) &Chain, 0);
|
|
}
|
|
}
|
|
}
|
|
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);
|
|
if (hLab) cmsCloseProfile(hLab);
|
|
|
|
// And return computed hull
|
|
return Gamut;
|
|
}
|
|
|
|
// Total Area Coverage estimation ----------------------------------------------------------------
|
|
|
|
typedef struct {
|
|
cmsUInt32Number nOutputChans;
|
|
cmsHTRANSFORM hRoundTrip;
|
|
cmsFloat32Number MaxTAC;
|
|
cmsFloat32Number MaxInput[cmsMAXCHANNELS];
|
|
|
|
} cmsTACestimator;
|
|
|
|
|
|
// This callback just accounts the maximum ink dropped in the given node. It does not populate any
|
|
// memory, as the destination table is NULL. Its only purpose it to know the global maximum.
|
|
static
|
|
int EstimateTAC(register const cmsUInt16Number In[], register cmsUInt16Number Out[], register void * Cargo)
|
|
{
|
|
cmsTACestimator* bp = (cmsTACestimator*) Cargo;
|
|
cmsFloat32Number RoundTrip[cmsMAXCHANNELS];
|
|
cmsUInt32Number i;
|
|
cmsFloat32Number Sum;
|
|
|
|
|
|
// Evaluate the xform
|
|
cmsDoTransform(bp->hRoundTrip, In, RoundTrip, 1);
|
|
|
|
// All all amounts of ink
|
|
for (Sum=0, i=0; i < bp ->nOutputChans; i++)
|
|
Sum += RoundTrip[i];
|
|
|
|
// If above maximum, keep track of input values
|
|
if (Sum > bp ->MaxTAC) {
|
|
|
|
bp ->MaxTAC = Sum;
|
|
|
|
for (i=0; i < bp ->nOutputChans; i++) {
|
|
bp ->MaxInput[i] = In[i];
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
cmsUNUSED_PARAMETER(Out);
|
|
}
|
|
|
|
|
|
// Detect Total area coverage of the profile
|
|
cmsFloat64Number CMSEXPORT cmsDetectTAC(cmsHPROFILE hProfile)
|
|
{
|
|
cmsTACestimator bp;
|
|
cmsUInt32Number dwFormatter;
|
|
cmsUInt32Number GridPoints[MAX_INPUT_DIMENSIONS];
|
|
cmsHPROFILE hLab;
|
|
cmsContext ContextID = cmsGetProfileContextID(hProfile);
|
|
|
|
// TAC only works on output profiles
|
|
if (cmsGetDeviceClass(hProfile) != cmsSigOutputClass) {
|
|
return 0;
|
|
}
|
|
|
|
// Create a fake formatter for result
|
|
dwFormatter = cmsFormatterForColorspaceOfProfile(hProfile, 4, TRUE);
|
|
|
|
bp.nOutputChans = T_CHANNELS(dwFormatter);
|
|
bp.MaxTAC = 0; // Initial TAC is 0
|
|
|
|
// for safety
|
|
if (bp.nOutputChans >= cmsMAXCHANNELS) return 0;
|
|
|
|
hLab = cmsCreateLab4ProfileTHR(ContextID, NULL);
|
|
if (hLab == NULL) return 0;
|
|
// Setup a roundtrip on perceptual intent in output profile for TAC estimation
|
|
bp.hRoundTrip = cmsCreateTransformTHR(ContextID, hLab, TYPE_Lab_16,
|
|
hProfile, dwFormatter, INTENT_PERCEPTUAL, cmsFLAGS_NOOPTIMIZE|cmsFLAGS_NOCACHE);
|
|
|
|
cmsCloseProfile(hLab);
|
|
if (bp.hRoundTrip == NULL) return 0;
|
|
|
|
// For L* we only need black and white. For C* we need many points
|
|
GridPoints[0] = 6;
|
|
GridPoints[1] = 74;
|
|
GridPoints[2] = 74;
|
|
|
|
|
|
if (!cmsSliceSpace16(3, GridPoints, EstimateTAC, &bp)) {
|
|
bp.MaxTAC = 0;
|
|
}
|
|
|
|
cmsDeleteTransform(bp.hRoundTrip);
|
|
|
|
// Results in %
|
|
return bp.MaxTAC;
|
|
}
|
|
|
|
|
|
// Carefully, clamp on CIELab space.
|
|
|
|
cmsBool CMSEXPORT cmsDesaturateLab(cmsCIELab* 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 FALSE;
|
|
}
|
|
|
|
// 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 TRUE;
|
|
}
|
|
|
|
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(0, cmsERROR_RANGE, "Invalid angle");
|
|
return FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
}
|