cmsHPROFILE LCMSEXPORT cmsCreateLinearizationDeviceLink(icColorSpaceSignature ColorSpace,
LPGAMMATABLE TransferFunctions[])
{
cmsHPROFILE hICC;
LPLUT Lut;
hICC = _cmsCreateProfilePlaceholder();
if (!hICC) // can't allocate
return NULL;
cmsSetDeviceClass(hICC, icSigLinkClass);
cmsSetColorSpace(hICC, ColorSpace);
cmsSetPCS(hICC, ColorSpace);
cmsSetRenderingIntent(hICC, INTENT_PERCEPTUAL);
// Creates a LUT with prelinearization step only
Lut = cmsAllocLUT();
if (Lut == NULL) return NULL;
// Set up channels
Lut ->InputChan = Lut ->OutputChan = _cmsChannelsOf(ColorSpace);
// Copy tables to LUT
cmsAllocLinearTable(Lut, TransferFunctions, 1);
// Create tags
cmsAddTag(hICC, icSigDeviceMfgDescTag, (LPVOID) "(lcms internal)");
cmsAddTag(hICC, icSigProfileDescriptionTag, (LPVOID) "lcms linearization device link");
cmsAddTag(hICC, icSigDeviceModelDescTag, (LPVOID) "linearization built-in");
cmsAddTag(hICC, icSigMediaWhitePointTag, (LPVOID) cmsD50_XYZ());
cmsAddTag(hICC, icSigAToB0Tag, (LPVOID) Lut);
// LUT is already on virtual profile
cmsFreeLUT(Lut);
// Ok, done
return hICC;
}
cmsHPROFILE LCMSEXPORT cmsCreateNULLProfile(void)
{
cmsHPROFILE hProfile;
LPLUT Lut;
LPGAMMATABLE EmptyTab;
hProfile = _cmsCreateProfilePlaceholder();
if (!hProfile) // can't allocate
return NULL;
cmsSetDeviceClass(hProfile, icSigOutputClass);
cmsSetColorSpace(hProfile, icSigGrayData);
cmsSetPCS(hProfile, icSigLabData);
// An empty LUTs is all we need
Lut = cmsAllocLUT();
if (Lut == NULL) {
cmsCloseProfile(hProfile);
return NULL;
}
Lut -> InputChan = 3;
Lut -> OutputChan = 1;
EmptyTab = cmsAllocGamma(2);
EmptyTab ->GammaTable[0] = 0;
EmptyTab ->GammaTable[1] = 0;
cmsAllocLinearTable(Lut, &EmptyTab, 2);
cmsAddTag(hProfile, icSigBToA0Tag, (LPVOID) Lut);
cmsFreeLUT(Lut);
cmsFreeGamma(EmptyTab);
return hProfile;
}
cmsHPROFILE LCMSEXPORT f_cmsCreateBCHSWabstractProfile(int nLUTPoints,
double Exposure,
double Bright,
double Contrast,
double Hue,
double Saturation,
LPcmsCIExyY current_wp,
LPcmsCIExyY destination_wp,
LPGAMMATABLE Tables [])
{
cmsHPROFILE hICC;
LPLUT Lut;
BCHSWADJUSTS bchsw;
cmsCIExyY WhitePnt;
bchsw.Exposure = Exposure;
bchsw.Brightness = Bright;
bchsw.Contrast = Contrast;
bchsw.Hue = Hue;
bchsw.Saturation = Saturation;
cmsxyY2XYZ(&bchsw.WPsrc, current_wp);
cmsxyY2XYZ(&bchsw.WPdest, destination_wp);
hICC = _cmsCreateProfilePlaceholder();
if (!hICC) // can't allocate
return NULL;
cmsSetDeviceClass(hICC, icSigAbstractClass);
cmsSetColorSpace(hICC, icSigLabData);
cmsSetPCS(hICC, icSigLabData);
cmsSetRenderingIntent(hICC, INTENT_PERCEPTUAL);
// Creates a LUT with 3D grid only
Lut = cmsAllocLUT();
cmsAlloc3DGrid(Lut, nLUTPoints, 3, 3);
if (Tables != NULL)
cmsAllocLinearTable (Lut, Tables, 1);
if (!cmsSample3DGrid(Lut, bchswSampler, (LPVOID) &bchsw, 0)) {
// Shouldn't reach here
cmsFreeLUT(Lut);
cmsCloseProfile(hICC);
return NULL;
}
// Create tags
cmsAddTag(hICC, icSigDeviceMfgDescTag, (LPVOID) "(f-spot internal)");
cmsAddTag(hICC, icSigProfileDescriptionTag, (LPVOID) "f-spot BCHSW abstract profile");
cmsAddTag(hICC, icSigDeviceModelDescTag, (LPVOID) "BCHSW built-in");
cmsAddTag(hICC, icSigMediaWhitePointTag, (LPVOID) cmsD50_XYZ());
cmsAddTag(hICC, icSigAToB0Tag, (LPVOID) Lut);
// LUT is already on virtual profile
cmsFreeLUT(Lut);
// Ok, done
return hICC;
}
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
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;
}
void _cmsComputePrelinearizationTablesFromXFORM(cmsHTRANSFORM h[], int nTransforms, LPLUT Grid)
{
LPGAMMATABLE Trans[MAXCHANNELS];
unsigned int t, i, v;
int j;
WORD In[MAXCHANNELS], Out[MAXCHANNELS];
BOOL 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 RGB to RGB transforms
if ((InputXForm ->EntryColorSpace != icSigRgbData) ||
(OutputXForm->ExitColorSpace != icSigRgbData)) 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]);
}
static
BOOL CreateLUTS(LPMONITORPROFILERDATA sys, LPLUT* A2B, LPLUT* B2A)
{
LPLUT AToB0 = cmsAllocLUT();
LPLUT BToA0 = cmsAllocLUT();
LPGAMMATABLE LabG;
cmsCIExyY xyY;
cmsAlloc3DGrid(AToB0, sys->hdr.CLUTPoints, 3, 3);
cmsAlloc3DGrid(BToA0, sys->hdr.CLUTPoints, 3, 3);
/* cmsAllocLinearTable(AToB0, sys -> Prelinearization, 1); */
sys->ReverseTables[0] = cmsReverseGamma(4096, sys ->Prelinearization[0]);
sys->ReverseTables[1] = cmsReverseGamma(4096, sys ->Prelinearization[1]);
sys->ReverseTables[2] = cmsReverseGamma(4096, sys ->Prelinearization[2]);
/* Prelinearization */
LabG = cmsBuildGamma(4096, 3.0);
sys -> PreLab[0] = cmsJoinGammaEx(LabG, sys ->Prelinearization[0], 4096);
sys -> PreLab[1] = cmsJoinGammaEx(LabG, sys ->Prelinearization[1], 4096);
sys -> PreLab[2] = cmsJoinGammaEx(LabG, sys ->Prelinearization[2], 4096);
sys -> PreLabRev[0] = cmsJoinGammaEx(sys ->Prelinearization[0], LabG, 4096);
sys -> PreLabRev[1] = cmsJoinGammaEx(sys ->Prelinearization[1], LabG, 4096);
sys -> PreLabRev[2] = cmsJoinGammaEx(sys ->Prelinearization[2], LabG, 4096);
cmsFreeGamma(LabG);
cmsAllocLinearTable(AToB0, sys->PreLabRev, 1);
cmsAllocLinearTable(BToA0, sys->PreLab, 2);
/* Set CIECAM97s parameters */
sys -> hdr.device.whitePoint.X = sys -> hdr.WhitePoint.X * 100.;
sys -> hdr.device.whitePoint.Y = sys -> hdr.WhitePoint.Y * 100.;
sys -> hdr.device.whitePoint.Z = sys -> hdr.WhitePoint.Z * 100.;
/* Normalize White point for CIECAM97s model */
cmsXYZ2xyY(&xyY, &sys -> hdr.device.whitePoint);
xyY.Y = 100.;
cmsxyY2XYZ(&sys -> hdr.device.whitePoint, &xyY);
sys->hdr.hDevice = cmsCIECAM97sInit(&sys->hdr.device);
sys->hdr.hPCS = cmsCIECAM97sInit(&sys->hdr.PCS);
cmsSample3DGrid(AToB0, RegressionSamplerA2B, sys, 0);
cmsSample3DGrid(BToA0, RegressionSamplerB2A, sys, 0);
cmsCIECAM97sDone(sys->hdr.hDevice);
cmsCIECAM97sDone(sys->hdr.hPCS);
cmsAddTag(sys->hdr.hProfile, icSigAToB0Tag, AToB0);
cmsAddTag(sys->hdr.hProfile, icSigBToA0Tag, BToA0);
/* This is the 0xff00 trick to map white at lattice point */
BToA0 ->Matrix.v[0].n[0] = DOUBLE_TO_FIXED((65535.0 / 65280.0));
*A2B = AToB0;
*B2A = BToA0;
cmsFreeGammaTriple(sys->ReverseTables);
cmsFreeGammaTriple(sys->PreLab);
cmsFreeGammaTriple(sys->PreLabRev);
return true;
}
int main(int argc, char *argv[])
{
LPLUT AToB0, BToA0;
LPGAMMATABLE PreLinear[3];
LPGAMMATABLE Lin;
CARGO Cargo;
cmsHPROFILE hProfile;
cmsCIEXYZ wp;
fprintf(stderr, "Creating lcmscmy.icm...");
wp.X = 55.6549;
wp.Y = 59.0485;
wp.Z = 72.5494;
cmsXYZ2xyY(&Cus, &wp);
InitCargo(&Cargo);
hProfile = cmsCreateLabProfile(&Cus);
// Create linearization
Lin = CreateLinear();
PreLinear[0] = Lin;
PreLinear[1] = Lin;
PreLinear[2] = Lin;
AToB0 = cmsAllocLUT();
BToA0 = cmsAllocLUT();
cmsAlloc3DGrid(AToB0, 33, 3, 3);
cmsAlloc3DGrid(BToA0, 33, 3, 3);
cmsSample3DGrid(AToB0, Reverse, &Cargo, 0);
cmsSample3DGrid(BToA0, Forward, &Cargo, 0);
cmsAllocLinearTable(AToB0, PreLinear, 1);
cmsAllocLinearTable(BToA0, PreLinear, 2);
cmsAddTag(hProfile, icSigAToB0Tag, AToB0);
cmsAddTag(hProfile, icSigBToA0Tag, BToA0);
cmsSetColorSpace(hProfile, icSigCmyData);
cmsAddTag(hProfile, icSigProfileDescriptionTag, "Little cms CMY mixing");
cmsAddTag(hProfile, icSigCopyrightTag, "Copyright (c) Marti Maria, 2002. All rights reserved.");
cmsAddTag(hProfile, icSigDeviceMfgDescTag, "Little cms");
cmsAddTag(hProfile, icSigDeviceModelDescTag, "CMY mixing");
_cmsSaveProfile(hProfile, "lcmscmy.icm");
cmsFreeGamma(Lin);
cmsFreeLUT(AToB0);
cmsFreeLUT(BToA0);
cmsCloseProfile(hProfile);
FreeCargo(&Cargo);
fprintf(stderr, "Done.\n");
return 0;
}
