CIccCLUT Class Reference

#include <IccTagLut.h>

Public Member Functions
	CIccCLUT (const CIccCLUT &ICLUT)
	CIccCLUT (icUInt8Number nInputChannels, icUInt16Number nOutputChannels, icUInt8Number nPrecision=2)
virtual	~CIccCLUT ()
void	Begin ()
void	DumpLut (std::string &sDescription, const icChar *szName, icColorSpaceSignature csInput, icColorSpaceSignature csOutput, int nVerboseness, bool bUseLegacy=false)
icFloatNumber *	GetData (int index)
icUInt32Number	GetDimSize (icUInt8Number nIndex) const
icUInt8Number	GetInputDim () const
CIccApplyCLUT *	GetNewApply ()
icUInt32Number	GetNumOffset () const
icUInt32Number	GetOffset (int index) const
icUInt16Number	GetOutputChannels () const
icUInt8Number	GetPrecision ()
icUInt8Number	GridPoint (int index) const
const icUInt8Number *	GridPointArray () const
icUInt8Number	GridPoints () const
bool	Init (const icUInt8Number *pGridPoints, icUInt32Number nMaxSize=0, icUInt8Number nBytesPerPoint=4)
bool	Init (icUInt8Number nGridPoints, icUInt32Number nMaxSize=0, icUInt8Number nBytesPerPoint=4)
void	Interp1d (icFloatNumber *destPixel, const icFloatNumber *srcPixel) const
void	Interp2d (icFloatNumber *destPixel, const icFloatNumber *srcPixel) const
void	Interp3d (icFloatNumber *destPixel, const icFloatNumber *srcPixel) const
void	Interp3dTetra (icFloatNumber *destPixel, const icFloatNumber *srcPixel) const
void	Interp4d (icFloatNumber *destPixel, const icFloatNumber *srcPixel) const
void	Interp5d (icFloatNumber *destPixel, const icFloatNumber *srcPixel) const
void	Interp6d (icFloatNumber *destPixel, const icFloatNumber *srcPixel) const
void	InterpND (icFloatNumber *destPixel, const icFloatNumber *srcPixel, CIccApplyCLUT *pApply) const
void	Iterate (IIccCLUTExec *pExec)
icUInt32Number	MaxGridPoint (int index) const
icUInt32Number	NumPoints () const
CIccCLUT &	operator= (const CIccCLUT &CLUTClass)
icFloatNumber &	operator[] (int index)
bool	Read (icUInt32Number size, CIccIO *pIO)
bool	ReadData (icUInt32Number size, CIccIO *pIO, icUInt8Number nPrecision)
void	SetClipFunc (icCLUTCLIPFUNC ClipFunc)
void	SetPrecision (icUInt8Number nPrecision)
icValidateStatus	Validate (std::string sigPath, std::string &sReport, const CIccProfile *pProfile=NULL) const
bool	Write (CIccIO *pIO)
bool	WriteData (CIccIO *pIO, icUInt8Number nPrecision)

Protected Member Functions
void	Iterate (std::string &sDescription, icUInt8Number nIndex, icUInt32Number nPos, bool bUseLegacy=false)
void	SubIterate (IIccCLUTExec *pExec, icUInt8Number nIndex, icUInt32Number nPos)

Protected Attributes
icColorSpaceSignature	m_csInput
icColorSpaceSignature	m_csOutput
icUInt32Number	m_DimSize [16]
icFloatNumber	m_fGridAdr [16]
icUInt8Number	m_GridAdr [16]
icUInt8Number	m_GridPoints [16]
icUInt8Number	m_MaxGridPoint [16]
icUInt8Number	m_nInput
icUInt32Number	m_nNodes
icUInt32Number	m_nNumPoints
icUInt32Number *	m_nOffset
icUInt16Number	m_nOutput
icUInt32Number	m_nPower [16]
icUInt8Number	m_nPrecision
icUInt8Number	m_nReserved2 [3]
icFloatNumber *	m_pData
icChar *	m_pOutText
icChar *	m_pVal
icUInt32Number	n000
icUInt32Number	n001
icUInt32Number	n010
icUInt32Number	n011
icUInt32Number	n100
icUInt32Number	n1000
icUInt32Number	n10000
icUInt32Number	n100000
icUInt32Number	n101
icUInt32Number	n110
icUInt32Number	n111
icCLUTCLIPFUNC	UnitClip

Detailed Description

Class: CIccCLUT

Purpose: The base multidimensional color look-up table (CLUT) class

Constructor & Destructor Documentation

CIccCLUT() [1/2]

CIccCLUT::CIccCLUT	(	icUInt8Number	nInputChannels,
		icUInt16Number	nOutputChannels,
		icUInt8Number	nPrecision = 2
	)

Name: CIccCLUT::CIccCLUT

Purpose: Constructor

Args: nInputChannels = number of input channels, nOutputChannels = number of output channels

{
  m_nInput = nInputChannels;
  m_nOutput = nOutputChannels;
  m_nPrecision = nPrecision;
  m_pData = NULL;
  m_nOffset = NULL;
  memset(&m_nReserved2, 0 , sizeof(m_nReserved2));
 
  UnitClip = ClutUnitClip;
}

References ClutUnitClip(), m_nInput, m_nOffset, m_nOutput, m_nPrecision, m_nReserved2, m_pData, and UnitClip.

Referenced by CDevLinkWriter::begin(), CIccMpeEmissionCLUT::Begin(), CIccMpeReflectanceCLUT::Begin(), icCLutFromXml(), main(), CIccMBB::NewCLUT(), CIccMBB::NewCLUT(), CIccMpeCLUT::Read(), CIccMpeExtCLUT::Read(), CIccMpeSpectralCLUT::Read(), CIccTagLutAtoB::Read(), CIccTagLut8::Read(), and CIccTagLut16::Read().

Here is the call graph for this function:

Here is the caller graph for this function:

CIccCLUT() [2/2]

CIccCLUT::CIccCLUT

(

const CIccCLUT &

ICLUT

)

Name: CIccCLUT::CIccCLUT

Purpose: Copy Constructor

Args: ICLUT = The CIccCLUT object to be copied

{
  m_pData = NULL;
  m_nOffset = NULL;
  m_nInput = ICLUT.m_nInput;
  m_nOutput = ICLUT.m_nOutput;
  m_nPrecision = ICLUT.m_nPrecision;
  m_nNumPoints = ICLUT.m_nNumPoints;
 
  m_csInput = ICLUT.m_csInput;
  m_csOutput = ICLUT.m_csOutput;
 
  memcpy(m_GridPoints, ICLUT.m_GridPoints, sizeof(m_GridPoints));
  memcpy(m_DimSize, ICLUT.m_DimSize, sizeof(m_DimSize));
  memcpy(m_GridAdr, ICLUT.m_GridAdr, sizeof(m_GridAdr));
  memcpy(&m_nReserved2, &ICLUT.m_nReserved2, sizeof(m_nReserved2));
 
  int num = NumPoints()*m_nOutput;
  m_pData = new icFloatNumber[num];
  memcpy(m_pData, ICLUT.m_pData, num*sizeof(icFloatNumber));
 
  UnitClip = ICLUT.UnitClip;
}

References m_csInput, m_csOutput, m_DimSize, m_GridAdr, m_GridPoints, m_nInput, m_nNumPoints, m_nOffset, m_nOutput, m_nPrecision, m_nReserved2, m_pData, NumPoints(), and UnitClip.

Referenced by CIccMBB::CIccMBB(), CIccMpeCLUT::CIccMpeCLUT(), CIccMpeSpectralCLUT::CIccMpeSpectralCLUT(), CIccMpeSpectralCLUT::copyData(), CIccMBB::operator=(), and CIccMpeCLUT::operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

~CIccCLUT()

CIccCLUT::~CIccCLUT ( )

virtual

Name: CIccCLUT::~CIccCLUT

Purpose: Destructor

{
  if (m_pData)
    delete [] m_pData;
 
  if (m_nOffset)
    delete [] m_nOffset;
 
}

References m_nOffset, and m_pData.

Member Function Documentation

Begin()

void CIccCLUT::Begin

(

)

Name: CIccCLUT::Begin

Purpose: Initializes the CLUT. Must be called before Apply().

