utils/matlab/icctrans.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
FatalError
MatLabErrorHandler
xoptinit
xgetopt
SizeOfArrayType
GetNumberOfPixels
AllocateOutputArray
MakeFormatDescriptor
OpenProfile
GetFlags
OpenTransforms
ApplyTransforms
CloseTransforms
HandleSwitches
PrintHelp
mexFunction
//
//  Little cms
//  Copyright (C) 1998-2010 Marti Maria, Ignacio Ruiz de Conejo
//
// 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 "mex.h"

#include "lcms2.h"
#include "string.h"
#include "stdarg.h"

// xgetopt() interface -----------------------------------------------------

static int   xoptind;    
static char *xoptarg; 
static int   xopterr;  
static char  *letP;
static char   SW = '-';

// ------------------------------------------------------------------------


static int  Verbose ;                   // Print some statistics
static char *cInProf;                   // Input profile
static char *cOutProf;                  // Output profile
static char *cProofing;                 // Softproofing profile


static int  Intent;                             // Rendering Intent
static int  ProofingIntent;             // RI for proof

static int  PrecalcMode;                // 0 = Not, 1=Normal, 2=Accurate, 3=Fast

static cmsBool BlackPointCompensation;
static cmsBool lIsDeviceLink;
static cmsBool lMultiProfileChain;              // Multiple profile chain

static cmsHPROFILE hInput, hOutput, hProof;
static cmsHTRANSFORM hColorTransform;
static cmsHPROFILE hProfiles[255];
static int nProfiles;

static cmsColorSpaceSignature InputColorSpace, OutputColorSpace;
static int OutputChannels, InputChannels, nBytesDepth;


// Error. Print error message and abort

static
cmsBool FatalError(const char *frm, ...)
{
        va_list args;
        char Buffer[1024];

        va_start(args, frm);
        vsprintf(Buffer, frm, args);
        mexErrMsgTxt(Buffer);   
        va_end(args);

        return FALSE;               
}

// This is the handler passed to lcms

static
void MatLabErrorHandler(cmsContext ContextID, cmsUInt32Number ErrorCode, 
                                                const char *Text)
{      
        mexErrMsgTxt(Text);    
}
//
//  Parse the command line options, System V style.
//

static
void xoptinit()
{   
        xoptind = 1;
        xopterr = 0;
        letP = NULL;
}


static
int xgetopt(int argc, char *argv[], char *optionS)
{
        unsigned char ch;
        char *optP;

        if (SW == 0) {
                SW = '/';
        }

        if (argc > xoptind) {
                if (letP == NULL) {
                        if ((letP = argv[xoptind]) == NULL ||
                                *(letP++) != SW)  goto gopEOF;
                        if (*letP == SW) {
                                xoptind++;  goto gopEOF;
                        }
                }
                if (0 == (ch = *(letP++))) {
                        xoptind++;  goto gopEOF;
                }
                if (':' == ch  ||  (optP = strchr(optionS, ch)) == NULL)
                        goto gopError;
                if (':' == *(++optP)) {
                        xoptind++;
                        if (0 == *letP) {
                                if (argc <= xoptind)  goto  gopError;
                                letP = argv[xoptind++];
                        }
                        xoptarg = letP;
                        letP = NULL;
                } else {
                        if (0 == *letP) {
                                xoptind++;
                                letP = NULL;
                        }
                        xoptarg = NULL;
                }
                return ch;
        }
gopEOF:
        xoptarg = letP = NULL;
        return EOF;

gopError:
        xoptarg = NULL;    
        if (xopterr)
                FatalError ("get command line option");
        return ('?');
}


// Return Mathlab type by depth

static
size_t SizeOfArrayType(const mxArray *Array)
{

        switch (mxGetClassID(Array))  {

         case mxINT8_CLASS:   return 1;
         case mxUINT8_CLASS:  return 1;
         case mxINT16_CLASS:  return 2;
         case mxUINT16_CLASS: return 2;  
         case mxSINGLE_CLASS: return 4;
         case mxDOUBLE_CLASS: return 0; // Special case -- lcms handles double as size=0


         default:
                 FatalError("Unsupported data type");
                 return 0;
        }
}


