LPGAMMATABLE _cmsBuildKToneCurve(cmsHTRANSFORM hCMYK2CMYK, int nPoints) { LPGAMMATABLE in, out; LPGAMMATABLE KTone; _LPcmsTRANSFORM p = (_LPcmsTRANSFORM) hCMYK2CMYK; // Make sure CMYK -> CMYK if (p -> EntryColorSpace != icSigCmykData || p -> ExitColorSpace != icSigCmykData) 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(p ->InputProfile, nPoints, p->Intent, p -> dwOriginalFlags); out = ComputeKToLstar(p ->OutputProfile, nPoints, p->Intent, p -> dwOriginalFlags); // Build the relationship KTone = cmsJoinGamma(in, out); cmsFreeGamma(in); cmsFreeGamma(out); // Make sure it is monotonic if (!IsMonotonic(KTone)) { cmsFreeGamma(KTone); return NULL; } return KTone; }
static cmsHPROFILE OpenProfile(const char* File) { cmsHPROFILE h; if (!File) return cmsCreate_sRGBProfile(); if (stricmp(File, "*Lab") == 0) return cmsCreateLabProfile(NULL); if (stricmp(File, "*XYZ") == 0) return cmsCreateXYZProfile(); if (stricmp(File, "*srgb") == 0) return cmsCreate_sRGBProfile(); if (stricmp(File, "*Gray22") == 0) { LPGAMMATABLE Gamma = cmsBuildGamma(256, 2.2); cmsHPROFILE hProfile = cmsCreateGrayProfile(cmsD50_xyY(), Gamma); cmsFreeGamma(Gamma); return hProfile; } if (stricmp(File, "*Lin2222") == 0) { LPGAMMATABLE Gamma = cmsBuildGamma(256, 2.2); LPGAMMATABLE Gamma4[4]; cmsHPROFILE hProfile; Gamma4[0] = Gamma4[1] = Gamma4[2] = Gamma4[3] = Gamma; hProfile = cmsCreateLinearizationDeviceLink(icSigCmykData, Gamma4); cmsFreeGamma(Gamma); return hProfile; } h = cmsOpenProfileFromFile(File, "r"); if (cmsGetDeviceClass(h) == icSigNamedColorClass) FatalError("ERROR: Cannot make devicelink of named color profiles!"); return h; }
// Create the ICC virtual profile for sRGB space cmsHPROFILE LCMSEXPORT cmsCreate_sRGBProfile(void) { cmsCIExyY D65; cmsCIExyYTRIPLE Rec709Primaries = { {0.6400, 0.3300, 1.0}, {0.3000, 0.6000, 1.0}, {0.1500, 0.0600, 1.0} }; LPGAMMATABLE Gamma22[3]; cmsHPROFILE hsRGB; cmsWhitePointFromTemp(6504, &D65); Gamma22[0] = Gamma22[1] = Gamma22[2] = Build_sRGBGamma(); hsRGB = cmsCreateRGBProfile(&D65, &Rec709Primaries, Gamma22); cmsFreeGamma(Gamma22[0]); if (hsRGB == NULL) return NULL; cmsAddTag(hsRGB, icSigDeviceMfgDescTag, (LPVOID) "(lcms internal)"); cmsAddTag(hsRGB, icSigDeviceModelDescTag, (LPVOID) "sRGB built-in"); cmsAddTag(hsRGB, icSigProfileDescriptionTag, (LPVOID) "sRGB built-in"); return hsRGB; }
static cmsHPROFILE OpenProfile(const char* File) { if (!File) return cmsCreate_sRGBProfile(); if (stricmp(File, "*sRGB") == 0) return cmsCreate_sRGBProfile(NULL); if (stricmp(File, "*Lab") == 0) return cmsCreateLabProfile(NULL); if (stricmp(File, "*LabD65") == 0) { cmsCIExyY D65xyY; cmsWhitePointFromTemp(6504, &D65xyY); return cmsCreateLabProfile(&D65xyY); } if (stricmp(File, "*XYZ") == 0) return cmsCreateXYZProfile(); if (stricmp(File, "*Gray22") == 0) { LPGAMMATABLE Gamma = cmsBuildGamma(256, 2.2); cmsHPROFILE hProfile = cmsCreateGrayProfile(cmsD50_xyY(), Gamma); cmsFreeGamma(Gamma); return hProfile; } return cmsOpenProfileFromFile(File, "r"); }
mng_cmsprof mnglcms_createsrgbprofile (void) { cmsCIExyY D65; cmsCIExyYTRIPLE Rec709Primaries = { {0.6400, 0.3300, 1.0}, {0.3000, 0.6000, 1.0}, {0.1500, 0.0600, 1.0} }; LPGAMMATABLE Gamma24[3]; mng_cmsprof hsRGB; cmsWhitePointFromTemp(6504, &D65); Gamma24[0] = Gamma24[1] = Gamma24[2] = cmsBuildGamma(256, 2.4); hsRGB = cmsCreateRGBProfile(&D65, &Rec709Primaries, Gamma24); cmsFreeGamma(Gamma24[0]); return hsRGB; }
static PyObject * pycms_CreateGrayProfile(PyObject *self, PyObject *args) { cmsHPROFILE hProfile; LPGAMMATABLE gamma; cmsErrorAction(LCMS_ERROR_IGNORE); gamma = cmsBuildGamma(256, 2.2); hProfile = cmsCreateGrayProfile(cmsD50_xyY(), gamma); cmsFreeGamma(gamma); if(hProfile==NULL) { Py_INCREF(Py_None); return Py_None; } return Py_BuildValue("O", PyCObject_FromVoidPtr((void *)hProfile, (void *)cmsCloseProfile)); }
static cmsHPROFILE CreateRGBSpace(void) { cmsHPROFILE hProfile; LPGAMMATABLE Gamma3[3]; cmsCIExyYTRIPLE CIEPrimaries = { {0.7355,0.2645 }, {0.2658,0.7243 }, {0.1669,0.0085}}; Gamma3[0] = Gamma3[1] = Gamma3[2] = cmsBuildGamma(4096, 4.5); hProfile = cmsCreateRGBProfile(&Cus, &CIEPrimaries, Gamma3); cmsFreeGamma(Gamma3[0]); return hProfile; }
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; }
static cmsHPROFILE GetTIFFProfile(TIFF* in) { cmsCIExyYTRIPLE Primaries; float* chr; cmsCIExyY WhitePoint; float* wp; int i; LPGAMMATABLE Gamma[3]; LPWORD gmr, gmg, gmb; cmsHPROFILE hProfile; DWORD EmbedLen; LPBYTE EmbedBuffer; if (IgnoreEmbedded) return NULL; if (TIFFGetField(in, TIFFTAG_ICCPROFILE, &EmbedLen, &EmbedBuffer)) { hProfile = cmsOpenProfileFromMem(EmbedBuffer, EmbedLen); if (Verbose) { fprintf(stdout, " (Embedded profile found)\n"); fprintf(stdout, "Product name: %s\n", cmsTakeProductName(hProfile)); fprintf(stdout, "Description : %s\n", cmsTakeProductDesc(hProfile)); fflush(stdout); } if (hProfile != NULL && SaveEmbedded != NULL) SaveMemoryBlock(EmbedBuffer, EmbedLen, SaveEmbedded); if (hProfile) return hProfile; } // Try to see if "colorimetric" tiff if (TIFFGetField(in, TIFFTAG_PRIMARYCHROMATICITIES, &chr)) { Primaries.Red.x = chr[0]; Primaries.Red.y = chr[1]; Primaries.Green.x = chr[2]; Primaries.Green.y = chr[3]; Primaries.Blue.x = chr[4]; Primaries.Blue.y = chr[5]; Primaries.Red.Y = Primaries.Green.Y = Primaries.Blue.Y = 1.0; if (TIFFGetField(in, TIFFTAG_WHITEPOINT, &wp)) { WhitePoint.x = wp[0]; WhitePoint.y = wp[1]; WhitePoint.Y = 1.0; // Transferfunction is a bit harder.... for (i=0; i < 3; i++) Gamma[i] = cmsAllocGamma(256); TIFFGetFieldDefaulted(in, TIFFTAG_TRANSFERFUNCTION, &gmr, &gmg, &gmb); CopyMemory(Gamma[0]->GammaTable, gmr, 256*sizeof(WORD)); CopyMemory(Gamma[1]->GammaTable, gmg, 256*sizeof(WORD)); CopyMemory(Gamma[2]->GammaTable, gmb, 256*sizeof(WORD)); hProfile = cmsCreateRGBProfile(&WhitePoint, &Primaries, Gamma); for (i=0; i < 3; i++) cmsFreeGamma(Gamma[i]); if (Verbose) { fprintf(stdout, " (Colorimetric TIFF)\n"); } return hProfile; } } return NULL; }
mng_retcode mng_init_full_cms (mng_datap pData, mng_bool bGlobal, mng_bool bObject, mng_bool bRetrobj) { mng_cmsprof hProf; mng_cmstrans hTrans; mng_imagep pImage = MNG_NULL; mng_imagedatap pBuf = MNG_NULL; #ifdef MNG_SUPPORT_TRACE MNG_TRACE (pData, MNG_FN_INIT_FULL_CMS, MNG_LC_START); #endif if (bObject) /* use object if present ? */ { /* current object ? */ if ((mng_imagep)pData->pCurrentobj) pImage = (mng_imagep)pData->pCurrentobj; else /* if not; use object 0 */ pImage = (mng_imagep)pData->pObjzero; } if (bRetrobj) /* retrieving from an object ? */ pImage = (mng_imagep)pData->pRetrieveobj; if (pImage) /* are we using an object ? */ pBuf = pImage->pImgbuf; /* then address the buffer */ if ((!pBuf) || (!pBuf->bCorrected)) /* is the buffer already corrected ? */ { #ifndef MNG_SKIPCHUNK_iCCP if (((pBuf) && (pBuf->bHasICCP)) || ((bGlobal) && (pData->bHasglobalICCP))) { if (!pData->hProf2) /* output profile not defined ? */ { /* then assume sRGB !! */ pData->hProf2 = mnglcms_createsrgbprofile (); if (!pData->hProf2) /* handle error ? */ MNG_ERRORL (pData, MNG_LCMS_NOHANDLE); } if ((pBuf) && (pBuf->bHasICCP)) /* generate a profile handle */ hProf = cmsOpenProfileFromMem (pBuf->pProfile, pBuf->iProfilesize); else hProf = cmsOpenProfileFromMem (pData->pGlobalProfile, pData->iGlobalProfilesize); pData->hProf1 = hProf; /* save for future use */ if (!hProf) /* handle error ? */ MNG_ERRORL (pData, MNG_LCMS_NOHANDLE); #ifndef MNG_NO_16BIT_SUPPORT if (pData->bIsRGBA16) /* 16-bit intermediates ? */ hTrans = cmsCreateTransform (hProf, TYPE_RGBA_16_SE, pData->hProf2, TYPE_RGBA_16_SE, INTENT_PERCEPTUAL, MNG_CMS_FLAGS); else #endif hTrans = cmsCreateTransform (hProf, TYPE_RGBA_8, pData->hProf2, TYPE_RGBA_8, INTENT_PERCEPTUAL, MNG_CMS_FLAGS); pData->hTrans = hTrans; /* save for future use */ if (!hTrans) /* handle error ? */ MNG_ERRORL (pData, MNG_LCMS_NOTRANS); /* load color-correction routine */ pData->fCorrectrow = (mng_fptr)mng_correct_full_cms; return MNG_NOERROR; /* and done */ } else #endif if (((pBuf) && (pBuf->bHasSRGB)) || ((bGlobal) && (pData->bHasglobalSRGB))) { mng_uint8 iIntent; if (pData->bIssRGB) /* sRGB system ? */ return MNG_NOERROR; /* no conversion required */ if (!pData->hProf3) /* sRGB profile not defined ? */ { /* then create it implicitly !! */ pData->hProf3 = mnglcms_createsrgbprofile (); if (!pData->hProf3) /* handle error ? */ MNG_ERRORL (pData, MNG_LCMS_NOHANDLE); } hProf = pData->hProf3; /* convert from sRGB profile */ if ((pBuf) && (pBuf->bHasSRGB)) /* determine rendering intent */ iIntent = pBuf->iRenderingintent; else iIntent = pData->iGlobalRendintent; if (pData->bIsRGBA16) /* 16-bit intermediates ? */ hTrans = cmsCreateTransform (hProf, TYPE_RGBA_16_SE, pData->hProf2, TYPE_RGBA_16_SE, iIntent, MNG_CMS_FLAGS); else hTrans = cmsCreateTransform (hProf, TYPE_RGBA_8, pData->hProf2, TYPE_RGBA_8, iIntent, MNG_CMS_FLAGS); pData->hTrans = hTrans; /* save for future use */ if (!hTrans) /* handle error ? */ MNG_ERRORL (pData, MNG_LCMS_NOTRANS); /* load color-correction routine */ pData->fCorrectrow = (mng_fptr)mng_correct_full_cms; return MNG_NOERROR; /* and done */ } else if ( (((pBuf) && (pBuf->bHasCHRM)) || ((bGlobal) && (pData->bHasglobalCHRM))) && ( ((pBuf) && (pBuf->bHasGAMA) && (pBuf->iGamma > 0)) || ((bGlobal) && (pData->bHasglobalGAMA) && (pData->iGlobalGamma > 0)) ) ) { mng_CIExyY sWhitepoint; mng_CIExyYTRIPLE sPrimaries; mng_gammatabp pGammatable[3]; mng_float dGamma; if (!pData->hProf2) /* output profile not defined ? */ { /* then assume sRGB !! */ pData->hProf2 = mnglcms_createsrgbprofile (); if (!pData->hProf2) /* handle error ? */ MNG_ERRORL (pData, MNG_LCMS_NOHANDLE); } #ifndef MNG_SKIPCHUNK_cHRM if ((pBuf) && (pBuf->bHasCHRM)) /* local cHRM ? */ { sWhitepoint.x = (mng_float)pBuf->iWhitepointx / 100000; sWhitepoint.y = (mng_float)pBuf->iWhitepointy / 100000; sPrimaries.Red.x = (mng_float)pBuf->iPrimaryredx / 100000; sPrimaries.Red.y = (mng_float)pBuf->iPrimaryredy / 100000; sPrimaries.Green.x = (mng_float)pBuf->iPrimarygreenx / 100000; sPrimaries.Green.y = (mng_float)pBuf->iPrimarygreeny / 100000; sPrimaries.Blue.x = (mng_float)pBuf->iPrimarybluex / 100000; sPrimaries.Blue.y = (mng_float)pBuf->iPrimarybluey / 100000; } else { sWhitepoint.x = (mng_float)pData->iGlobalWhitepointx / 100000; sWhitepoint.y = (mng_float)pData->iGlobalWhitepointy / 100000; sPrimaries.Red.x = (mng_float)pData->iGlobalPrimaryredx / 100000; sPrimaries.Red.y = (mng_float)pData->iGlobalPrimaryredy / 100000; sPrimaries.Green.x = (mng_float)pData->iGlobalPrimarygreenx / 100000; sPrimaries.Green.y = (mng_float)pData->iGlobalPrimarygreeny / 100000; sPrimaries.Blue.x = (mng_float)pData->iGlobalPrimarybluex / 100000; sPrimaries.Blue.y = (mng_float)pData->iGlobalPrimarybluey / 100000; } #endif sWhitepoint.Y = /* Y component is always 1.0 */ sPrimaries.Red.Y = sPrimaries.Green.Y = sPrimaries.Blue.Y = 1.0; if ((pBuf) && (pBuf->bHasGAMA)) /* get the gamma value */ dGamma = (mng_float)pBuf->iGamma / 100000; else dGamma = (mng_float)pData->iGlobalGamma / 100000; dGamma = pData->dViewgamma / dGamma; pGammatable [0] = /* and build the lookup tables */ pGammatable [1] = pGammatable [2] = cmsBuildGamma (256, dGamma); if (!pGammatable [0]) /* enough memory ? */ MNG_ERRORL (pData, MNG_LCMS_NOMEM); /* create the profile */ hProf = cmsCreateRGBProfile (&sWhitepoint, &sPrimaries, pGammatable); cmsFreeGamma (pGammatable [0]); /* free the temporary gamma tables ? */ /* yes! but just the one! */ pData->hProf1 = hProf; /* save for future use */ if (!hProf) /* handle error ? */ MNG_ERRORL (pData, MNG_LCMS_NOHANDLE); if (pData->bIsRGBA16) /* 16-bit intermediates ? */ hTrans = cmsCreateTransform (hProf, TYPE_RGBA_16_SE, pData->hProf2, TYPE_RGBA_16_SE, INTENT_PERCEPTUAL, MNG_CMS_FLAGS); else hTrans = cmsCreateTransform (hProf, TYPE_RGBA_8, pData->hProf2, TYPE_RGBA_8, INTENT_PERCEPTUAL, MNG_CMS_FLAGS); pData->hTrans = hTrans; /* save for future use */ if (!hTrans) /* handle error ? */ MNG_ERRORL (pData, MNG_LCMS_NOTRANS); /* load color-correction routine */ pData->fCorrectrow = (mng_fptr)mng_correct_full_cms; return MNG_NOERROR; /* and done */ } } #ifdef MNG_SUPPORT_TRACE MNG_TRACE (pData, MNG_FN_INIT_FULL_CMS, MNG_LC_END); #endif /* if we get here, we'll only do gamma */ return mng_init_gamma_only (pData, bGlobal, bObject, bRetrobj); }
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; }