{
  int i;
  for (i=0; i<m_nInput; i++) {
    m_MaxGridPoint[i] = m_GridPoints[i] - 1;
  }
  m_nNodes = (1<<m_nInput);
 
  if (m_nOffset)
    delete [] m_nOffset;
 
  m_nOffset = new icUInt32Number[m_nNodes];
 
  if (m_nInput==1) {
    m_nOffset[0] = n000 = 0;
    m_nOffset[1] = n001 = m_DimSize[0];
  }
  else if (m_nInput==2) {
    m_nOffset[0] = n000 = 0;
    m_nOffset[1] = n001 = m_DimSize[0];
    m_nOffset[2] = n010 = m_DimSize[1];
    m_nOffset[3] = n011 = n001 + n010;
  }
  else if (m_nInput==3) {
    m_nOffset[0] = n000 = 0;
    m_nOffset[1] = n001 = m_DimSize[0];
    m_nOffset[2] = n010 = m_DimSize[1];
    m_nOffset[3] = n011 = n001 + n010;
    m_nOffset[4] = n100 = m_DimSize[2];
    m_nOffset[5] = n101 = n100 + n001;
    m_nOffset[6] = n110 = n100 + n010;
    m_nOffset[7] = n111 = n110 + n001;
  }
  else if (m_nInput == 4) {
    m_nOffset[ 0] = 0;
    m_nOffset[ 1] = n001 = m_DimSize[ 0];
    m_nOffset[ 2] = n010 = m_DimSize[ 1];
    m_nOffset[ 3] = m_nOffset[ 2] + m_nOffset[ 1];
    m_nOffset[ 4] = n100 = m_DimSize[ 2];
    m_nOffset[ 5] = m_nOffset[ 4] + m_nOffset[ 1];
    m_nOffset[ 6] = m_nOffset[ 4] + m_nOffset[ 2];
    m_nOffset[ 7] = m_nOffset[ 4] + m_nOffset[ 3];
    m_nOffset[ 8] = n1000 = m_DimSize[ 3];
    m_nOffset[ 9] = m_nOffset[ 8] + m_nOffset[ 1];
    m_nOffset[10] = m_nOffset[ 8] + m_nOffset[ 2];
    m_nOffset[11] = m_nOffset[ 8] + m_nOffset[ 3];
    m_nOffset[12] = m_nOffset[ 8] + m_nOffset[ 4];
    m_nOffset[13] = m_nOffset[ 8] + m_nOffset[ 5];
    m_nOffset[14] = m_nOffset[ 8] + m_nOffset[ 6];
    m_nOffset[15] = m_nOffset[ 8] + m_nOffset[ 7];
  }
  else if (m_nInput == 5) {
    m_nOffset[ 0] = 0;
    m_nOffset[ 1] = n001 = m_DimSize[ 0];
    m_nOffset[ 2] = n010 = m_DimSize[ 1];
    m_nOffset[ 3] = m_nOffset[ 2] + m_nOffset[ 1];
    m_nOffset[ 4] = n100 = m_DimSize[ 2];
    m_nOffset[ 5] = m_nOffset[ 4] + m_nOffset[ 1];
    m_nOffset[ 6] = m_nOffset[ 4] + m_nOffset[ 2];
    m_nOffset[ 7] = m_nOffset[ 4] + m_nOffset[ 3];
    m_nOffset[ 8] = n1000 = m_DimSize[ 3];
    m_nOffset[ 9] = m_nOffset[ 8] + m_nOffset[ 1];
    m_nOffset[10] = m_nOffset[ 8] + m_nOffset[ 2];
    m_nOffset[11] = m_nOffset[ 8] + m_nOffset[ 3];
    m_nOffset[12] = m_nOffset[ 8] + m_nOffset[ 4];
    m_nOffset[13] = m_nOffset[ 8] + m_nOffset[ 5];
    m_nOffset[14] = m_nOffset[ 8] + m_nOffset[ 6];
    m_nOffset[15] = m_nOffset[ 8] + m_nOffset[ 7];
    m_nOffset[16] = n10000 = m_DimSize[ 4];
    m_nOffset[17] = m_nOffset[16] + m_nOffset[ 1];
    m_nOffset[18] = m_nOffset[16] + m_nOffset[ 2];
    m_nOffset[19] = m_nOffset[16] + m_nOffset[ 3];
    m_nOffset[20] = m_nOffset[16] + m_nOffset[ 4];
    m_nOffset[21] = m_nOffset[16] + m_nOffset[ 5];
    m_nOffset[22] = m_nOffset[16] + m_nOffset[ 6];
    m_nOffset[23] = m_nOffset[16] + m_nOffset[ 7];
    m_nOffset[24] = m_nOffset[16] + m_nOffset[ 8];
    m_nOffset[25] = m_nOffset[16] + m_nOffset[ 9];
    m_nOffset[26] = m_nOffset[16] + m_nOffset[10];
    m_nOffset[27] = m_nOffset[16] + m_nOffset[11];
    m_nOffset[28] = m_nOffset[16] + m_nOffset[12];
    m_nOffset[29] = m_nOffset[16] + m_nOffset[13];
    m_nOffset[30] = m_nOffset[16] + m_nOffset[14];
    m_nOffset[31] = m_nOffset[16] + m_nOffset[15];
  }
  else if (m_nInput == 6) {
    m_nOffset[ 0] = 0;
    m_nOffset[ 1] = n001 = m_DimSize[ 0];
    m_nOffset[ 2] = n010 = m_DimSize[ 1];
    m_nOffset[ 3] = m_nOffset[ 2] + m_nOffset[ 1];
    m_nOffset[ 4] = n100 = m_DimSize[ 2];
    m_nOffset[ 5] = m_nOffset[ 4] + m_nOffset[ 1];
    m_nOffset[ 6] = m_nOffset[ 4] + m_nOffset[ 2];
    m_nOffset[ 7] = m_nOffset[ 4] + m_nOffset[ 3];
    m_nOffset[ 8] = n1000 = m_DimSize[ 3];
    m_nOffset[ 9] = m_nOffset[ 8] + m_nOffset[ 1];
    m_nOffset[10] = m_nOffset[ 8] + m_nOffset[ 2];
    m_nOffset[11] = m_nOffset[ 8] + m_nOffset[ 3];
    m_nOffset[12] = m_nOffset[ 8] + m_nOffset[ 4];
    m_nOffset[13] = m_nOffset[ 8] + m_nOffset[ 5];
    m_nOffset[14] = m_nOffset[ 8] + m_nOffset[ 6];
    m_nOffset[15] = m_nOffset[ 8] + m_nOffset[ 7];
    m_nOffset[16] = n10000 = m_DimSize[ 4];
    m_nOffset[17] = m_nOffset[16] + m_nOffset[ 1];
    m_nOffset[18] = m_nOffset[16] + m_nOffset[ 2];
    m_nOffset[19] = m_nOffset[16] + m_nOffset[ 3];
    m_nOffset[20] = m_nOffset[16] + m_nOffset[ 4];
    m_nOffset[21] = m_nOffset[16] + m_nOffset[ 5];
    m_nOffset[22] = m_nOffset[16] + m_nOffset[ 6];
    m_nOffset[23] = m_nOffset[16] + m_nOffset[ 7];
    m_nOffset[24] = m_nOffset[16] + m_nOffset[ 8];
    m_nOffset[25] = m_nOffset[16] + m_nOffset[ 9];
    m_nOffset[26] = m_nOffset[16] + m_nOffset[10];
    m_nOffset[27] = m_nOffset[16] + m_nOffset[11];
    m_nOffset[28] = m_nOffset[16] + m_nOffset[12];
    m_nOffset[29] = m_nOffset[16] + m_nOffset[13];
    m_nOffset[30] = m_nOffset[16] + m_nOffset[14];
    m_nOffset[31] = m_nOffset[16] + m_nOffset[15];
    m_nOffset[32] = n100000 = m_DimSize[5];
    m_nOffset[33] = m_nOffset[32] + m_nOffset[ 1];
    m_nOffset[34] = m_nOffset[32] + m_nOffset[ 2];
    m_nOffset[35] = m_nOffset[32] + m_nOffset[ 3];
    m_nOffset[36] = m_nOffset[32] + m_nOffset[ 4];
    m_nOffset[37] = m_nOffset[32] + m_nOffset[ 5];
    m_nOffset[38] = m_nOffset[32] + m_nOffset[ 6];
    m_nOffset[39] = m_nOffset[32] + m_nOffset[ 7];
    m_nOffset[40] = m_nOffset[32] + m_nOffset[ 8];
    m_nOffset[41] = m_nOffset[32] + m_nOffset[ 9];
    m_nOffset[42] = m_nOffset[32] + m_nOffset[10];
    m_nOffset[43] = m_nOffset[32] + m_nOffset[11];
    m_nOffset[44] = m_nOffset[32] + m_nOffset[12];
    m_nOffset[45] = m_nOffset[32] + m_nOffset[13];
    m_nOffset[46] = m_nOffset[32] + m_nOffset[14];
    m_nOffset[47] = m_nOffset[32] + m_nOffset[15];
    m_nOffset[48] = m_nOffset[32] + m_nOffset[16];
    m_nOffset[49] = m_nOffset[32] + m_nOffset[17];
    m_nOffset[50] = m_nOffset[32] + m_nOffset[18];
    m_nOffset[51] = m_nOffset[32] + m_nOffset[19];
    m_nOffset[52] = m_nOffset[32] + m_nOffset[20];
    m_nOffset[53] = m_nOffset[32] + m_nOffset[21];
    m_nOffset[54] = m_nOffset[32] + m_nOffset[22];
    m_nOffset[55] = m_nOffset[32] + m_nOffset[23];
    m_nOffset[56] = m_nOffset[32] + m_nOffset[24];
    m_nOffset[57] = m_nOffset[32] + m_nOffset[25];
    m_nOffset[58] = m_nOffset[32] + m_nOffset[26];
    m_nOffset[59] = m_nOffset[32] + m_nOffset[27];
    m_nOffset[60] = m_nOffset[32] + m_nOffset[28];
    m_nOffset[61] = m_nOffset[32] + m_nOffset[29];
    m_nOffset[62] = m_nOffset[32] + m_nOffset[30];
    m_nOffset[63] = m_nOffset[32] + m_nOffset[31];
  }
  else {
    
    m_nOffset[0] = 0;
    int count, nFlag;
    icUInt32Number nPower[2];
    nPower[0] = 0;
    nPower[1] = 1;
 
    for (count=0; count<m_nInput; count++) {
      m_nPower[count] = (1<<(m_nInput-1-count));
    }
 
    count = 0;
    nFlag = 1;
    for (icUInt32Number j=1; j<m_nNodes; j++) {
      if (j == nPower[1]) {
        m_nOffset[j] = m_DimSize[count];
        nPower[0] = (1<<count);
        count++;
        nPower[1] = (1<<count);
        nFlag = 1;
      }
      else {
        m_nOffset[j] = m_nOffset[nPower[0]] + m_nOffset[nFlag];
        nFlag++;
      }
    }
  }
}

References m_DimSize, m_GridPoints, m_MaxGridPoint, m_nInput, m_nNodes, m_nOffset, m_nPower, n000, n001, n010, n011, n100, n1000, n10000, n100000, n101, n110, and n111.

Referenced by CIccMpeCLUT::Begin(), CIccMpeEmissionCLUT::Begin(), and CIccMpeReflectanceCLUT::Begin().

Here is the caller graph for this function:

DumpLut()

void CIccCLUT::DumpLut	(	std::string &	sDescription,
		const icChar *	szName,
		icColorSpaceSignature	csInput,
		icColorSpaceSignature	csOutput,
		int	nVerboseness,
		bool	bUseLegacy = false
	)

Name: CIccCLUT::DumpLut

Purpose: Dump data associated with the tag to a string.