// Get number of pixels of input array. Supported arrays are 
// organized as NxMxD, being N and M the size of image and D the
// number of components.

static
size_t GetNumberOfPixels(const mxArray* In)
{
        int nDimensions  = mxGetNumberOfDimensions(In); 
        const int  *Dimensions   = mxGetDimensions(In);

        switch (nDimensions) {

                case 1: return 1;                            // It is just a spot color
                case 2: return Dimensions[0];                // A scanline
                case 3: return Dimensions[0]*Dimensions[1];  // A image

                default:
                        FatalError("Unsupported array of %d dimensions", nDimensions);
                        return 0;
        }
}   


// Allocates the output array. Copies the input array modifying the pixel
// definition to match "OutputChannels".

static
mxArray* AllocateOutputArray(const mxArray* In, int OutputChannels)
{       

        mxArray*        Out                       = mxDuplicateArray(In);   // Make a "deep copy" of Input array 
        int         nDimensions   = mxGetNumberOfDimensions(In);    
        const int*      Dimensions    = mxGetDimensions(In);
        int         InputChannels = Dimensions[nDimensions-1];


        // Modify pixel size only if needed

        if (InputChannels != OutputChannels) {


                int i, NewSize;
                int *ModifiedDimensions = (int*) mxMalloc(nDimensions * sizeof(int));


                memmove(ModifiedDimensions, Dimensions, nDimensions * sizeof(int));
                ModifiedDimensions[nDimensions - 1] = OutputChannels;

                switch (mxGetClassID(In))  {

                case mxINT8_CLASS:   NewSize = sizeof(char); break;
                case mxUINT8_CLASS:  NewSize = sizeof(unsigned char); break;
                case mxINT16_CLASS:  NewSize = sizeof(short); break;
                case mxUINT16_CLASS: NewSize = sizeof(unsigned short); break;

                default:
                case mxDOUBLE_CLASS: NewSize = sizeof(double); break;
                }


                // NewSize = 1;
                for (i=0; i < nDimensions; i++)
                        NewSize *= ModifiedDimensions[i];


                mxSetDimensions(Out, ModifiedDimensions, nDimensions);
                mxFree(ModifiedDimensions);

                mxSetPr(Out, mxRealloc(mxGetPr(Out), NewSize));             

        }


        return Out;
}



// Does create a format descriptor. "Bytes" is the sizeof type in bytes
//  
//  Bytes  Meaning
//  ------ --------
//   0      Floating point (double)
//   1      8-bit samples
//   2      16-bit samples   

static
cmsUInt32Number MakeFormatDescriptor(cmsColorSpaceSignature ColorSpace, int Bytes)
{
        int IsFloat = (Bytes == 0 || Bytes == 4) ? 1 : 0;
        int Channels = cmsChannelsOf(ColorSpace);
        return FLOAT_SH(IsFloat)|COLORSPACE_SH(_cmsLCMScolorSpace(ColorSpace))|BYTES_SH(Bytes)|CHANNELS_SH(Channels)|PLANAR_SH(1);
}


// Opens a profile or proper built-in