Args: sDescription = string to concatenate tag dump to, szName = name of the LUT to be printed, csInput = color space signature of the input data, csOutput = color space signature of the output data nVerboseness = how verbose the output is (bigger = more verbose)

{
  icChar szOutText[200000], szColor[40];
  int i;
 
  sprintf(szOutText, "BEGIN_LUT %s %d %d\n", szName, m_nInput, m_nOutput);
  sDescription += szOutText;
 
  if (nVerboseness > 75) {
 
    for (i=0; i<m_nInput; i++) {
      icColorIndexName(szColor, csInput, i, m_nInput, "In");
      sprintf(szOutText, " %s=%d", szColor, m_GridPoints[i]);
      sDescription += szOutText;
    }
 
    sDescription += "  ";
 
    for (i=0; i<m_nOutput; i++) {
      icColorIndexName(szColor, csOutput, i, m_nOutput, "Out");
      sprintf(szOutText, " %s", szColor);
      sDescription += szOutText;
    }
 
    sDescription += "\n";
 
    if (nVerboseness > 75) {
      size_t len = 0;
      for (i=0; i<m_nInput; i++) {
        icColorValue(szColor, 1.0, csInput, i, bUseLegacy);
        len += strlen(szColor);
      }
      for (i=0; i<m_nOutput; i++) {
        icColorValue(szColor, 1.0, csOutput, i, bUseLegacy);
        len += strlen(szColor);
      }
      len += m_nInput + m_nOutput + 6;
 
      sDescription.reserve(sDescription.size() + NumPoints()*len);
 
      //Initialize iteration member variables
      m_csInput = csInput;
      m_csOutput = csOutput;
      m_pOutText = szOutText;
      m_pVal = szColor;
      memset(m_GridAdr, 0, 16);
 
      Iterate(sDescription, 0, 0, bUseLegacy);
    }
  }
}

References icColorIndexName(), icColorValue(), Iterate(), m_csInput, m_csOutput, m_GridAdr, m_GridPoints, m_nInput, m_nOutput, m_pOutText, m_pVal, and NumPoints().

Referenced by CIccMpeCLUT::Describe(), CIccMpeExtCLUT::Describe(), CIccMpeSpectralCLUT::Describe(), and CIccMBB::Describe().

Here is the call graph for this function:

Here is the caller graph for this function:

GetData()

icFloatNumber * CIccCLUT::GetData ( int  index )

inline

{ return &m_pData[index]; }

References m_pData.

Referenced by CDevLinkWriter::begin(), CIccMpeEmissionCLUT::Begin(), CIccMpeReflectanceCLUT::Begin(), icCLutFromXml(), main(), CIccMpeCLUT::Read(), CIccMpeExtCLUT::Read(), CIccMpeSpectralCLUT::Read(), CIccMpeCLUT::Write(), CIccMpeExtCLUT::Write(), and CIccMpeSpectralCLUT::Write().

Here is the caller graph for this function:

GetDimSize()

icUInt32Number CIccCLUT::GetDimSize ( icUInt8Number  nIndex ) const

inline

{ return m_DimSize[nIndex]; }

References m_DimSize.

GetInputDim()

icUInt8Number CIccCLUT::GetInputDim ( ) const

inline

{ return m_nInput; }

References m_nInput.

Referenced by icCLUTDataToXml(), CIccMBB::SetCLUT(), CIccMpeCLUT::SetCLUT(), and CIccMpeSpectralCLUT::SetData().

Here is the caller graph for this function:

GetNewApply()

CIccApplyCLUT * CIccCLUT::GetNewApply

(

)

{
  CIccApplyCLUT* rv = new CIccApplyCLUT();
 
  if (!rv)
    return NULL;
 
  if (!rv->Init(m_nInput, m_nNodes)) {
    delete rv;
    return NULL;
  }
 
  return rv;
}

References CIccApplyCLUT::CIccApplyCLUT(), CIccApplyCLUT::Init(), m_nInput, and m_nNodes.

Referenced by CIccMpeCLUT::GetNewApply(), and CIccMpeSpectralCLUT::GetNewApply().

Here is the call graph for this function:

Here is the caller graph for this function:

GetNumOffset()

icUInt32Number CIccCLUT::GetNumOffset ( ) const

inline

{ return m_nNodes; }

References m_nNodes.

GetOffset()

icUInt32Number CIccCLUT::GetOffset ( int  index ) const

inline

{ return m_nOffset ? m_nOffset[index] : 0; }

References m_nOffset.

GetOutputChannels()

icUInt16Number CIccCLUT::GetOutputChannels ( ) const

inline

{ return m_nOutput; }

References m_nOutput.

Referenced by CIccMpeEmissionCLUT::Begin(), CIccMpeReflectanceCLUT::Begin(), icCLUTDataToXml(), icCLutFromXml(), CIccMBB::SetCLUT(), and CIccMpeCLUT::SetCLUT().

Here is the caller graph for this function:

GetPrecision()

icUInt8Number CIccCLUT::GetPrecision ( )

inline

{ return m_nPrecision; }

References m_nPrecision.

Referenced by icCLUTDataToXml().

Here is the caller graph for this function:

GridPoint()

icUInt8Number CIccCLUT::GridPoint ( int  index ) const

inline

{ return m_GridPoints[index]; }

References m_GridPoints.

Referenced by icCLUTDataToXml(), icCLUTToXml(), CIccMpeCLUT::Write(), CIccMpeExtCLUT::Write(), and CIccMpeSpectralCLUT::Write().

Here is the caller graph for this function:

GridPointArray()

const icUInt8Number * CIccCLUT::GridPointArray ( ) const

inline

{return &m_GridPoints[0]; }

References m_GridPoints.

Referenced by CIccMpeEmissionCLUT::Begin(), and CIccMpeReflectanceCLUT::Begin().

Here is the caller graph for this function:

GridPoints()

icUInt8Number CIccCLUT::GridPoints ( ) const

inline

{ return m_GridPoints[0]; }

References m_GridPoints.

Referenced by CIccEvalCompare::EvaluateProfile(), CIccTagLut8::Write(), and CIccTagLut16::Write().

Here is the caller graph for this function:

Init() [1/2]

bool CIccCLUT::Init	(	const icUInt8Number *	pGridPoints,
		icUInt32Number	nMaxSize = 0,
		icUInt8Number	nBytesPerPoint = 4
	)

Name: CIccCLUT::Init

Purpose: Initializes and sets the size of the CLUT

Args: pGridPoints = number of grid points in the CLUT

{
  if (nMaxSize && !nBytesPerPoint)
    return false;
 
  icUInt64Number nNumPoints;
  memset(m_nReserved2, 0, sizeof(m_nReserved2));
  if (pGridPoints!=&m_GridPoints[0]) {
    // m_GridPoints[] is fixed size of 16
    if (m_nInput > 16)
      return false;
    memcpy(m_GridPoints, pGridPoints, m_nInput);
    if (m_nInput<16)
      memset(m_GridPoints+m_nInput, 0, 16-m_nInput);
  }
 
  // There should be at least 2 grid points for each input dimension for interpolation to work
  for (int i = 0; i < m_nInput; i++) {
    if (pGridPoints[i] < 2)
      return false;
  }
 
  if (m_pData) {
    delete [] m_pData;
    m_pData = NULL;
  }
 
  int i=m_nInput-1;
 
  // m_DimSize[] is a fixed size of 16
  if (i >= 16)
    return false;
 
  m_DimSize[i] = m_nOutput;
  nNumPoints = m_GridPoints[i];
  for (i--; i>=0; i--) {
    m_DimSize[i] = m_DimSize[i+1] * m_GridPoints[i+1];
    nNumPoints *= m_GridPoints[i];
    if (nMaxSize && nNumPoints * m_nOutput * nBytesPerPoint > nMaxSize)
      return false;
  }
  m_nNumPoints = (icUInt32Number)nNumPoints;
 
  icUInt32Number nSize = NumPoints() * m_nOutput;
 
  if (!nSize)
    return false;
 
  m_pData = new icFloatNumber[nSize];
 
  return (m_pData != NULL);
}

References m_DimSize, m_GridPoints, m_nInput, m_nNumPoints, m_nOutput, m_nReserved2, m_pData, and NumPoints().

Referenced by CIccMpeEmissionCLUT::Begin(), CIccMpeReflectanceCLUT::Begin(), icCLutFromXml(), Init(), CIccMBB::NewCLUT(), CIccMpeCLUT::Read(), CIccMpeExtCLUT::Read(), CIccMpeSpectralCLUT::Read(), and Read().

Here is the call graph for this function:

Here is the caller graph for this function:

Init() [2/2]

bool CIccCLUT::Init	(	icUInt8Number	nGridPoints,
		icUInt32Number	nMaxSize = 0,
		icUInt8Number	nBytesPerPoint = 4
	)

Name: CIccCLUT::Init

Purpose: Initializes and sets the size of the CLUT

Args: nGridPoints = number of grid points in the CLUT

{
  memset(&m_GridPoints, 0, sizeof(m_GridPoints));
  // m_GridPoints[] is a fixed length of 16
  if (m_nInput > 16)
    return false;
  memset(m_GridPoints, nGridPoints, m_nInput);
  return Init(&m_GridPoints[0], nMaxSize, nBytesPerPoint);
}

References Init(), m_GridPoints, and m_nInput.

Referenced by CDevLinkWriter::begin(), icCLutFromXml(), main(), CIccMBB::NewCLUT(), CIccTagLut8::Read(), and CIccTagLut16::Read().

Here is the call graph for this function:

Here is the caller graph for this function:

Interp1d()

void CIccCLUT::Interp1d	(	icFloatNumber *	destPixel,
		const icFloatNumber *	srcPixel
	)		const

Name: CIccCLUT::Interp1d

Purpose: One dimensional interpolation function

Args: Pixel = Pixel value to be found in the CLUT. Also used to store the result.

{
  icUInt8Number mx = m_MaxGridPoint[0];
 
  icFloatNumber x = UnitClip(srcPixel[0]) * mx;
 
  icUInt32Number ix = (icUInt32Number)x;
 
  icFloatNumber u = x - ix;
 
  if (ix==mx) {
    ix--;
    u = 1.0;
  }
 
  icFloatNumber nu = (icFloatNumber)(1.0 - u);
 
  int i;
  icFloatNumber *p = &m_pData[ix*n001];
 
  //Normalize grid units
  icFloatNumber dF0, dF1, pv;
 
  dF0 = nu;
  dF1 =  u;
 
  for (i=0; i<m_nOutput; i++, p++) {
    pv = p[n000]*dF0 + p[n001]*dF1;
 
    destPixel[i] = pv;
  }
}

References m_MaxGridPoint, m_nOutput, m_pData, n000, n001, and UnitClip.

Referenced by CIccMpeCLUT::Apply(), and CIccMpeSpectralCLUT::Apply().

Here is the caller graph for this function:

Interp2d()

void CIccCLUT::Interp2d	(	icFloatNumber *	destPixel,
		const icFloatNumber *	srcPixel
	)		const

Name: CIccCLUT::Interp2d

Purpose: Two dimensional interpolation function

Args: Pixel = Pixel value to be found in the CLUT. Also used to store the result.

{
  icUInt8Number mx = m_MaxGridPoint[0];
  icUInt8Number my = m_MaxGridPoint[1];
 
  icFloatNumber x = UnitClip(srcPixel[0]) * mx;
  icFloatNumber y = UnitClip(srcPixel[1]) * my;
 
  icUInt32Number ix = (icUInt32Number)x;
  icUInt32Number iy = (icUInt32Number)y;
 
  icFloatNumber u = x - ix;
  icFloatNumber t = y - iy;
 
  if (ix==mx) {
    ix--;
    u = 1.0f;
  }
  if (iy==my) {
    iy--;
    t = 1.0f;
  }
 
  icFloatNumber nt = 1.0f - t;
  icFloatNumber nu = 1.0f - u;
 
  int i;
  icFloatNumber *p = &m_pData[ix*n001 + iy*n010];
 
  //Normalize grid units
  icFloatNumber dF0, dF1, dF2, dF3, pv;
 
  dF0 = nt* nu;
  dF1 = nt*  u;
  dF2 =  t* nu;
  dF3 =  t*  u;
 
  for (i=0; i<m_nOutput; i++, p++) {
    pv = p[n000]*dF0 + p[n001]*dF1 + p[n010]*dF2 + p[n011]*dF3;
 
    destPixel[i] = pv;
  }
}

References m_MaxGridPoint, m_nOutput, m_pData, n000, n001, n010, n011, and UnitClip.

Referenced by CIccMpeCLUT::Apply(), and CIccMpeSpectralCLUT::Apply().

Here is the caller graph for this function:

Interp3d()

void CIccCLUT::Interp3d	(	icFloatNumber *	destPixel,
		const icFloatNumber *	srcPixel
	)		const

Name: CIccCLUT::Interp3d

Purpose: Three dimensional interpolation function

Args: Pixel = Pixel value to be found in the CLUT. Also used to store the result.

{
  icUInt8Number mx = m_MaxGridPoint[0];
  icUInt8Number my = m_MaxGridPoint[1];
  icUInt8Number mz = m_MaxGridPoint[2];
 
  icFloatNumber x = UnitClip(srcPixel[0]) * mx;
  icFloatNumber y = UnitClip(srcPixel[1]) * my;
  icFloatNumber z = UnitClip(srcPixel[2]) * mz;
 
  icUInt32Number ix = (icUInt32Number)x;
  icUInt32Number iy = (icUInt32Number)y;
  icUInt32Number iz = (icUInt32Number)z;
 
  icFloatNumber u = x - ix;
  icFloatNumber t = y - iy;
  icFloatNumber s = z - iz;
 
  if (ix==mx) {
    ix--;
    u = 1.0f;
  }
  if (iy==my) {
    iy--;
    t = 1.0f;
  }
  if (iz==mz) {
    iz--;
    s = 1.0f;
  }
 
  icFloatNumber ns = 1.0f - s;
  icFloatNumber nt = 1.0f - t;
  icFloatNumber nu = 1.0f - u;
 
  int i;
  icFloatNumber *p = &m_pData[ix*n001 + iy*n010 + iz*n100];
 
  //Normalize grid units
  icFloatNumber dF0, dF1, dF2, dF3, dF4, dF5, dF6, dF7, pv;
 
  dF0 = ns* nt* nu;
  dF1 = ns* nt*  u;
  dF2 = ns*  t* nu;
  dF3 = ns*  t*  u;
  dF4 =  s* nt* nu;
  dF5 =  s* nt*  u;
  dF6 =  s*  t* nu;
  dF7 =  s*  t*  u;
 
  for (i=0; i<m_nOutput; i++, p++) {
    pv = p[n000]*dF0 + p[n001]*dF1 + p[n010]*dF2 + p[n011]*dF3 +
         p[n100]*dF4 + p[n101]*dF5 + p[n110]*dF6 + p[n111]*dF7;
 
    destPixel[i] = pv;
  }
}

References m_MaxGridPoint, m_nOutput, m_pData, n000, n001, n010, n011, n100, n101, n110, n111, and UnitClip.

Referenced by CIccMpeCLUT::Apply(), and CIccMpeSpectralCLUT::Apply().

Here is the caller graph for this function:

Interp3dTetra()

void CIccCLUT::Interp3dTetra	(	icFloatNumber *	destPixel,
		const icFloatNumber *	srcPixel
	)		const

Name: CIccCLUT::Interp3dTetra

Purpose: Tetrahedral interpolation function

Args: Pixel = Pixel value to be found in the CLUT. Also used to store the result.

{
  icUInt8Number mx = m_MaxGridPoint[0];
  icUInt8Number my = m_MaxGridPoint[1];
  icUInt8Number mz = m_MaxGridPoint[2];
 
  icFloatNumber x = UnitClip(srcPixel[0]) * mx;
  icFloatNumber y = UnitClip(srcPixel[1]) * my;
  icFloatNumber z = UnitClip(srcPixel[2]) * mz;
 
  icUInt32Number ix = (icUInt32Number)x;
  icUInt32Number iy = (icUInt32Number)y;
  icUInt32Number iz = (icUInt32Number)z;
 
  icFloatNumber v = x - ix;
  icFloatNumber u = y - iy;
  icFloatNumber t = z - iz;
 
  if (ix==mx) {
    ix--;
    v = 1.0f;
  }
  if (iy==my) {
    iy--;
    u = 1.0f;
  }
  if (iz==mz) {
    iz--;
    t = 1.0f;
  }
 
  int i;
  icFloatNumber *p = &m_pData[ix*n001 + iy*n010 + iz*n100];
 
  //Normalize grid units
 
  for (i=0; i<m_nOutput; i++, p++) {
    if (t<u) {
      if (t>v) {
        destPixel[i] = (p[n000] + t*(p[n110]-p[n010]) +
                                      u*(p[n010]-p[n000]) +
                                      v*(p[n111]-p[n110]));
      }
      else if (u<v) {
        destPixel[i] = (p[n000] + t*(p[n111]-p[n011]) + 
                                      u*(p[n011]-p[n001]) +
                                      v*(p[n001]-p[n000]));
      }
      else {
        destPixel[i] = (p[n000] + t*(p[n111]-p[n011]) +
                                      u*(p[n010]-p[n000]) +
                                      v*(p[n011]-p[n010]));
      }
    }
    else { 
      if (t<v) {
        destPixel[i] = (p[n000] + t*(p[n101]-p[n001]) + 
                                      u*(p[n111]-p[n101]) + 
                                      v*(p[n001]-p[n000]));
      }
      else if (u<v) {
        destPixel[i] = (p[n000] + t*(p[n100]-p[n000]) + 
                                      u*(p[n111]-p[n101]) + 
                                      v*(p[n101]-p[n100]));
      }
      else {
        destPixel[i] = (p[n000] + t*(p[n100]-p[n000]) + 
                                      u*(p[n110]-p[n100]) + 
                                      v*(p[n111]-p[n110]));
      }
    }
  }
}

References m_MaxGridPoint, m_nOutput, m_pData, n000, n001, n010, n011, n100, n101, n110, n111, and UnitClip.

Referenced by CIccMpeCLUT::Apply(), and CIccMpeSpectralCLUT::Apply().

Here is the caller graph for this function:

Interp4d()

void CIccCLUT::Interp4d	(	icFloatNumber *	destPixel,
		const icFloatNumber *	srcPixel
	)		const

Name: CIccCLUT::Interp4d

Purpose: Four dimensional interpolation function

Args: Pixel = Pixel value to be found in the CLUT. Also used to store the result.

{
  icUInt8Number mw = m_MaxGridPoint[0];
  icUInt8Number mx = m_MaxGridPoint[1];
  icUInt8Number my = m_MaxGridPoint[2];
  icUInt8Number mz = m_MaxGridPoint[3];
 
  icFloatNumber w = UnitClip(srcPixel[0]) * mw;
  icFloatNumber x = UnitClip(srcPixel[1]) * mx;
  icFloatNumber y = UnitClip(srcPixel[2]) * my;
  icFloatNumber z = UnitClip(srcPixel[3]) * mz;
 
  icUInt32Number iw = (icUInt32Number)w;
  icUInt32Number ix = (icUInt32Number)x;
  icUInt32Number iy = (icUInt32Number)y;
  icUInt32Number iz = (icUInt32Number)z;
 
  icFloatNumber v = w - iw;
  icFloatNumber u = x - ix;
  icFloatNumber t = y - iy;
  icFloatNumber s = z - iz;
 
  if (iw==mw) {
    iw--;
    v = 1.0f;
  }
  if (ix==mx) {
    ix--;
    u = 1.0f;
  }
  if (iy==my) {
    iy--;
    t = 1.0f;
  }
  if (iz==mz) {
    iz--;
    s = 1.0f;
  }
 
  icFloatNumber ns = 1.0f - s;
  icFloatNumber nt = 1.0f - t;
  icFloatNumber nu = 1.0f - u;
  icFloatNumber nv = 1.0f - v;
 
  int i, j;
  icFloatNumber *p = &m_pData[iw*n001 + ix*n010 + iy*n100 + iz*n1000];
 
  //Normalize grid units
  icFloatNumber dF[16], pv;
 
  dF[ 0] = ns* nt* nu* nv;
  dF[ 1] = ns* nt* nu*  v;
  dF[ 2] = ns* nt*  u* nv;
  dF[ 3] = ns* nt*  u*  v;
  dF[ 4] = ns*  t* nu* nv;
  dF[ 5] = ns*  t* nu*  v;
  dF[ 6] = ns*  t*  u* nv;
  dF[ 7] = ns*  t*  u*  v;
  dF[ 8] =  s* nt* nu* nv;
  dF[ 9] =  s* nt* nu*  v;
  dF[10] =  s* nt*  u* nv;
  dF[11] =  s* nt*  u*  v;
  dF[12] =  s*  t* nu* nv;
  dF[13] =  s*  t* nu*  v;
  dF[14] =  s*  t*  u* nv;
  dF[15] =  s*  t*  u*  v;
 
  for (i=0; i<m_nOutput; i++, p++) {
    for (pv=0, j=0; j<16; j++)
      pv += p[m_nOffset[j]] * dF[j];
 
    destPixel[i] = pv;
  }
}