static
cmsHPROFILE OpenProfile(const char* File)
{   

        cmsContext ContextID = 0;

           if (!File) 
            return cmsCreate_sRGBProfileTHR(ContextID);    

       if (cmsstrcasecmp(File, "*Lab2") == 0)
                return cmsCreateLab2ProfileTHR(ContextID, NULL);

       if (cmsstrcasecmp(File, "*Lab4") == 0)
                return cmsCreateLab4ProfileTHR(ContextID, NULL);

       if (cmsstrcasecmp(File, "*Lab") == 0)
                return cmsCreateLab4ProfileTHR(ContextID, NULL);
       
       if (cmsstrcasecmp(File, "*LabD65") == 0) {

           cmsCIExyY D65xyY;
           
           cmsWhitePointFromTemp( &D65xyY, 6504);           
           return cmsCreateLab4ProfileTHR(ContextID, &D65xyY);
       }

       if (cmsstrcasecmp(File, "*XYZ") == 0)
                return cmsCreateXYZProfileTHR(ContextID);

       if (cmsstrcasecmp(File, "*Gray22") == 0) {

           cmsToneCurve* Curve = cmsBuildGamma(ContextID, 2.2);
           cmsHPROFILE hProfile = cmsCreateGrayProfileTHR(ContextID, cmsD50_xyY(), Curve);
           cmsFreeToneCurve(Curve);
           return hProfile;
       }

        if (cmsstrcasecmp(File, "*Gray30") == 0) {

           cmsToneCurve* Curve = cmsBuildGamma(ContextID, 3.0);
           cmsHPROFILE hProfile = cmsCreateGrayProfileTHR(ContextID, cmsD50_xyY(), Curve);
           cmsFreeToneCurve(Curve);
           return hProfile;
       }

       if (cmsstrcasecmp(File, "*srgb") == 0)
                return cmsCreate_sRGBProfileTHR(ContextID);

       if (cmsstrcasecmp(File, "*null") == 0)
                return cmsCreateNULLProfileTHR(ContextID);

       
       if (cmsstrcasecmp(File, "*Lin2222") == 0) {

            cmsToneCurve*  Gamma = cmsBuildGamma(0, 2.2);
            cmsToneCurve*  Gamma4[4];
            cmsHPROFILE hProfile; 

            Gamma4[0] = Gamma4[1] = Gamma4[2] = Gamma4[3] = Gamma;
            hProfile = cmsCreateLinearizationDeviceLink(cmsSigCmykData, Gamma4);
            cmsFreeToneCurve(Gamma);
            return hProfile;
       }

           
        return cmsOpenProfileFromFileTHR(ContextID, File, "r");
}


static
cmsUInt32Number GetFlags()
{
        cmsUInt32Number dwFlags = 0; 

        switch (PrecalcMode) {

        case 0: dwFlags = cmsFLAGS_NOOPTIMIZE; break;
        case 2: dwFlags = cmsFLAGS_HIGHRESPRECALC; break;
        case 3: dwFlags = cmsFLAGS_LOWRESPRECALC; break;
        case 1: break;

        default: FatalError("Unknown precalculation mode '%d'", PrecalcMode);
        }

        if (BlackPointCompensation) 
                dwFlags |= cmsFLAGS_BLACKPOINTCOMPENSATION;

        return dwFlags;
}

// Create transforms

static
void OpenTransforms(int argc, char *argv[])
{

        cmsUInt32Number dwIn, dwOut, dwFlags;


        if (lMultiProfileChain) {

                int i;
                cmsHTRANSFORM hTmp;


                nProfiles = argc - xoptind;
                for (i=0; i < nProfiles; i++) {

                        hProfiles[i] = OpenProfile(argv[i+xoptind]);
                }


                // Create a temporary devicelink 

                hTmp = cmsCreateMultiprofileTransform(hProfiles, nProfiles, 
                        0, 0, Intent, GetFlags());

                hInput = cmsTransform2DeviceLink(hTmp, 4.2, 0);
                hOutput = NULL;
                cmsDeleteTransform(hTmp);

                InputColorSpace  = cmsGetColorSpace(hInput);
                OutputColorSpace = cmsGetPCS(hInput);        
                lIsDeviceLink = TRUE;

        }
        else
                if (lIsDeviceLink) {

                        hInput  = cmsOpenProfileFromFile(cInProf, "r");
                        hOutput = NULL;
                        InputColorSpace  = cmsGetColorSpace(hInput);
                        OutputColorSpace = cmsGetPCS(hInput);


                }
                else {

                        hInput  = OpenProfile(cInProf);
                        hOutput = OpenProfile(cOutProf);    

                        InputColorSpace   = cmsGetColorSpace(hInput);
                        OutputColorSpace  = cmsGetColorSpace(hOutput);

                        if (cmsGetDeviceClass(hInput) == cmsSigLinkClass ||
                                cmsGetDeviceClass(hOutput) == cmsSigLinkClass)   
                                FatalError("Use %cl flag for devicelink profiles!\n", SW);

                }


                /*

                if (Verbose) {

                mexPrintf("From: %s\n", cmsTakeProductName(hInput));
                if (hOutput) mexPrintf("To  : %s\n\n", cmsTakeProductName(hOutput));

                }
                */


                OutputChannels = cmsChannelsOf(OutputColorSpace);
                InputChannels  = cmsChannelsOf(InputColorSpace);


                dwIn  = MakeFormatDescriptor(InputColorSpace, nBytesDepth);
                dwOut = MakeFormatDescriptor(OutputColorSpace, nBytesDepth);


                dwFlags = GetFlags();

                if (cProofing != NULL) {

                        hProof = OpenProfile(cProofing);
                        dwFlags |= cmsFLAGS_SOFTPROOFING;
                }




                hColorTransform = cmsCreateProofingTransform(hInput, dwIn, 
                        hOutput, dwOut, 
                        hProof, Intent, 
                        ProofingIntent, 
                        dwFlags);

}