References m_MaxGridPoint, m_nOffset, m_nOutput, m_pData, n001, n010, n100, n1000, and UnitClip.

Referenced by CIccMpeCLUT::Apply(), and CIccMpeSpectralCLUT::Apply().

Here is the caller graph for this function:

Interp5d()

void CIccCLUT::Interp5d	(	icFloatNumber *	destPixel,
		const icFloatNumber *	srcPixel
	)		const

Name: CIccCLUT::Interp5d

Purpose: Five dimensional interpolation function

Args: Pixel = Pixel value to be found in the CLUT. Also used to store the result.

{
  icUInt8Number m0 = m_MaxGridPoint[0];
  icUInt8Number m1 = m_MaxGridPoint[1];
  icUInt8Number m2 = m_MaxGridPoint[2];
  icUInt8Number m3 = m_MaxGridPoint[3];
  icUInt8Number m4 = m_MaxGridPoint[4];
 
  icFloatNumber g0 = UnitClip(srcPixel[0]) * m0;
  icFloatNumber g1 = UnitClip(srcPixel[1]) * m1;
  icFloatNumber g2 = UnitClip(srcPixel[2]) * m2;
  icFloatNumber g3 = UnitClip(srcPixel[3]) * m3;
  icFloatNumber g4 = UnitClip(srcPixel[4]) * m4;
 
  icUInt32Number ig0 = (icUInt32Number)g0;
  icUInt32Number ig1 = (icUInt32Number)g1;
  icUInt32Number ig2 = (icUInt32Number)g2;
  icUInt32Number ig3 = (icUInt32Number)g3;
  icUInt32Number ig4 = (icUInt32Number)g4;
 
  icFloatNumber s4 = g0 - ig0;
  icFloatNumber s3 = g1 - ig1;
  icFloatNumber s2 = g2 - ig2;
  icFloatNumber s1 = g3 - ig3;
  icFloatNumber s0 = g4 - ig4;
 
  if (ig0==m0) {
    ig0--;
    s4 = 1.0f;
  }
  if (ig1==m1) {
    ig1--;
    s3 = 1.0f;
  }
  if (ig2==m2) {
    ig2--;
    s2 = 1.0f;
  }
  if (ig3==m3) {
    ig3--;
    s1 = 1.0f;
  }
  if (ig4==m4) {
    ig4--;
    s0 = 1.0f;
  }
 
  icFloatNumber ns0 = 1.0f - s0;
  icFloatNumber ns1 = 1.0f - s1;
  icFloatNumber ns2 = 1.0f - s2;
  icFloatNumber ns3 = 1.0f - s3;
  icFloatNumber ns4 = 1.0f - s4;
 
  int i, j;
  icFloatNumber *p = &m_pData[ig0*n001 + ig1*n010 + ig2*n100 + ig3*n1000 + ig4*n10000];
 
  //Normalize grid units
  icFloatNumber dF[32], pv;
 
  dF[ 0] = ns0 * ns1 * ns2 * ns3 * ns4;
  dF[ 1] = ns0 * ns1 * ns2 * ns3 *  s4;
  dF[ 2] = ns0 * ns1 * ns2 *  s3 * ns4;
  dF[ 3] = ns0 * ns1 * ns2 *  s3 *  s4;
  dF[ 4] = ns0 * ns1 *  s2 * ns3 * ns4;
  dF[ 5] = ns0 * ns1 *  s2 * ns3 *  s4;
  dF[ 6] = ns0 * ns1 *  s2 *  s3 * ns4;
  dF[ 7] = ns0 * ns1 *  s2 *  s3 *  s4;
  dF[ 8] = ns0 *  s1 * ns2 * ns3 * ns4;
  dF[ 9] = ns0 *  s1 * ns2 * ns3 *  s4;
  dF[10] = ns0 *  s1 * ns2 *  s3 * ns4;
  dF[11] = ns0 *  s1 * ns2 *  s3 *  s4;
  dF[12] = ns0 *  s1 *  s2 * ns3 * ns4;
  dF[13] = ns0 *  s1 *  s2 * ns3 *  s4;
  dF[14] = ns0 *  s1 *  s2 *  s3 * ns4;
  dF[15] = ns0 *  s1 *  s2 *  s3 *  s4;
  dF[16] =  s0 * ns1 * ns2 * ns3 * ns4;
  dF[17] =  s0 * ns1 * ns2 * ns3 *  s4;
  dF[18] =  s0 * ns1 * ns2 *  s3 * ns4;
  dF[19] =  s0 * ns1 * ns2 *  s3 *  s4;
  dF[20] =  s0 * ns1 *  s2 * ns3 * ns4;
  dF[21] =  s0 * ns1 *  s2 * ns3 *  s4;
  dF[22] =  s0 * ns1 *  s2 *  s3 * ns4;
  dF[23] =  s0 * ns1 *  s2 *  s3 *  s4;
  dF[24] =  s0 *  s1 * ns2 * ns3 * ns4;
  dF[25] =  s0 *  s1 * ns2 * ns3 *  s4;
  dF[26] =  s0 *  s1 * ns2 *  s3 * ns4;
  dF[27] =  s0 *  s1 * ns2 *  s3 *  s4;
  dF[28] =  s0 *  s1 *  s2 * ns3 * ns4;
  dF[29] =  s0 *  s1 *  s2 * ns3 *  s4;
  dF[30] =  s0 *  s1 *  s2 *  s3 * ns4;
  dF[31] =  s0 *  s1 *  s2 *  s3 *  s4;
 
  for (i=0; i<m_nOutput; i++, p++) {
    for (pv=0.0, j=0; j<32; j++)
      pv += p[m_nOffset[j]] * dF[j];
 
    destPixel[i] = pv;
  }
}

References m_MaxGridPoint, m_nOffset, m_nOutput, m_pData, n001, n010, n100, n1000, n10000, and UnitClip.

Referenced by CIccMpeCLUT::Apply(), and CIccMpeSpectralCLUT::Apply().

Here is the caller graph for this function:

Interp6d()

void CIccCLUT::Interp6d	(	icFloatNumber *	destPixel,
		const icFloatNumber *	srcPixel
	)		const

Name: CIccCLUT::Interp6d

Purpose: Six dimensional interpolation function

Args: Pixel = Pixel value to be found in the CLUT. Also used to store the result.

{
  icUInt8Number m0 = m_MaxGridPoint[0];
  icUInt8Number m1 = m_MaxGridPoint[1];
  icUInt8Number m2 = m_MaxGridPoint[2];
  icUInt8Number m3 = m_MaxGridPoint[3];
  icUInt8Number m4 = m_MaxGridPoint[4];
  icUInt8Number m5 = m_MaxGridPoint[5];
 
  icFloatNumber g0 = UnitClip(srcPixel[0]) * m0;
  icFloatNumber g1 = UnitClip(srcPixel[1]) * m1;
  icFloatNumber g2 = UnitClip(srcPixel[2]) * m2;
  icFloatNumber g3 = UnitClip(srcPixel[3]) * m3;
  icFloatNumber g4 = UnitClip(srcPixel[4]) * m4;
  icFloatNumber g5 = UnitClip(srcPixel[5]) * m5;
 
  icUInt32Number ig0 = (icUInt32Number)g0;
  icUInt32Number ig1 = (icUInt32Number)g1;
  icUInt32Number ig2 = (icUInt32Number)g2;
  icUInt32Number ig3 = (icUInt32Number)g3;
  icUInt32Number ig4 = (icUInt32Number)g4;
  icUInt32Number ig5 = (icUInt32Number)g5;
 
  icFloatNumber s5 = g0 - ig0;
  icFloatNumber s4 = g1 - ig1;
  icFloatNumber s3 = g2 - ig2;
  icFloatNumber s2 = g3 - ig3;
  icFloatNumber s1 = g4 - ig4;
  icFloatNumber s0 = g5 - ig5;
 
  if (ig0==m0) {
    ig0--;
    s5 = 1.0f;
  }
  if (ig1==m1) {
    ig1--;
    s4 = 1.0f;
  }
  if (ig2==m2) {
    ig2--;
    s3 = 1.0f;
  }
  if (ig3==m3) {
    ig3--;
    s2 = 1.0f;
  }
  if (ig4==m4) {
    ig4--;
    s1 = 1.0f;
  }
  if (ig5==m5) {
    ig5--;
    s0 = 1.0f;
  }
 
  icFloatNumber ns0 = 1.0f - s0;
  icFloatNumber ns1 = 1.0f - s1;
  icFloatNumber ns2 = 1.0f - s2;
  icFloatNumber ns3 = 1.0f - s3;
  icFloatNumber ns4 = 1.0f - s4;
  icFloatNumber ns5 = 1.0f - s5;
 
  int i, j;
  icFloatNumber *p = &m_pData[ig0*n001 + ig1*n010 + ig2*n100 + ig3*n1000 + ig4*n10000 + ig5*n100000];
 
  //Normalize grid units
  icFloatNumber dF[64], pv;
 
  dF[ 0] = ns0 * ns1 * ns2 * ns3 * ns4 * ns5;
  dF[ 1] = ns0 * ns1 * ns2 * ns3 * ns4 *  s5;
  dF[ 2] = ns0 * ns1 * ns2 * ns3 *  s4 * ns5;
  dF[ 3] = ns0 * ns1 * ns2 * ns3 *  s4 *  s5;
  dF[ 4] = ns0 * ns1 * ns2 *  s3 * ns4 * ns5;
  dF[ 5] = ns0 * ns1 * ns2 *  s3 * ns4 *  s5;
  dF[ 6] = ns0 * ns1 * ns2 *  s3 *  s4 * ns5;
  dF[ 7] = ns0 * ns1 * ns2 *  s3 *  s4 *  s5;
  dF[ 8] = ns0 * ns1 *  s2 * ns3 * ns4 * ns5;
  dF[ 9] = ns0 * ns1 *  s2 * ns3 * ns4 *  s5;
  dF[10] = ns0 * ns1 *  s2 * ns3 *  s4 * ns5;
  dF[11] = ns0 * ns1 *  s2 * ns3 *  s4 *  s5;
  dF[12] = ns0 * ns1 *  s2 *  s3 * ns4 * ns5;
  dF[13] = ns0 * ns1 *  s2 *  s3 * ns4 *  s5;
  dF[14] = ns0 * ns1 *  s2 *  s3 *  s4 * ns5;
  dF[15] = ns0 * ns1 *  s2 *  s3 *  s4 *  s5;
  dF[16] = ns0 *  s1 * ns2 * ns3 * ns4 * ns5;
  dF[17] = ns0 *  s1 * ns2 * ns3 * ns4 *  s5;
  dF[18] = ns0 *  s1 * ns2 * ns3 *  s4 * ns5;
  dF[19] = ns0 *  s1 * ns2 * ns3 *  s4 *  s5;
  dF[20] = ns0 *  s1 * ns2 *  s3 * ns4 * ns5;
  dF[21] = ns0 *  s1 * ns2 *  s3 * ns4 *  s5;
  dF[22] = ns0 *  s1 * ns2 *  s3 *  s4 * ns5;
  dF[23] = ns0 *  s1 * ns2 *  s3 *  s4 *  s5;
  dF[24] = ns0 *  s1 *  s2 * ns3 * ns4 * ns5;
  dF[25] = ns0 *  s1 *  s2 * ns3 * ns4 *  s5;
  dF[26] = ns0 *  s1 *  s2 * ns3 *  s4 * ns5;
  dF[27] = ns0 *  s1 *  s2 * ns3 *  s4 *  s5;
  dF[28] = ns0 *  s1 *  s2 *  s3 * ns4 * ns5;
  dF[29] = ns0 *  s1 *  s2 *  s3 * ns4 *  s5;
  dF[30] = ns0 *  s1 *  s2 *  s3 *  s4 * ns5;
  dF[31] = ns0 *  s1 *  s2 *  s3 *  s4 *  s5;
  dF[32] =  s0 * ns1 * ns2 * ns3 * ns4 * ns5;
  dF[33] =  s0 * ns1 * ns2 * ns3 * ns4 *  s5;
  dF[34] =  s0 * ns1 * ns2 * ns3 *  s4 * ns5;
  dF[35] =  s0 * ns1 * ns2 * ns3 *  s4 *  s5;
  dF[36] =  s0 * ns1 * ns2 *  s3 * ns4 * ns5;
  dF[37] =  s0 * ns1 * ns2 *  s3 * ns4 *  s5;
  dF[38] =  s0 * ns1 * ns2 *  s3 *  s4 * ns5;
  dF[39] =  s0 * ns1 * ns2 *  s3 *  s4 *  s5;
  dF[40] =  s0 * ns1 *  s2 * ns3 * ns4 * ns5;
  dF[41] =  s0 * ns1 *  s2 * ns3 * ns4 *  s5;
  dF[42] =  s0 * ns1 *  s2 * ns3 *  s4 * ns5;
  dF[43] =  s0 * ns1 *  s2 * ns3 *  s4 *  s5;
  dF[44] =  s0 * ns1 *  s2 *  s3 * ns4 * ns5;
  dF[45] =  s0 * ns1 *  s2 *  s3 * ns4 *  s5;
  dF[46] =  s0 * ns1 *  s2 *  s3 *  s4 * ns5;
  dF[47] =  s0 * ns1 *  s2 *  s3 *  s4 *  s5;
  dF[48] =  s0 *  s1 * ns2 * ns3 * ns4 * ns5;
  dF[49] =  s0 *  s1 * ns2 * ns3 * ns4 *  s5;
  dF[50] =  s0 *  s1 * ns2 * ns3 *  s4 * ns5;
  dF[51] =  s0 *  s1 * ns2 * ns3 *  s4 *  s5;
  dF[52] =  s0 *  s1 * ns2 *  s3 * ns4 * ns5;
  dF[53] =  s0 *  s1 * ns2 *  s3 * ns4 *  s5;
  dF[54] =  s0 *  s1 * ns2 *  s3 *  s4 * ns5;
  dF[55] =  s0 *  s1 * ns2 *  s3 *  s4 *  s5;
  dF[56] =  s0 *  s1 *  s2 * ns3 * ns4 * ns5;
  dF[57] =  s0 *  s1 *  s2 * ns3 * ns4 *  s5;
  dF[58] =  s0 *  s1 *  s2 * ns3 *  s4 * ns5;
  dF[59] =  s0 *  s1 *  s2 * ns3 *  s4 *  s5;
  dF[60] =  s0 *  s1 *  s2 *  s3 * ns4 * ns5;
  dF[61] =  s0 *  s1 *  s2 *  s3 * ns4 *  s5;
  dF[62] =  s0 *  s1 *  s2 *  s3 *  s4 * ns5;
  dF[63] =  s0 *  s1 *  s2 *  s3 *  s4 *  s5;
 
  for (i=0; i<m_nOutput; i++, p++) {
    for (pv=0, j=0; j<64; j++)
      pv += p[m_nOffset[j]] * dF[j];
 
    destPixel[i] = pv;
  }
}

References m_MaxGridPoint, m_nOffset, m_nOutput, m_pData, n001, n010, n100, n1000, n10000, n100000, and UnitClip.

Referenced by CIccMpeCLUT::Apply(), and CIccMpeSpectralCLUT::Apply().

Here is the caller graph for this function:

InterpND()

void CIccCLUT::InterpND	(	icFloatNumber *	destPixel,
		const icFloatNumber *	srcPixel,
		CIccApplyCLUT *	pApply
	)		const

Name: CIccCLUT::InterpND

Purpose: Generic N-dimensional interpolation function

Args: Pixel = Pixel value to be found in the CLUT. Also used to store the result.

{
  icUInt32Number i,j, index = 0;
  icFloatNumber* df = pApply->m_df;
  icFloatNumber* g = pApply->m_g;
  icFloatNumber* s = pApply->m_s;
  icUInt32Number* ig = pApply->m_ig;
 
  for (i=0; i<m_nInput; i++) {
    g[i] = UnitClip(srcPixel[i]) * m_MaxGridPoint[i];
    ig[i] = (icUInt32Number)g[i];
    s[m_nInput-1-i] = g[i] - ig[i];
    if (ig[i]==m_MaxGridPoint[i]) {
      ig[i]--;
      s[m_nInput-1-i] = 1.0;      
    }
    index += ig[i]*m_DimSize[i];
  }
 
  icFloatNumber *p = &m_pData[index];
  icFloatNumber temp[2];
  icFloatNumber pv;
  int nFlag = 0;
 
  for (i=0; i<m_nNodes; i++) {
    df[i] = 1.0f;
  }
 
 
  for (i=0; i<m_nInput; i++) {
    temp[0] = 1.0f - s[i];
    temp[1] = s[i];
    index = m_nPower[i];
    for (j=0; j<m_nNodes; j++) {
      df[j] *= temp[nFlag];
      if ((j+1)%index == 0)
        nFlag = !nFlag;
    }
    nFlag = 0;
  }
 
  for (i=0; i<m_nOutput; i++, p++) {
    for (pv=0, j=0; j<m_nNodes; j++)
      pv += p[m_nOffset[j]] * df[j];
 
    destPixel[i] = pv;
  }
 
}

References CIccApplyCLUT::m_df, m_DimSize, CIccApplyCLUT::m_g, CIccApplyCLUT::m_ig, m_MaxGridPoint, m_nInput, m_nNodes, m_nOffset, m_nOutput, m_nPower, m_pData, CIccApplyCLUT::m_s, and UnitClip.

Referenced by CIccMpeCLUT::Apply(), and CIccMpeSpectralCLUT::Apply().

Here is the caller graph for this function:

Iterate() [1/2]

void CIccCLUT::Iterate

(

IIccCLUTExec *

pExec

)

Name: CIccCLUT::Iterate

Purpose: Iterate through the CLUT to get the data and execute PixelOp

Args: pExec = pointer to the IIccCLUTExec object that implements the IIccCLUTExec::Apply() function