static
void ApplyTransforms(const mxArray *In, mxArray *Out)
{   
        double *Input  = mxGetPr(In); 
        double *Output = mxGetPr(Out);    
        size_t nPixels = GetNumberOfPixels(In);;

        cmsDoTransform(hColorTransform, Input, Output, nPixels );

}


static
void CloseTransforms(void)
{
        int i;

        if (hColorTransform) cmsDeleteTransform(hColorTransform);
        if (hInput) cmsCloseProfile(hInput);
        if (hOutput) cmsCloseProfile(hOutput);             
        if (hProof) cmsCloseProfile(hProof);

        for (i=0; i < nProfiles; i++)
                cmsCloseProfile(hProfiles[i]);

        hColorTransform = NULL; hInput = NULL; hOutput = NULL; hProof = NULL;
}


static
void HandleSwitches(int argc, char *argv[])
{
        int  s;

        xoptinit();

        while ((s = xgetopt(argc, argv,"C:c:VvbBI:i:O:o:T:t:L:l:r:r:P:p:Mm")) != EOF) {


                switch (s){

                case 'b':
                case 'B': 
                        BlackPointCompensation = TRUE;
                        break;

                case 'c':
                case 'C':
                        PrecalcMode = atoi(xoptarg);
                        if (PrecalcMode < 0 || PrecalcMode > 3)
                                FatalError("Unknown precalc mode '%d'", PrecalcMode);
                        break;

                case 'v':
                case 'V':
                        Verbose = TRUE;
                        break;

                case 'i':
                case 'I':
                        if (lIsDeviceLink)
                                FatalError("Device-link already specified");
                        cInProf = xoptarg;
                        break;

                case 'o':
                case 'O':
                        if (lIsDeviceLink)
                                FatalError("Device-link already specified"); 
                        cOutProf = xoptarg;
                        break;

                case 't':
                case 'T':
                        Intent = atoi(xoptarg);
                        // if (Intent > 3) Intent = 3;
                        if (Intent < 0) Intent = 0;
                        break;


                case 'l':
                case 'L': 
                        cInProf = xoptarg;
                        lIsDeviceLink = TRUE;
                        break;

                case 'p':
                case 'P':
                        cProofing = xoptarg;
                        break;



                case 'r':
                case 'R':
                        ProofingIntent = atoi(xoptarg);
                        // if (ProofingIntent > 3) ProofingIntent = 3;
                        if (ProofingIntent < 0) ProofingIntent = 0;
                        break;


                case 'm':
                case 'M':
                        lMultiProfileChain = TRUE;
                        break;

                default:
                        FatalError("Unknown option.");
                }
        }

        // For multiprofile, need to specify -m

        if (xoptind < argc) {

                if (!lMultiProfileChain)
                        FatalError("Use %cm for multiprofile transforms", SW);
        }

}