{
  memset(&m_fGridAdr[0], 0, sizeof(m_fGridAdr));
  if (m_nInput==3) {
    int i,j,k;
    icUInt32Number index=0;
    for (i=0; i<m_GridPoints[0]; i++) {
      for (j=0; j<m_GridPoints[1]; j++) {
        for (k=0; k<m_GridPoints[2]; k++) {
          m_fGridAdr[2] = (icFloatNumber)k/(icFloatNumber)(m_GridPoints[2]-1);
          m_fGridAdr[1] = (icFloatNumber)j/(icFloatNumber)(m_GridPoints[1]-1);
          m_fGridAdr[0] = (icFloatNumber)i/(icFloatNumber)(m_GridPoints[0]-1);
 
          index = (m_DimSize[0]*i + m_DimSize[1]*j + m_DimSize[2]*k); 
          pExec->PixelOp(m_fGridAdr, &m_pData[index]);
 
        }
      }
    }
  }
  else if (m_nInput==4) {
    int i,j,k,l;
    icUInt32Number index=0;
    for (i=0; i<m_GridPoints[0]; i++) {
      for (j=0; j<m_GridPoints[1]; j++) {
        for (k=0; k<m_GridPoints[2]; k++) {
          for (l=0; l<m_GridPoints[3]; l++) {
            m_fGridAdr[3] = (icFloatNumber)l/(icFloatNumber)(m_GridPoints[3]-1);
            m_fGridAdr[2] = (icFloatNumber)k/(icFloatNumber)(m_GridPoints[2]-1);
            m_fGridAdr[1] = (icFloatNumber)j/(icFloatNumber)(m_GridPoints[1]-1);
            m_fGridAdr[0] = (icFloatNumber)i/(icFloatNumber)(m_GridPoints[0]-1);
 
            index = (m_DimSize[0]*i + m_DimSize[1]*j + 
                     m_DimSize[2]*k + m_DimSize[3]*l); 
            pExec->PixelOp(m_fGridAdr, &m_pData[index]);
 
          }
        }
      }
    }
  }
  else
    SubIterate(pExec, 0, 0);
}

References m_DimSize, m_fGridAdr, m_GridPoints, m_nInput, m_pData, IIccCLUTExec::PixelOp(), and SubIterate().

Referenced by icCLUTDataToXml().

Here is the call graph for this function:

Here is the caller graph for this function:

Iterate() [2/2]

void CIccCLUT::Iterate ( std::string &  sDescription, icUInt8Number  nIndex, icUInt32Number  nPos, bool  bUseLegacy = false  )

protected

Name: CIccCLUT::Iterate

Purpose: Iterate through the CLUT to dump the data

Args: sDescription = string to concatenate data dump to, nIndex = the channel number, nPos = the current position in the CLUT

{
  if (nIndex < m_nInput) {
    int i;
    for (i=0; i<m_GridPoints[nIndex]; i++) {
      m_GridAdr[nIndex] = i;
      Iterate(sDescription, nIndex+1, nPos, bUseLegacy);
      nPos += m_DimSize[nIndex];
    }
  }
  else {
    icChar *ptr = m_pOutText;
    icFloatNumber *pData = &m_pData[nPos];
    int i;
 
    for (i=0; i<m_nInput; i++) {
      icColorValue(m_pVal, (icFloatNumber)m_GridAdr[i] / (m_GridPoints[i]-1) , m_csInput, i, bUseLegacy);
 
      ptr += sprintf(ptr, " %s", m_pVal);
    }
    strcpy(ptr, "  ");
    ptr += 2;
 
    for (i=0; i<m_nOutput; i++) {
      icColorValue(m_pVal, pData[i], m_csOutput, i, bUseLegacy);
 
      ptr += sprintf(ptr, " %s", m_pVal);
    }
    strcpy(ptr, "\n");
    sDescription += (const icChar*)m_pOutText;
 
  }
}

References icColorValue(), Iterate(), m_csInput, m_csOutput, m_DimSize, m_GridAdr, m_GridPoints, m_nInput, m_nOutput, m_pData, m_pOutText, and m_pVal.

Referenced by DumpLut(), and Iterate().

Here is the call graph for this function:

Here is the caller graph for this function:

MaxGridPoint()

icUInt32Number CIccCLUT::MaxGridPoint ( int  index ) const

inline

{ return m_MaxGridPoint[index]; }

References m_MaxGridPoint.

NumPoints()

icUInt32Number CIccCLUT::NumPoints ( ) const

inline

{ return (m_nNumPoints != 0) ? m_nNumPoints : 0; }

References m_nNumPoints.

Referenced by CIccCLUT(), CDevLinkWriter::begin(), CIccMpeEmissionCLUT::Begin(), CIccMpeReflectanceCLUT::Begin(), DumpLut(), icCLutFromXml(), Init(), main(), operator=(), CIccMpeCLUT::Read(), CIccMpeExtCLUT::Read(), CIccMpeSpectralCLUT::Read(), ReadData(), CIccMpeCLUT::Write(), CIccMpeExtCLUT::Write(), CIccMpeSpectralCLUT::Write(), and WriteData().

Here is the caller graph for this function:

operator=()

CIccCLUT & CIccCLUT::operator=

(

const CIccCLUT &

CLUTTag

)

Name: CIccCLUT::operator=

Purpose: Copy Operator

Args: CLUTTag = The CIccCLUT object to be copied

{
  if (&CLUTTag == this)
    return *this;
  
  m_nInput = CLUTTag.m_nInput;
  m_nOutput = CLUTTag.m_nOutput;
  m_nPrecision = CLUTTag.m_nPrecision;
  m_nNumPoints = CLUTTag.m_nNumPoints;
 
  m_csInput = CLUTTag.m_csInput;
  m_csOutput = CLUTTag.m_csOutput;
 
  memcpy(m_GridPoints, CLUTTag.m_GridPoints, sizeof(m_GridPoints));
  memcpy(m_DimSize, CLUTTag.m_DimSize, sizeof(m_DimSize));
  memcpy(m_GridAdr, CLUTTag.m_GridAdr, sizeof(m_GridAdr));
  memcpy(m_nReserved2, &CLUTTag.m_nReserved2, sizeof(m_nReserved2));
 
  int num;
  if (m_pData)
    delete [] m_pData;
  num = NumPoints()*m_nOutput;
  m_pData = new icFloatNumber[num];
  memcpy(m_pData, CLUTTag.m_pData, num*sizeof(icFloatNumber));
 
  UnitClip = CLUTTag.UnitClip;
 
  return *this;
}

References m_csInput, m_csOutput, m_DimSize, m_GridAdr, m_GridPoints, m_nInput, m_nNumPoints, m_nOutput, m_nPrecision, m_nReserved2, m_pData, NumPoints(), and UnitClip.

Here is the call graph for this function:

operator[]()

icFloatNumber & CIccCLUT::operator[] ( int  index )

inline

{ return m_pData[index]; }

References m_pData.

Read()

bool CIccCLUT::Read	(	icUInt32Number	size,
		CIccIO *	pIO
	)

Name: CIccCLUT::Read

Purpose: Read in the tag contents into a data block

Args: size - # of bytes in tag, pIO - IO object to read tag from

Return: true = successful, false = failure

{
  if (size < 20)
    return false;
 
  if (pIO->Read8(m_GridPoints, 16)!=16 ||
      !pIO->Read8(&m_nPrecision) ||
      pIO->Read8(&m_nReserved2[0], 3)!=3)
    return false;
 
  if (!Init(m_GridPoints, size - 20, m_nPrecision))
    return false;
 
  return ReadData(size-20, pIO, m_nPrecision);
}

References Init(), m_GridPoints, m_nPrecision, m_nReserved2, CIccIO::Read8(), and ReadData().

Referenced by CIccTagLutAtoB::Read().

Here is the call graph for this function:

Here is the caller graph for this function:

ReadData()

bool CIccCLUT::ReadData	(	icUInt32Number	size,
		CIccIO *	pIO,
		icUInt8Number	nPrecision
	)

Name: CIccCLUT::ReadData

Purpose: Reads the CLUT data points into the data buffer

Args: size = # of bytes in the tag, pIO = IO object to read data from, nPrecision = data precision (8bit encoded as 1 or 16bit encoded as 2)

Return: true = data read succesfully, false = read data failed

{
  icUInt32Number nNum=NumPoints() * m_nOutput;
 
  if (nNum * nPrecision > size)
    return false;
 
  if (m_pData == NULL)
    return false;
 
  if (nPrecision==1) {
    if (pIO->ReadUInt8Float(m_pData, nNum)!=(icInt32Number)nNum)
      return false;
  }
  else if (nPrecision==2) {
    if (pIO->ReadUInt16Float(m_pData, nNum)!=(icInt32Number)nNum)
      return false;
  }
  else
    return false;
 
  return true;
}

References m_nOutput, m_pData, NumPoints(), CIccIO::ReadUInt16Float(), and CIccIO::ReadUInt8Float().

Referenced by Read(), CIccTagLut8::Read(), and CIccTagLut16::Read().

Here is the call graph for this function:

Here is the caller graph for this function:

SetClipFunc()

void CIccCLUT::SetClipFunc ( icCLUTCLIPFUNC  ClipFunc )

inline

{ UnitClip = ClipFunc; }

References UnitClip.

Referenced by CIccMpeEmissionCLUT::Begin(), CIccMpeReflectanceCLUT::Begin(), CIccMpeCLUT::Read(), CIccMpeExtCLUT::Read(), CIccMpeSpectralCLUT::Read(), CIccMpeCLUT::SetCLUT(), and CIccMpeSpectralCLUT::SetData().

Here is the caller graph for this function:

SetPrecision()

void CIccCLUT::SetPrecision ( icUInt8Number  nPrecision )

inline

{ m_nPrecision = nPrecision; }

References m_nPrecision.

Referenced by icCLutFromXml().

Here is the caller graph for this function:

SubIterate()

void CIccCLUT::SubIterate ( IIccCLUTExec *  pExec, icUInt8Number  nIndex, icUInt32Number  nPos  )

protected

Name: CIccCLUT::SubIterate

Purpose: Iterate through the CLUT to get the data

Args: pExec = pointer to the IIccCLUTExec object that implements the IIccCLUTExec::Apply() function, nIndex = the channel number, nPos = the current position in the CLUT

{
  if (nIndex < m_nInput) {
    int i;
    for (i=0; i<m_GridPoints[nIndex]; i++) {
      m_fGridAdr[nIndex] = (icFloatNumber)i/(icFloatNumber)(m_GridPoints[nIndex]-1);
      SubIterate(pExec, nIndex+1, nPos);
      nPos += m_DimSize[nIndex];
    }
  }
  else
    pExec->PixelOp(m_fGridAdr, &m_pData[nPos]);
}

References m_DimSize, m_fGridAdr, m_GridPoints, m_nInput, m_pData, IIccCLUTExec::PixelOp(), and SubIterate().

Referenced by Iterate(), and SubIterate().

Here is the call graph for this function:

Here is the caller graph for this function:

Validate()

icValidateStatus CIccCLUT::Validate	(	std::string	sigPath,
		std::string &	sReport,
		const CIccProfile *	pProfile = NULL
	)		const

Name: CIccCLUT::Validate

Purpose: Check tag data validity.

Args: sig = signature of tag being validated, sReport = String to add report information to

Return: icValidateStatusOK if valid, or other error status.

{
  icValidateStatus rv = icValidateOK;
  icSignature sig = icGetFirstSigPathSig(sigPath);
 
  CIccInfo Info;
  std::string sSigPathName = Info.GetSigPathName(sigPath);
  if (m_nReserved2[0]!=0 || m_nReserved2[1]!=0 || m_nReserved2[2]!=0) {
    sReport += icMsgValidateNonCompliant;
    sReport += sSigPathName;
    sReport += " - Reserved Value must be zero.\n";
 
    rv = icValidateNonCompliant;
  }
 
  if (sig==icSigLutAtoBType || sig==icSigLutBtoAType) {
    char temp[256];
    for (int i=0; i<m_nInput; i++) {
      if (m_GridPoints[i]<2) {
        sReport += icMsgValidateCriticalError;
        sReport += sSigPathName;
        sprintf(temp, " - CLUT: At least 2 grid points should be present in dimension %u.\n",i );
        sReport += temp;
        rv = icMaxStatus(rv, icValidateCriticalError);
      }
    }
  }
 
  return rv;
}

References CIccInfo::GetSigPathName(), icGetFirstSigPathSig(), icMaxStatus(), icMsgValidateCriticalError, icMsgValidateNonCompliant, icSigLutAtoBType, icSigLutBtoAType, icValidateCriticalError, icValidateNonCompliant, icValidateOK, m_GridPoints, m_nInput, and m_nReserved2.

Referenced by CIccMBB::Validate().

Here is the call graph for this function:

Here is the caller graph for this function:

Write()

bool CIccCLUT::Write

(

CIccIO *

pIO

)

Name: CIccCLUT::Write

Purpose: Write the tag to a file

Args: pIO - The IO object to write tag to.

Return: true = succesful, false = failure

{
  if (pIO->Write8(m_GridPoints, 16)!=16 ||
      !pIO->Write8(&m_nPrecision) ||
      pIO->Write8(&m_nReserved2[0], 3)!=3)
    return false;
 
  return WriteData(pIO, m_nPrecision);
}

References m_GridPoints, m_nPrecision, m_nReserved2, CIccIO::Write8(), and WriteData().

Referenced by CIccTagLutAtoB::Write().

Here is the call graph for this function:

Here is the caller graph for this function:

WriteData()

bool CIccCLUT::WriteData	(	CIccIO *	pIO,
		icUInt8Number	nPrecision
	)

Name: CIccCLUT::WriteData

Purpose: Writes the CLUT data points from the data buffer

Args: pIO = IO object to write data to, nPrecision = data precision (8bit encoded as 1 or 16bit encoded as 2)

Return: true = data written succesfully, false = write operation failed

{
  icUInt32Number nNum=NumPoints() * m_nOutput;
 
  if (nPrecision==1) {
    if (pIO->WriteUInt8Float(m_pData, nNum)!=(icInt32Number)nNum)
      return false;
  }
  else if (nPrecision==2) {
    if (pIO->WriteUInt16Float(m_pData, nNum)!=(icInt32Number)nNum)
      return false;
  }
  else
    return false;
 
  return true;
}

References m_nOutput, m_pData, NumPoints(), CIccIO::WriteUInt16Float(), and CIccIO::WriteUInt8Float().

Referenced by Write(), CIccTagLut8::Write(), and CIccTagLut16::Write().

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

m_csInput

icColorSpaceSignature CIccCLUT::m_csInput

protected

Referenced by CIccCLUT(), DumpLut(), Iterate(), and operator=().

m_csOutput

icColorSpaceSignature CIccCLUT::m_csOutput

protected

Referenced by CIccCLUT(), DumpLut(), Iterate(), and operator=().

m_DimSize

icUInt32Number CIccCLUT::m_DimSize[16]

protected

Referenced by CIccCLUT(), Begin(), GetDimSize(), Init(), InterpND(), Iterate(), Iterate(), operator=(), and SubIterate().

m_fGridAdr

icFloatNumber CIccCLUT::m_fGridAdr[16]

protected

Referenced by Iterate(), and SubIterate().

m_GridAdr

icUInt8Number CIccCLUT::m_GridAdr[16]

protected

Referenced by CIccCLUT(), DumpLut(), Iterate(), and operator=().

m_GridPoints

icUInt8Number CIccCLUT::m_GridPoints[16]

protected

Referenced by CIccCLUT(), Begin(), DumpLut(), GridPoint(), GridPointArray(), GridPoints(), Init(), Init(), Iterate(), Iterate(), operator=(), Read(), SubIterate(), Validate(), and Write().

m_MaxGridPoint

icUInt8Number CIccCLUT::m_MaxGridPoint[16]

protected

Referenced by Begin(), Interp1d(), Interp2d(), Interp3d(), Interp3dTetra(), Interp4d(), Interp5d(), Interp6d(), InterpND(), and MaxGridPoint().

m_nInput

icUInt8Number CIccCLUT::m_nInput

protected

Referenced by CIccCLUT(), CIccCLUT(), Begin(), DumpLut(), GetInputDim(), GetNewApply(), Init(), Init(), InterpND(), Iterate(), Iterate(), operator=(), SubIterate(), and Validate().

m_nNodes

icUInt32Number CIccCLUT::m_nNodes

protected

Referenced by Begin(), GetNewApply(), GetNumOffset(), and InterpND().

m_nNumPoints

icUInt32Number CIccCLUT::m_nNumPoints

protected

Referenced by CIccCLUT(), Init(), NumPoints(), and operator=().

m_nOffset

icUInt32Number* CIccCLUT::m_nOffset

protected

Referenced by CIccCLUT(), CIccCLUT(), ~CIccCLUT(), Begin(), GetOffset(), Interp4d(), Interp5d(), Interp6d(), and InterpND().

m_nOutput

icUInt16Number CIccCLUT::m_nOutput

protected

Referenced by CIccCLUT(), CIccCLUT(), DumpLut(), GetOutputChannels(), Init(), Interp1d(), Interp2d(), Interp3d(), Interp3dTetra(), Interp4d(), Interp5d(), Interp6d(), InterpND(), Iterate(), operator=(), ReadData(), and WriteData().

m_nPower

icUInt32Number CIccCLUT::m_nPower[16]

protected

Referenced by Begin(), and InterpND().

m_nPrecision

icUInt8Number CIccCLUT::m_nPrecision

protected

Referenced by CIccCLUT(), CIccCLUT(), GetPrecision(), operator=(), Read(), SetPrecision(), and Write().

m_nReserved2

icUInt8Number CIccCLUT::m_nReserved2[3]

protected

Referenced by CIccCLUT(), CIccCLUT(), Init(), operator=(), Read(), Validate(), and Write().

m_pData

icFloatNumber* CIccCLUT::m_pData

protected

Referenced by CIccCLUT(), CIccCLUT(), ~CIccCLUT(), GetData(), Init(), Interp1d(), Interp2d(), Interp3d(), Interp3dTetra(), Interp4d(), Interp5d(), Interp6d(), InterpND(), Iterate(), Iterate(), operator=(), operator[](), ReadData(), SubIterate(), and WriteData().

m_pOutText

icChar* CIccCLUT::m_pOutText

protected

Referenced by DumpLut(), and Iterate().

m_pVal

icChar * CIccCLUT::m_pVal

protected

Referenced by DumpLut(), and Iterate().

n000

icUInt32Number CIccCLUT::n000

protected

Referenced by Begin(), Interp1d(), Interp2d(), Interp3d(), and Interp3dTetra().

n001

icUInt32Number CIccCLUT::n001

protected

Referenced by Begin(), Interp1d(), Interp2d(), Interp3d(), Interp3dTetra(), Interp4d(), Interp5d(), and Interp6d().

n010

icUInt32Number CIccCLUT::n010

protected

Referenced by Begin(), Interp2d(), Interp3d(), Interp3dTetra(), Interp4d(), Interp5d(), and Interp6d().

n011

icUInt32Number CIccCLUT::n011

protected

Referenced by Begin(), Interp2d(), Interp3d(), and Interp3dTetra().

n100

icUInt32Number CIccCLUT::n100

protected

Referenced by Begin(), Interp3d(), Interp3dTetra(), Interp4d(), Interp5d(), and Interp6d().

n1000

icUInt32Number CIccCLUT::n1000

protected

Referenced by Begin(), Interp4d(), Interp5d(), and Interp6d().

n10000

icUInt32Number CIccCLUT::n10000

protected

Referenced by Begin(), Interp5d(), and Interp6d().

n100000

icUInt32Number CIccCLUT::n100000

protected

Referenced by Begin(), and Interp6d().

n101

icUInt32Number CIccCLUT::n101

protected

Referenced by Begin(), Interp3d(), and Interp3dTetra().

n110

icUInt32Number CIccCLUT::n110

protected

Referenced by Begin(), Interp3d(), and Interp3dTetra().

n111

icUInt32Number CIccCLUT::n111

protected

Referenced by Begin(), Interp3d(), and Interp3dTetra().

UnitClip

icCLUTCLIPFUNC CIccCLUT::UnitClip

protected

Referenced by CIccCLUT(), CIccCLUT(), Interp1d(), Interp2d(), Interp3d(), Interp3dTetra(), Interp4d(), Interp5d(), Interp6d(), InterpND(), operator=(), and SetClipFunc().

---

The documentation for this class was generated from the following files:

• IccProfLib/IccTagLut.h
• IccProfLib/IccTagLut.cpp