// -------------------------------------------------- Print some fancy help
static
void PrintHelp(void)
{
        mexPrintf("(MX) little cms ColorSpace conversion tool - v2.0\n\n");

        mexPrintf("usage: icctrans (mVar, flags)\n\n");

        mexPrintf("mVar : Matlab array.\n");
        mexPrintf("flags: a string containing one or more of following options.\n\n");
        mexPrintf("\t%cv - Verbose\n", SW);
        mexPrintf("\t%ci<profile> - Input profile (defaults to sRGB)\n", SW);
        mexPrintf("\t%co<profile> - Output profile (defaults to sRGB)\n", SW);   
        mexPrintf("\t%cl<profile> - Transform by device-link profile\n", SW);      
        mexPrintf("\t%cm<profiles> - Apply multiprofile chain\n", SW);      

        mexPrintf("\t%ct<n> - Rendering intent\n", SW);    

        mexPrintf("\t%cb - Black point compensation\n", SW);
        mexPrintf("\t%cc<0,1,2,3> - Optimize transform (0=Off, 1=Normal, 2=Hi-res, 3=Lo-Res) [defaults to 1]\n", SW);     

        mexPrintf("\t%cp<profile> - Soft proof profile\n", SW);
        mexPrintf("\t%cr<0,1,2,3> - Soft proof intent\n", SW);

        mexPrintf("\nYou can use following built-ins as profiles:\n\n");

        mexPrintf("\t*Lab2  -- D50-based v2 CIEL*a*b\n"
        "\t*Lab4  -- D50-based v4 CIEL*a*b\n"
        "\t*Lab   -- D50-based v4 CIEL*a*b\n"
        "\t*XYZ   -- CIE XYZ (PCS)\n"
        "\t*sRGB  -- IEC6 1996-2.1 sRGB color space\n" 
        "\t*Gray22 - Monochrome of Gamma 2.2\n"
        "\t*Gray30 - Monochrome of Gamma 3.0\n"
        "\t*null   - Monochrome black for all input\n"
        "\t*Lin2222- CMYK linearization of gamma 2.2 on each channel\n\n");

        mexPrintf("For suggestions, comments, bug reports etc. send mail to info@littlecms.com\n\n");

}



// Main entry point

void mexFunction(
                                 int nlhs,              // Number of left hand side (output) arguments
                                 mxArray *plhs[],       // Array of left hand side arguments
                                 int nrhs,              // Number of right hand side (input) arguments
                                 const mxArray *prhs[]  // Array of right hand side arguments
)
{

        char CommandLine[4096+1];
        char *pt, *argv[128];
        int argc = 1;


        if (nrhs != 2) {    

                PrintHelp();              
                return;
        }


        if(nlhs > 1) {        
                FatalError("Too many output arguments.");
        }


        // Setup error handler

        cmsSetLogErrorHandler(MatLabErrorHandler);

        // Defaults

        Verbose     = 0;
        cInProf     = NULL;
        cOutProf    = NULL;
        cProofing   = NULL;

        lMultiProfileChain = FALSE;
        nProfiles   = 0;

        Intent                  = INTENT_PERCEPTUAL;
        ProofingIntent          = INTENT_ABSOLUTE_COLORIMETRIC;
        PrecalcMode = 1;
        BlackPointCompensation  = FALSE;
        lIsDeviceLink           = FALSE;

        // Check types. Fist parameter is array of values, second parameter is command line

        if (!mxIsNumeric(prhs[0]))
                FatalError("Type mismatch on argument 1 -- Must be numeric");

        if (!mxIsChar(prhs[1]))
                FatalError("Type mismatch on argument 2 -- Must be string");




        // Unpack string to command line buffer

        if (mxGetString(prhs[1], CommandLine, 4096))
                FatalError("Cannot unpack command string");

        // Separate to argv[] convention

        argv[0] = NULL;
        for (pt = strtok(CommandLine, " ");
                pt;
                pt = strtok(NULL, " ")) {

                        argv[argc++] = pt;
        }



        // Parse arguments
        HandleSwitches(argc, argv);


        nBytesDepth = SizeOfArrayType(prhs[0]);

        OpenTransforms(argc, argv);


        plhs[0] = AllocateOutputArray(prhs[0], OutputChannels);


        ApplyTransforms(prhs[0], plhs[0]);

        CloseTransforms();

        // Done!
}
/* [<][>][^][v][top][bottom][index][help] */
root/utils/matlab/icctrans.c

DEFINITIONS
