CIccMpeXmlCalculator Class Reference

#include <IccMpeXml.h>

Inheritance diagram for CIccMpeXmlCalculator:

Collaboration diagram for CIccMpeXmlCalculator:

Public Member Functions
	CIccMpeXmlCalculator ()
virtual	~CIccMpeXmlCalculator ()
virtual void	Apply (CIccApplyMpe *pApply, icFloatNumber *pDestPixel, const icFloatNumber *pSrcPixel) const
virtual bool	Begin (icElemInterp nInterp, CIccTagMultiProcessElement *pMPE)
virtual void	Describe (std::string &sDescription, int nVerboseness)
virtual icAcsSignature	GetBAcsSig ()
virtual const char *	GetClassName () const
virtual icAcsSignature	GetEAcsSig ()
CIccMultiProcessElement *	GetElem (icSigCalcOp op, icUInt16Number index)
virtual const char *	GetExtClassName ()
virtual IIccExtensionMpe *	GetExtension ()
virtual CIccApplyMpe *	GetNewApply (CIccApplyTagMpe *pApplyTag)
virtual icElemTypeSignature	GetType () const
virtual bool	IsAcs ()
virtual bool	IsLateBinding () const
virtual bool	IsLateBindingReflectance () const
virtual bool	IsSupported ()
virtual CIccMpeCalculator *	NewCopy () const
virtual icUInt16Number	NumInputChannels () const
virtual icUInt16Number	NumOutputChannels () const
bool	ParseImport (xmlNode *pNode, std::string importPath, std::string &parseStr)
virtual bool	ParseXml (xmlNode *pNode, std::string &parseStr)
virtual bool	Read (icUInt32Number size, CIccIO *pIO)
void	Reset ()
icFuncParseStatus	SetCalcFunc (const char *szFuncDef, std::string &sReport)
icFuncParseStatus	SetCalcFunc (icCalculatorFuncPtr newFunc)
void	SetSize (icUInt16Number nInputChannels, icUInt16Number nOutputChannels)
bool	SetSubElem (icUInt32Number idx, CIccMultiProcessElement *pElem)
virtual bool	ToXml (std::string &xml, std::string blanks="")
virtual icValidateStatus	Validate (std::string sigPath, std::string &sReport, const CIccTagMultiProcessElement *pMPE=NULL, const CIccProfile *pProfile=NULL) const
virtual bool	Write (CIccIO *pIO)

Static Public Member Functions
static CIccMultiProcessElement *	Create (icElemTypeSignature sig)

Data Fields
icUInt32Number	m_nReserved

Protected Member Functions
void	clean ()
bool	Flatten (std::string &flatStr, std::string macroName, const char *szFunc, std::string &parseStr, icUInt32Number nLocalsOffset=0)
bool	ParseChanMap (ChanVarMap &chanMap, const char *szNames, int nChannels)
bool	SetElem (icUInt32Number idx, CIccMultiProcessElement *pElem, icUInt32Number &count, CIccMultiProcessElement ***pArray)
bool	UpdateLocals (std::string &func, std::string szFunc, std::string &parseStr, int nLocalsOffset)
bool	ValidateMacroCalls (std::string &parseStr) const
bool	ValidMacroCalls (const char *szMacroText, std::string macroStack, std::string &parseStr) const

Static Protected Member Functions
static bool	validName (const char *saName)
static bool	validNameChar (char c, bool bFirst)

Protected Attributes
bool	m_bNeedTempReset
icCalculatorFuncPtr	m_calcFunc
TempDeclVarMap	m_declVarMap
ChanVarMap	m_inputMap
TempDeclVarMap	m_macroLocalMap
MacroMap	m_macroMap
MpePtrList	m_mpeList
MpePtrMap	m_mpeMap
icUInt16Number	m_nInputChannels
int	m_nNextMpe
int	m_nNextVar
icUInt16Number	m_nOutputChannels
icUInt32Number	m_nSubElem
icUInt32Number	m_nTempChannels
ChanVarMap	m_outputMap
IIccCmmEnvVarLookup *	m_pCmmEnvVarLookup
std::string	m_sImport
CIccMultiProcessElement **	m_SubElem
TempVarMap	m_varMap

Detailed Description

Constructor & Destructor Documentation

CIccMpeXmlCalculator()

CIccMpeXmlCalculator::CIccMpeXmlCalculator ( )

inline

{ m_sImport = "*"; }

References m_sImport.

Referenced by CIccMpeXmlFactory::CreateElement(), and CIccSampledCalculatorCurveXml::ParseXml().

Here is the caller graph for this function:

~CIccMpeXmlCalculator()

virtual CIccMpeXmlCalculator::~CIccMpeXmlCalculator ( )

inlinevirtual

{  clean(); }

References clean().

Here is the call graph for this function:

Member Function Documentation

Apply()

void CIccMpeCalculator::Apply ( CIccApplyMpe *  pApply, icFloatNumber *  pDestPixel, const icFloatNumber *  pSrcPixel  ) const

virtualinherited

Name: CIccMpeCalculator::Apply

Purpose:

Args:

Return:

Implements CIccMultiProcessElement.

{
  CIccApplyMpeCalculator *pApplyCalc = (CIccApplyMpeCalculator*)pApply;
  icFloatNumber *pSrcTemp = pApplyCalc->m_temp;
  bool rv;
 
  pApplyCalc->m_temp = pSrcTemp;
  pApplyCalc->m_input = pSrcPixel;
  pApplyCalc->m_output = pDestPixel;
 
  if (m_bNeedTempReset) {
    memset(pSrcTemp, 0, m_nTempChannels*sizeof(icFloatNumber));
  }
 
  if (g_pDebugger) {
    g_pDebugger->BeginApply();
    rv = m_calcFunc->Apply(pApplyCalc);
    if (!rv)
      g_pDebugger->Error("Calc Function Apply Terminated with an error!");
 
    g_pDebugger->EndApply();
  }
  else {
    rv = m_calcFunc->Apply(pApplyCalc);
  }
}

References CIccCalculatorFunc::Apply(), IIccCalcDebugger::BeginApply(), IIccCalcDebugger::EndApply(), IIccCalcDebugger::Error(), g_pDebugger, CIccMpeCalculator::m_bNeedTempReset, CIccMpeCalculator::m_calcFunc, CIccApplyMpeCalculator::m_input, CIccMpeCalculator::m_nTempChannels, CIccApplyMpeCalculator::m_output, and CIccApplyMpeCalculator::m_temp.

Referenced by CIccSampledCalculatorCurve::Begin().

Here is the call graph for this function:

Here is the caller graph for this function:

Begin()

bool CIccMpeCalculator::Begin ( icElemInterp  nInterp, CIccTagMultiProcessElement *  pMPE  )

virtualinherited

Name: CIccMpeCalculator::Begin

Purpose:

Args:

Return:

Implements CIccMultiProcessElement.

{
  if (!m_calcFunc)
    return false;
 
  m_nTempChannels = m_calcFunc->GetMaxTemp()+1;
 
  m_pCmmEnvVarLookup = pMPE->GetCmmEnvLookup();
 
  if (m_nTempChannels>65536)
    return false;
 
  if (m_nTempChannels) {
    icUInt8Number *tempUsage = (icUInt8Number *)calloc(m_nTempChannels, sizeof(icUInt8Number));
    if (tempUsage) {
      m_bNeedTempReset = m_calcFunc->NeedTempReset(tempUsage, m_nTempChannels);
      free(tempUsage);
    }
    else
      m_bNeedTempReset = true;
  }
  else {
    m_bNeedTempReset = false;
  }
 
  if (!m_calcFunc->Begin(this, pMPE))
    return false;
 
  icUInt32Number n;
  for (n=0; n<m_nSubElem; n++) {
    if (m_SubElem[n] && !m_SubElem[n]->Begin(nInterp, pMPE))
      return false;
  }
 
  return true;
}

References CIccCalculatorFunc::Begin(), CIccMultiProcessElement::Begin(), CIccTagMultiProcessElement::GetCmmEnvLookup(), CIccCalculatorFunc::GetMaxTemp(), CIccMpeCalculator::m_bNeedTempReset, CIccMpeCalculator::m_calcFunc, CIccMpeCalculator::m_nSubElem, CIccMpeCalculator::m_nTempChannels, CIccMpeCalculator::m_pCmmEnvVarLookup, CIccMpeCalculator::m_SubElem, and CIccCalculatorFunc::NeedTempReset().

Referenced by CIccSampledCalculatorCurve::Begin().

Here is the call graph for this function:

Here is the caller graph for this function:

clean()

void CIccMpeXmlCalculator::clean ( )

protected

{
  m_sImport = "*";
  m_declVarMap.clear();
  m_varMap.clear();
  m_macroMap.clear();
 
  MpePtrList::iterator ml;
  for (ml = m_mpeList.begin(); ml != m_mpeList.end(); ml++) {
    if (ml->m_ptr)
      delete ml->m_ptr;
  }
  m_mpeList.clear();
 
  MpePtrMap::iterator mm;
  for (mm = m_mpeMap.begin(); mm != m_mpeMap.end(); mm++) {
    if (mm->second.m_ptr)
      delete mm->second.m_ptr;
  }
  m_mpeMap.clear();
  m_nNextVar = 0;
  m_nNextMpe = 0;
}

References m_declVarMap, m_macroMap, m_mpeList, m_mpeMap, m_nNextMpe, m_nNextVar, CIccMpePtr::m_ptr, m_sImport, and m_varMap.

Referenced by ~CIccMpeXmlCalculator(), and ParseXml().

Here is the caller graph for this function:

Create()

CIccMultiProcessElement * CIccMultiProcessElement::Create ( icElemTypeSignature  sig )

staticinherited

Name: CIccMultiProcessElement::Create

Purpose:

Args:

Return:

{
  return CIccMpeCreator::CreateElement(sig);
}

References CIccMpeCreator::CreateElement().

Referenced by CIccDefaultEncProfileConverter::ConvertFromParams(), CIccSampledCalculatorCurve::Read(), CIccMpeCalculator::Read(), and CIccTagMultiProcessElement::Read().

Here is the call graph for this function:

Here is the caller graph for this function:

Describe()

void CIccMpeCalculator::Describe ( std::string &  sDescription, int  nVerboseness  )

virtualinherited

Name: CIccMpeCalculator::Describe

Purpose:

Args:

Return:

Implements CIccMultiProcessElement.

{
  if (m_calcFunc) {
    icChar buf[81];
 
    sprintf(buf, "BEGIN_CALC_ELEMENT %u %u\n", m_nInputChannels, m_nOutputChannels); 
    sDescription += buf;
 
    if (m_nSubElem && m_SubElem) {
      icUInt32Number i;
      for (i=0; i<m_nSubElem; i++) {
        sprintf(buf, "BEGIN_SUBCALCELEM %u\n", i);
        sDescription += buf;
        m_SubElem[i]->Describe(sDescription, nVerboseness);
        sprintf(buf, "END_SUBCALCELEM %u\n\n", i);
        sDescription += buf;
      }
    }
 
    if (m_calcFunc) {
      sDescription += "BEGIN_CALC_FUNCTION\n";
      m_calcFunc->Describe(sDescription, nVerboseness);
      sDescription += "END_CALC_FUNCTION\n";
    }
 
    sprintf(buf, "END_CALC_ELEMENT\n");
    sDescription += buf;
 
  }
}

References CIccMultiProcessElement::Describe(), CIccCalculatorFunc::Describe(), CIccMpeCalculator::m_calcFunc, CIccMultiProcessElement::m_nInputChannels, CIccMultiProcessElement::m_nOutputChannels, CIccMpeCalculator::m_nSubElem, and CIccMpeCalculator::m_SubElem.

Referenced by CIccSampledCalculatorCurve::Describe().

Here is the call graph for this function:

Here is the caller graph for this function:

Flatten()

bool CIccMpeXmlCalculator::Flatten ( std::string &  flatStr, std::string  macroName, const char *  szFunc, std::string &  parseStr, icUInt32Number  nLocalsOffset = 0  )

protected

{
  CIccFuncTokenizer parse(szFunc, true);
 
  while (parse.GetNext()) {
    std::string token = parse.GetLast();
    const char *tok = token.c_str();
    if (!strncmp(tok, "call{", 5) ||
        tok[0] == '#') {
      std::string nameiter;
      std::string name;
 
      if (tok[0] == '#')
        nameiter = token.substr(1);
      else
        nameiter = parse.GetReference();
 
      const char *ptr;
      for (ptr = nameiter.c_str(); *ptr && *ptr != '[' && *ptr != '('; ptr++) name += *ptr;
      int iter = 1;
//       if (*ptr) {
//         iter = atoi(ptr + 1);
//         if (iter < 1)
//           iter = 1;
//         else if (iter>1024)
//           iter = 1024;
//       }
 
      MacroMap::iterator m = m_macroMap.find(name.c_str());
      if (m != m_macroMap.end()) {
        icUInt16Number nLocalsSize = 0;
        TempDeclVarMap::iterator locals = m_macroLocalMap.find(macroName);
        if (locals != m_macroLocalMap.end()) {
          nLocalsSize = locals->second.m_size;
        }
        
        int i;
        for (i = 0; i < iter; i++) {
          Flatten(flatStr, name, m->second.c_str(), parseStr, nLocalsOffset+nLocalsSize);
        }
      }
      else {
        parseStr += "Call to undefined macro '" + name + "'\n";
        return false;
      }
    }
    else if (!strncmp(tok, "in{", 3) ||
             !strncmp(tok, "out{", 4)) {
      std::string op = parse.GetName();
      std::string ref = parse.GetReference();
      std::string refroot;
      for (const char *ptr = ref.c_str(); *ptr && *ptr != ',' && *ptr != '(' && *ptr != '['; ptr++) refroot += *ptr;
 
      ChanVarMap *pMap;
      int nChan;
      if (op == "in") {
        pMap = &m_inputMap;
        nChan = m_nInputChannels;
      }
      else {
        pMap = &m_outputMap;
        nChan = m_nOutputChannels;
      }
 
      ChanVarMap::iterator ci = pMap->find(refroot);
      if (ci == pMap->end()) {
        parseStr += "Invalid '" + op + "' operation channel reference '" + refroot + "'\n";
        return false;
      }
      if (refroot != ref) {
        std::string select = ref.substr(refroot.size());
        int offset = 0;
        int size = 1;
 
        if (select[0] == '[' || select[1] == '(') {
          const char *ptr;
          offset = atoi(select.c_str() + 1);
          for (ptr = select.c_str() + 1; *ptr && *ptr != ')' && *ptr != ']'; ptr++);
          select = ptr + 1;
        }
 
        if (select[0]==',')
          size = atoi(select.c_str() + 1);
 
        if (size < 0 || offset<0 || ci->second.first + offset + size > m_nInputChannels) {
          parseStr += "Invalid '" + op + "' operation channel offset or size '" + refroot + "'\n";
          return false;
        }
        char index[80];
        sprintf(index, "(%d,%d)", ci->second.first+offset, size);
        flatStr += op + index + " ";
      }
      else if (ci->second.second>1) {
        char index[80];
        sprintf(index, "(%d,%d)", ci->second.first, ci->second.second);
        flatStr += op + index + " ";
      }
      else {
        char index[80];
        sprintf(index, "(%d)", ci->second.first);
        flatStr += op + index + " ";
      }
    }
    else if (!strncmp(tok, "tget{", 5) ||
             !strncmp(tok, "tput{", 5) ||
             !strncmp(tok, "tsav{", 5)) {
      std::string op = parse.GetName();
      std::string ref = parse.GetReference();
      std::string refroot;
      for (const char *ptr = ref.c_str(); *ptr && *ptr != '[' && *ptr != '('; ptr++) refroot += *ptr;
 
      if (macroName.size() && refroot.size() && refroot[0] == '@') {
        std::string localName = refroot.substr(1);
        TempDeclVarMap::iterator locals = m_macroLocalMap.find(macroName);
        if (locals == m_macroLocalMap.end()) {
          parseStr += "Reference to undeclared local variable '" + localName + "' in macro '" + macroName + "'\n";
          return false;
        }
 
        unsigned long nLocalOffset = 0;
        unsigned long nLocalSize = 0;
        TempVarList::iterator m = locals->second.m_members.begin();
        for (; m != locals->second.m_members.end(); m++) {
          if (localName == m->m_name) {
            nLocalOffset = m->m_pos;
            nLocalSize = m->m_size;
            break;
          }
        }
        if (m == locals->second.m_members.end()) {
          parseStr += "Reference to undeclared local variable '" + localName + "' in macro '" + macroName + "'\n";
          return false;
        }
        int voffset, vsize;
 
        if (ref != refroot) {
          CIccFuncTokenizer p2(ref.c_str());
          p2.GetNext();
          icUInt16Number _voffset = 0, _vsize = 1;
          p2.GetIndex(_voffset, _vsize, 0, 1);
          voffset = _voffset;
          vsize = _vsize + 1;
        }
        else {
          voffset = 0;
          vsize = (int)nLocalSize;
        }
 
        if (voffset + vsize > (int)nLocalSize) {
          parseStr += "Out of bounds indexing of local '" + refroot + "' in macro '" + macroName + "'\n";
          return false;
        }
 
        if (nLocalsOffset + nLocalOffset + voffset + vsize > 65536) {
          parseStr += "Temporary variable addressing out of bounds\n";
          return false;
        }
        char idx[80];
        if (vsize == 1) {
          sprintf(idx, "[%lu]", nLocalsOffset + nLocalOffset + voffset);
        }
        else {
          sprintf(idx, "[%lu,%d]", nLocalsOffset + nLocalOffset + voffset, vsize);
        }
        flatStr += "l";
        flatStr += op.substr(1);
        flatStr += idx;
        flatStr += " ";
      }
      else {
        TempVarMap::iterator var = m_varMap.find(refroot);
        if (var == m_varMap.end()) {
          std::string root;
          for (const char *ptr = refroot.c_str(); *ptr && *ptr != '.'; ptr++) root += *ptr;
 
          TempVarMap::iterator rootVar = m_varMap.find(root);
          if (refroot != root && rootVar == m_varMap.end()) {
            parseStr += "Reference to undeclared variable '" + ref + "'\n";
            return false;
          }
 
          TempDeclVarMap::iterator decl = m_declVarMap.find(root);
          if (decl == m_declVarMap.end()) {
            parseStr += "Reference to undeclared variable '" + ref + "'\n";
            return false;
          }
 
          if (decl->second.m_pos < 0) {
            m_varMap[root] = CIccTempVar(root, m_nNextVar, decl->second.m_size);
            decl->second.m_pos = m_nNextVar;
 
            if (strchr(refroot.c_str(), '.')) {
              TempVarList::iterator m = decl->second.m_members.begin();
              for (; m != decl->second.m_members.end(); m++) {
                std::string vm = root + "." + m->m_name;
                m_varMap[vm] = CIccTempVar(vm, m_nNextVar + m->m_pos, m->m_size);
              }
            }
 
            if (m_nNextVar + decl->second.m_size > 65536) {
              parseStr += "Temporary variable addressing out of bounds\n";
              return false;
            }
            m_nNextVar += decl->second.m_size;
          }
          else {
            m_varMap[root] = CIccTempVar(root, decl->second.m_pos, decl->second.m_size);
 
            if (strchr(refroot.c_str(), '.')) {
              TempVarList::iterator m = decl->second.m_members.begin();
              for (; m != decl->second.m_members.end(); m++) {
                std::string vm = root + "." + m->m_name;
                m_varMap[vm] = CIccTempVar(vm, decl->second.m_pos + m->m_pos, m->m_size);
              }
            }
            if (decl->second.m_pos + decl->second.m_size > 65536) {
              parseStr += "Temporary variable addressing out of bounds\n";
              return false;
            }
          }
 
          var = m_varMap.find(refroot);
          if (var == m_varMap.end()) {
            parseStr += "Reference to undeclared variable '" + refroot + "'\n";
            return false;
          }
        }
        int voffset, vsize;
 
        if (ref != refroot) {
          CIccFuncTokenizer p2(ref.c_str());
          p2.GetNext();
          icUInt16Number _voffset = 0, _vsize = 1;
          p2.GetIndex(_voffset, _vsize, 0, 1);
          voffset = _voffset;
          vsize = _vsize + 1;
        }
        else {
          voffset = 0;
          vsize = var->second.m_size;
        }
 
        if (voffset + vsize > var->second.m_size) {
          parseStr += "Out of bounds indexing of '" + refroot + "'\n";
          return false;
        }
        if (var->second.m_pos + voffset + vsize > 65536) {
          parseStr += "Temporary variable addressing out of bounds\n";
          return false;
        }
        char idx[80];
        if (vsize == 1) {
          sprintf(idx, "[%d]", var->second.m_pos + voffset);
        }
        else {
          sprintf(idx, "[%d,%d]", var->second.m_pos + voffset, vsize);
        }
        flatStr += op + idx + " ";
      }
    }
    else if (!strncmp(tok, "elem{", 5) ||
             !strncmp(tok, "curv{", 5) ||
             !strncmp(tok, "clut{", 5) ||
             !strncmp(tok, "mtx{", 4) ||
             !strncmp(tok, "fJab{", 5) ||
             !strncmp(tok, "tJab{", 5) ||
             !strncmp(tok, "calc{", 5) ||
             !strncmp(tok, "tint{", 5)) {
      std::string op = parse.GetName();
      std::string ref = parse.GetReference();
      MpePtrMap::iterator e = m_mpeMap.find(ref);
      if (e == m_mpeMap.end()) {
        parseStr += "Unknown sub element reference to " + token + "\n";
        return false;
      }
      if (e->second.m_nIndex<0) {
        if (e->second.m_ptr) {
          m_mpeList.push_back(CIccMpePtr(e->second.m_ptr, m_nNextMpe));
          e->second.m_ptr = NULL;
          e->second.m_nIndex = m_nNextMpe;
          m_nNextMpe++;
        }
        else {
          parseStr += "Invalid sub-element reference:  " + token + "\n";
          return false;
        }
      }
      char idx[80];
      sprintf(idx, "(%d)", e->second.m_nIndex);
      flatStr += op + idx + " ";
    }
    else {
      flatStr += tok;
      flatStr += " ";
    }
  }
 
  return true;
}

References CIccFuncTokenizer::CIccFuncTokenizer(), CIccMpePtr::CIccMpePtr(), CIccTempVar::CIccTempVar(), Flatten(), CIccFuncTokenizer::GetIndex(), CIccFuncTokenizer::GetLast(), CIccFuncTokenizer::GetName(), CIccFuncTokenizer::GetNext(), CIccFuncTokenizer::GetReference(), m_declVarMap, m_inputMap, m_macroLocalMap, m_macroMap, CIccTempDeclVar::m_members, m_mpeList, m_mpeMap, CIccTempVar::m_name, CIccMpePtr::m_nIndex, CIccMultiProcessElement::m_nInputChannels, m_nNextMpe, m_nNextVar, CIccMultiProcessElement::m_nOutputChannels, m_outputMap, CIccTempVar::m_pos, CIccTempDeclVar::m_pos, CIccMpePtr::m_ptr, CIccTempVar::m_size, CIccTempDeclVar::m_size, and m_varMap.

Referenced by Flatten(), and ParseXml().

Here is the call graph for this function:

Here is the caller graph for this function:

GetBAcsSig()

virtual icAcsSignature CIccMultiProcessElement::GetBAcsSig ( )

inlinevirtualinherited

Reimplemented in CIccMpeBAcs.

{ return icSigAcsZero; }

Referenced by CIccMpeAcs::Describe().

Here is the caller graph for this function:

GetClassName()

virtual const char * CIccMpeXmlCalculator::GetClassName ( ) const

inlinevirtual

Reimplemented from CIccMpeCalculator.

{ return "CIccMpeXmlCalculator"; }

GetEAcsSig()

virtual icAcsSignature CIccMultiProcessElement::GetEAcsSig ( )

inlinevirtualinherited

Reimplemented in CIccMpeEAcs.

{ return icSigAcsZero; }

GetElem()

CIccMultiProcessElement * CIccMpeCalculator::GetElem ( icSigCalcOp  opsig, icUInt16Number  index  )

inherited

Name: CIccMpeCalculator::GetSubApply

Purpose:

Args:

Return:

{
  if (m_SubElem && index<m_nSubElem) {
    CIccMultiProcessElement *pMpe = m_SubElem[index];
    if (opsig==icSigApplyElemOp)
      return pMpe;
 
    if ((opsig==icSigApplyCurvesOp && pMpe->GetType() != icSigCurveSetElemType) ||
        (opsig==icSigApplyMatrixOp && pMpe->GetType() != icSigMatrixElemType) ||
        (opsig==icSigApplyCLutOp && !(pMpe->GetType() == icSigCLutElemType || pMpe->GetType() == icSigExtCLutElemType)) ||
        (opsig==icSigApplyTintOp && pMpe->GetType() != icSigTintArrayElemType) ||
        (opsig==icSigApplyToJabOp && pMpe->GetType() != icSigXYZToJabElemType) ||
        (opsig==icSigApplyFromJabOp && pMpe->GetType() != icSigJabToXYZElemType) ||
        (opsig==icSigApplyCalcOp && pMpe->GetType() != icSigCalculatorElemType))
      return NULL;
 
    return pMpe;
  }
 
  return NULL;
}

References CIccMultiProcessElement::GetType(), icSigApplyCalcOp, icSigApplyCLutOp, icSigApplyCurvesOp, icSigApplyElemOp, icSigApplyFromJabOp, icSigApplyMatrixOp, icSigApplyTintOp, icSigApplyToJabOp, icSigCalculatorElemType, icSigCLutElemType, icSigCurveSetElemType, icSigExtCLutElemType, icSigJabToXYZElemType, icSigMatrixElemType, icSigTintArrayElemType, icSigXYZToJabElemType, CIccMpeCalculator::m_nSubElem, and CIccMpeCalculator::m_SubElem.

Referenced by SIccCalcOp::ArgsPushed(), SIccCalcOp::ArgsUsed(), and SIccCalcOp::IsValidOp().

Here is the call graph for this function:

Here is the caller graph for this function:

GetExtClassName()

virtual const char * CIccMpeXml::GetExtClassName ( )

inlinevirtualinherited

Implements IIccExtensionMpe.

{ return "CIccMpeXml"; }

GetExtension()

virtual IIccExtensionMpe * CIccMpeXmlCalculator::GetExtension ( )

inlinevirtual

Reimplemented from CIccMultiProcessElement.

{ return this; }

GetNewApply()

CIccApplyMpe * CIccMpeCalculator::GetNewApply ( CIccApplyTagMpe *  pApplyTag )

virtualinherited

Name: CIccMpeCalculator::Begin

Purpose:

Args:

Return:

Reimplemented from CIccMultiProcessElement.

{
  CIccApplyTagMpe *pApplyTagEx = (CIccApplyTagMpe*)pApplyTag;
 
  CIccApplyMpeCalculator *pApply = new CIccApplyMpeCalculator(this);
 
  if (!pApply)
    return NULL;
 
  if (m_nTempChannels) {
    pApply->m_temp = (icFloatNumber*)malloc(m_nTempChannels*sizeof(icFloatNumber));
  }
  pApply->m_stack = new CIccFloatVector;
  pApply->m_scratch = new CIccFloatVector;
  pApply->m_scratch->resize(50);
  pApply->m_pCmmEnvVarLookup = m_pCmmEnvVarLookup;
 
  icUInt32Number i;
 
  pApply->m_nSubElem = m_nSubElem;
  if(m_nSubElem) {
    pApply->m_SubElem = (CIccSubCalcApply **)calloc(m_nSubElem, sizeof(CIccSubCalcApply*));
 
    if (m_SubElem) {
      for (i=0; i<m_nSubElem; i++) {
        if (m_SubElem[i]) {
          pApply->m_SubElem[i] = new CIccSubCalcApply(m_SubElem[i]->GetNewApply(pApplyTag));
        }
      }
    }
  }
  else {
    m_SubElem=NULL;
  }
  return pApply;
}

References CIccApplyMpeCalculator::CIccApplyMpeCalculator(), CIccSubCalcApply::CIccSubCalcApply(), CIccMultiProcessElement::GetNewApply(), CIccMpeCalculator::m_nSubElem, CIccApplyMpeCalculator::m_nSubElem, CIccMpeCalculator::m_nTempChannels, CIccMpeCalculator::m_pCmmEnvVarLookup, CIccApplyMpeCalculator::m_pCmmEnvVarLookup, CIccApplyMpeCalculator::m_scratch, CIccApplyMpeCalculator::m_stack, CIccMpeCalculator::m_SubElem, CIccApplyMpeCalculator::m_SubElem, and CIccApplyMpeCalculator::m_temp.

Referenced by CIccSampledCalculatorCurve::Begin().

Here is the call graph for this function:

Here is the caller graph for this function:

GetType()

virtual icElemTypeSignature CIccMpeCalculator::GetType ( ) const

inlinevirtualinherited

Implements CIccMultiProcessElement.

{ return icSigCalculatorElemType; }

References icSigCalculatorElemType.

Referenced by CIccMpeCalculator::Validate(), and CIccMpeCalculator::Write().

Here is the caller graph for this function:

IsAcs()

virtual bool CIccMultiProcessElement::IsAcs ( )

inlinevirtualinherited

Reimplemented in CIccMpeAcs.

{ return false; }

Referenced by CIccTagMultiProcessElement::Apply().

Here is the caller graph for this function:

IsLateBinding()

bool CIccMpeCalculator::IsLateBinding ( ) const

virtualinherited

Name: CIccMpeCalculator::IsLateBinding

Purpose:

Args:

Return:

Reimplemented from CIccMultiProcessElement.

{
  icUInt32Number i;
 
  if (m_SubElem) {
    for (i=0; i<m_nSubElem; i++) {
      if (m_SubElem[i] && m_SubElem[i]->IsLateBinding())
        return true;
    }
  }
 
  return false;
}

References CIccMultiProcessElement::IsLateBinding(), CIccMpeCalculator::m_nSubElem, and CIccMpeCalculator::m_SubElem.

Here is the call graph for this function:

IsLateBindingReflectance()

bool CIccMpeCalculator::IsLateBindingReflectance ( ) const

virtualinherited

Name: CIccMpeCalculator::IsLateBindingReflectance

Purpose:

Args:

Return:

Reimplemented from CIccMultiProcessElement.

{
  icUInt32Number i;
 
  if (m_SubElem) {
    for (i=0; i<m_nSubElem; i++) {
      if (m_SubElem[i] && m_SubElem[i]->IsLateBindingReflectance())
        return true;
    }
  }
 
  return false;
}

References CIccMultiProcessElement::IsLateBindingReflectance(), CIccMpeCalculator::m_nSubElem, and CIccMpeCalculator::m_SubElem.

Here is the call graph for this function:

IsSupported()

virtual bool CIccMultiProcessElement::IsSupported ( )

inlinevirtualinherited

Reimplemented in CIccMpeUnknown.

{ return true; }

Referenced by CIccTagMultiProcessElement::IsSupported().

Here is the caller graph for this function:

NewCopy()

virtual CIccMpeCalculator * CIccMpeCalculator::NewCopy ( ) const

inlinevirtualinherited

Implements CIccMultiProcessElement.

{ return new CIccMpeCalculator(*this);}

References CIccMpeCalculator::CIccMpeCalculator().

Referenced by CIccSampledCalculatorCurve::CIccSampledCalculatorCurve(), and CIccSampledCalculatorCurve::operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

NumInputChannels()

virtual icUInt16Number CIccMultiProcessElement::NumInputChannels ( ) const

inlinevirtualinherited

{ return m_nInputChannels; }

References CIccMultiProcessElement::m_nInputChannels.

Referenced by SIccCalcOp::ArgsUsed(), CIccCalculatorFunc::Begin(), CIccTagMultiProcessElement::Begin(), CIccSubCalcApply::NumInputChannels(), CIccMpeXmlUnknown::ToXml(), CIccMpeXmlCurveSet::ToXml(), CIccMpeXmlTintArray::ToXml(), CIccMpeXmlToneMap::ToXml(), CIccMpeXmlMatrix::ToXml(), CIccMpeXmlCLUT::ToXml(), CIccMpeXmlExtCLUT::ToXml(), CIccMpeXmlBAcs::ToXml(), CIccMpeXmlEAcs::ToXml(), CIccMpeXmlJabToXYZ::ToXml(), CIccMpeXmlXYZToJab::ToXml(), ToXml(), CIccMpeXmlEmissionMatrix::ToXml(), CIccMpeXmlInvEmissionMatrix::ToXml(), CIccMpeXmlEmissionCLUT::ToXml(), CIccMpeXmlReflectanceCLUT::ToXml(), CIccMpeXmlEmissionObserver::ToXml(), CIccMpeXmlReflectanceObserver::ToXml(), CIccCalculatorFunc::Validate(), and CIccTagMultiProcessElement::Validate().

Here is the caller graph for this function:

NumOutputChannels()

virtual icUInt16Number CIccMultiProcessElement::NumOutputChannels ( ) const

inlinevirtualinherited

{ return m_nOutputChannels; }

References CIccMultiProcessElement::m_nOutputChannels.

Referenced by CIccCalculatorFunc::Apply(), SIccCalcOp::ArgsPushed(), CIccCalculatorFunc::Begin(), CIccTagMultiProcessElement::Begin(), CIccSubCalcApply::NumOutputChannels(), CIccMpeXmlUnknown::ToXml(), CIccMpeXmlCurveSet::ToXml(), CIccMpeXmlTintArray::ToXml(), CIccMpeXmlToneMap::ToXml(), CIccMpeXmlMatrix::ToXml(), CIccMpeXmlCLUT::ToXml(), CIccMpeXmlExtCLUT::ToXml(), CIccMpeXmlBAcs::ToXml(), CIccMpeXmlEAcs::ToXml(), CIccMpeXmlJabToXYZ::ToXml(), CIccMpeXmlXYZToJab::ToXml(), ToXml(), CIccMpeXmlEmissionMatrix::ToXml(), CIccMpeXmlInvEmissionMatrix::ToXml(), CIccMpeXmlEmissionCLUT::ToXml(), CIccMpeXmlReflectanceCLUT::ToXml(), CIccMpeXmlEmissionObserver::ToXml(), CIccMpeXmlReflectanceObserver::ToXml(), CIccCalculatorFunc::Validate(), and CIccTagMultiProcessElement::Validate().

Here is the caller graph for this function:

ParseChanMap()

bool CIccMpeXmlCalculator::ParseChanMap ( ChanVarMap &  chanMap, const char *  szNames, int  nChannels  )

protected

{
  chanMap.clear();
 
  if (!szNames)
    return false;
 
  int i;
  const char *ptr;
  std::string name;
  IndexSizePair isp;
  int size = 1;
 
  for (i = 0, ptr = szNames; *ptr && i < nChannels; ptr++) {
    bool bFirst = name.empty();
    if (*ptr == ' ') {
      if (!bFirst) {
        isp.first = i;
        isp.second = size;
        chanMap[name] = isp;
        name.clear();
        i += size;
        size = 1;
      }
    }
    else if (*ptr == '[' || *ptr == '(') {
      size = atoi(ptr + 1);
      if (size<0 || i + size>nChannels)
        return 0;
 
      for (; *ptr && *ptr != ']' && *ptr != ')'; ptr++);
      if (!*ptr)
        ptr--;
    }
    else if (validNameChar(*ptr, bFirst)) {
      name += *ptr;
    }
    else {
      return false;
    }
  }
 
  if (!name.empty() && i < nChannels) {
    isp.first = i;
    isp.second = size;
    chanMap[name] = isp;
  }
 
  return true;
}

References validNameChar().

Referenced by ParseXml().

Here is the call graph for this function:

Here is the caller graph for this function:

ParseImport()

bool CIccMpeXmlCalculator::ParseImport	(	xmlNode *	pNode,
		std::string	importPath,
		std::string &	parseStr
	)

{
  xmlNode *pChild, *pNext;
  xmlAttr *attr;
 
  pChild = icXmlFindNode(pNode->children, "Imports");
  if (pChild) {
    for (pNext = pChild->children; pNext; pNext = pNext->next) {
      if (pNext->type == XML_ELEMENT_NODE) {
        if (!strcmp((icChar*)pNext->name, "Import")) {
          if ((attr = icXmlFindAttr(pNext, "Filename"))) {
            std::string file = icXmlAttrValue(attr);
            xmlDoc *doc = NULL;
            xmlNode *root_element = NULL;
 
            std::string look = "*";
            look += file;
            look += "*";
 
            if (strstr(importPath.c_str(), look.c_str())) {
              //Already imported this file
              continue;
            }
 
            /*parse the file and get the DOM */
            doc = xmlReadFile(file.c_str(), NULL, 0);
 
            if (doc == NULL) {
              parseStr += "Unable to import '";
              parseStr += file;
              parseStr += '\n';
              return false;
            }
 
            /*Get the root element node */
            root_element = xmlDocGetRootElement(doc);
            if (strcmp((icChar*)root_element->name, "IccCalcImport")) {
              parseStr += "Invalid calc element import file '" + file + "'\n";
              return false;
            }
 
            bool rv = ParseImport(root_element, importPath+file+"*", parseStr);
 
            xmlFreeDoc(doc);
          }
          else {
            parseStr += "Missing import file specifier\n";
            return false;
          }
        }
        else {
          parseStr += "Invalid import specifier\n";
          return false;
        }
      }
    }
  }
 
  pChild = icXmlFindNode(pNode->children, "Variables");
  if (pChild) {
    for (pNext = pChild->children; pNext; pNext = pNext->next) {
      if (pNext->type == XML_ELEMENT_NODE) {
        if (!strcmp((icChar*)pNext->name, "Declare")) {
          if ((attr = icXmlFindAttr(pNext, "Name"))) {
            std::string name = icXmlAttrValue(attr);
            if (!validName(name.c_str())) {
              parseStr += "Invalid calc element variable name '" + name + "'\n'";
              return false;
            }
 
            TempDeclVarMap::iterator v = m_declVarMap.find(name);
            if (v != m_declVarMap.end()) {
              parseStr += "Calc element variable '" + name + "' was previously declared\n";
              return false;
            }
            int offset = -1;
            icUInt16Number size = 1;
 
            if ((attr = icXmlFindAttr(pNext, "Position"))) {
              offset = atoi(icXmlAttrValue(attr));
              if (offset && importPath != "*") {
                parseStr += "Position cannot be specified for imported variables";
                return false;
              }
            }
            if ((attr = icXmlFindAttr(pNext, "Size"))) {
              size = (icUInt16Number)atoi(icXmlAttrValue(attr));
            }
            if (size < 1) size = 1;
 
            CIccTempDeclVar var = CIccTempDeclVar(name, offset, size);
            if (pNext->children && pNext->children->content) {
              CIccFuncTokenizer parse((icChar*)pNext->children->content);
              offset = 0;
 
              while (parse.GetNext()) {
                icUInt16Number extra = 0;
                std::string member = parse.GetName();
                if (!validName(member.c_str())) {
                  parseStr += "Invalid member name '" + member + "' for calc element variable '" + name + "'\n";
                  return false;
                }
                size = 0; extra = 0;
                parse.GetIndex(size, extra, 1, 0);
                size++;
                if (size < 1) 
                  size = 1;
 
                var.m_members.push_back(CIccTempVar(member, offset, size));
                offset += size;
              }
              if (var.m_size < offset)
                var.m_size = offset;
            }
            m_declVarMap[name] = var;
          }
          else {
            parseStr += "Missing calc element variable name definition\n";
            return false;
          }
        }
        else {
          parseStr += "Invalid calc element variable declaration\n";
          return false;
        }
      }
    }
  }
 
  pChild = icXmlFindNode(pNode->children, "Macros");
  if (pChild) {
    for (pNext = pChild->children; pNext; pNext = pNext->next) {
      if (pNext->type == XML_ELEMENT_NODE) {
        if (!strcmp((icChar*)pNext->name, "Macro")) {
          if ((attr = icXmlFindAttr(pNext, "Name"))) {
            std::string name = icXmlAttrValue(attr);
            if (!validName(name.c_str())) {
              parseStr += "Invalid Macro name '" + name + "'\n'";
              return false;
            }
            if (!pNext->children || !pNext->children->content || !pNext->children->content[0]) {
              parseStr += "Missing content for macro '" + name + "'\n'";
              return false;
            }
            MacroMap::iterator m = m_macroMap.find(name);
            if (m != m_macroMap.end()) {
              if (!strcmp(m->second.c_str(), (icChar*)pNext->children->content))
                continue;
              parseStr += "Calc Element macro '" + name + "' was previously defined differently\n";
              return false;
            }
            m_macroMap[name] = (icChar*)(pNext->children->content);
 
            if ((attr = icXmlFindAttr(pNext, "Local"))) {
              icUInt16Number offset, size;
              CIccTempDeclVar var = CIccTempDeclVar(name, 0, 0);
              std::string locals = icXmlAttrValue(attr);
              CIccFuncTokenizer parse(locals.c_str());
              offset = 0;
 
              while (parse.GetNext()) {
                icUInt16Number extra = 0;
                std::string member = parse.GetName();
                if (!validName(member.c_str())) {
                  parseStr += "Invalid local name '" + member + "' for calc element macro '" + name + "'\n";
                  return false;
                }
                size = 0; extra = 0;
                parse.GetIndex(size, extra, 1, 0);
                size++;
                if (size < 1)
                  size = 1;
 
                var.m_members.push_back(CIccTempVar(member, offset, size));
                offset += size;
              }
              if (var.m_size < offset)
                var.m_size = offset;
 
              m_macroLocalMap[name] = var;
            }
          }
          else {
            parseStr += "Missing macro name\n";
            return false;
          }
        }
        else {
          parseStr += "Invalid macro declaration\n";
          return false;
        }
      }
    }
  }
 
  pChild = icXmlFindNode(pNode->children, "SubElements");
  if (pChild) {
    for (pNext = pChild->children; pNext; pNext = pNext->next) {
      if (pNext->type == XML_ELEMENT_NODE) {
        std::string name;
 
        if ((attr = icXmlFindAttr(pNext, "Name"))) {
          name = icXmlAttrValue(attr);
          if (!validName(name.c_str())) {
            parseStr += "Invalid SubElement name '" + name + "'\n'";
            return false;
          }
        }
        if (name.empty()) {
          if (importPath != "*") {
            parseStr += "Imported Calc SubElments must be named.";
            return false;
          }
        }
        else {
          MpePtrMap::iterator se = m_mpeMap.find(name);
          if (se != m_mpeMap.end()) {
            parseStr += "Duplicate declaration of SubElement '" + name + "'\n";
            return false;
          }
        }
 
        CIccMultiProcessElement *pMpe = CIccTagXmlMultiProcessElement::CreateElement((const icChar*)pNext->name);
 
        if (!pMpe) {
          parseStr += std::string("Unknown Sub-Element Type (") + (const icChar*)pNext->name + ")\n";
          return false;
        }
 
        if (!strcmp(pMpe->GetClassName(), "CIccMpeXmlCalculator")) {
          CIccMpeXmlCalculator *pSubCalc = (CIccMpeXmlCalculator*)pMpe;
          pSubCalc->m_sImport = importPath;
        }
 
        xmlAttr *attr;
        IIccExtensionMpe *pExt = pMpe->GetExtension();
 
        if (pExt) {
          if (!strcmp(pExt->GetExtClassName(), "CIccMpeXml")) {
            CIccMpeXml* pXmlMpe = (CIccMpeXml*)pExt;
 
            if (pXmlMpe->ParseXml(pNext, parseStr)) {
              if ((attr = icXmlFindAttr(pNode, "Reserved"))) {
                sscanf(icXmlAttrValue(attr), "%u", &pMpe->m_nReserved);
              }
 
              if (name.empty()) {
                m_mpeList.push_back(CIccMpePtr(pMpe, m_nNextMpe));
                m_nNextMpe++;
              }
              else {
                m_mpeMap[name] = CIccMpePtr(pMpe);
              }
            }
            else {
              char str[100];
              sprintf(str, " starting on line %d", pNext->line);
              parseStr += std::string("Unable to parse element of type ") + pMpe->GetClassName() + str + "\n";
              delete pMpe;
              return false;
            }
          }
          else {
            parseStr += std::string("Element ") + pMpe->GetClassName() + "isn't of type CIccMpeXml\n";
            delete pMpe;
            return false;
          }
        }
        else {
          parseStr += std::string("Element ") + pMpe->GetClassName() + "isn't of type CIccMpeXml\n";
          delete pMpe;
          return false;
        }
      }
    }
  }
  return true;
}

References CIccFuncTokenizer::CIccFuncTokenizer(), CIccMpePtr::CIccMpePtr(), CIccTempDeclVar::CIccTempDeclVar(), CIccTempVar::CIccTempVar(), CIccTagXmlMultiProcessElement::CreateElement(), CIccMultiProcessElement::GetClassName(), IIccExtensionMpe::GetExtClassName(), CIccMultiProcessElement::GetExtension(), CIccFuncTokenizer::GetIndex(), CIccFuncTokenizer::GetName(), CIccFuncTokenizer::GetNext(), icXmlAttrValue(), icXmlFindAttr(), icXmlFindNode(), m_declVarMap, m_macroLocalMap, m_macroMap, CIccTempDeclVar::m_members, m_mpeList, m_mpeMap, m_nNextMpe, CIccMultiProcessElement::m_nReserved, m_sImport, CIccTempDeclVar::m_size, ParseImport(), CIccMpeXml::ParseXml(), and validName().

Referenced by ParseImport(), and ParseXml().

Here is the call graph for this function:

Here is the caller graph for this function:

ParseXml()

bool CIccMpeXmlCalculator::ParseXml ( xmlNode *  pNode, std::string &  parseStr  )

virtual

Implements CIccMpeXml.

{
  xmlNode *pChild;
  
  SetSize(atoi(icXmlAttrValue(pNode, "InputChannels")),
          atoi(icXmlAttrValue(pNode, "OutputChannels")));
 
  clean();
 
  if (!ParseChanMap(m_inputMap, icXmlAttrValue(pNode, "InputNames"), m_nInputChannels)) {
    parseStr += "Invalid name for InputChannels";
    return false;
  }
 
  if (!ParseChanMap(m_outputMap, icXmlAttrValue(pNode, "OutputNames"), m_nOutputChannels)) {
    parseStr += "Invalid name for InputChannels";
    return false;
  }
 
  if (!ParseImport(pNode, "*", parseStr))
    return false;
 
  if (!ValidateMacroCalls(parseStr)) {
    return false;
  }
 
  pChild = icXmlFindNode(pNode->children, "MainFunction");
  if (pChild && pNode->children && pChild->children->content) {
    char *content = (char*)pChild->children->content;
    std::string flatFunc;
 
    //Move new variables to after allocated variables
    TempDeclVarMap::iterator declVar;
    for (declVar = m_declVarMap.begin(); declVar != m_declVarMap.end(); declVar++) {
      if (declVar->second.m_pos >= 0) {
        int next = declVar->second.m_pos + declVar->second.m_size;
        if (next > m_nNextVar)
          m_nNextVar = next;
      }
    }
 
    if (!Flatten(flatFunc, "", content, parseStr, 0)) {
      return false;
    }
 
    if (m_macroLocalMap.size()) {
      std::string localFunc;
      if (!UpdateLocals(localFunc, flatFunc, parseStr, m_nNextVar)) {
        return false;
      }
      flatFunc = localFunc;
    }
    //copy MPE subelmeents used by Main Function to returned object
    int n;
    MpePtrList::iterator m;
    for (m = m_mpeList.begin(), n = 0; m != m_mpeList.end(); m++, n++) {
      this->SetSubElem(n, m->m_ptr);
      m->m_ptr = NULL;
    }
 
#if 0
    FILE *ff = fopen("flatfunc.txt", "wb");
    fwrite(flatFunc.c_str(), flatFunc.size(), 1, ff);
    fclose(ff);
#endif
 
    icFuncParseStatus stat = SetCalcFunc(flatFunc.c_str(), parseStr);
    if (stat!=icFuncParseNoError) {
      char buf[65];
      int len = icIntMin(64, (int)strlen(flatFunc.c_str()));
      strncpy(buf, flatFunc.c_str(), len);
      buf[len]=0;
 
      switch(stat) {
        case icFuncParseSyntaxError:
          parseStr += "Syntax Error occurred while parsing Main Calculator Function from \"";
          break;
        case icFuncParseInvalidOperation:
          parseStr += "Invalid Operation found while parsing Main Calculator Function from \"";
          break;
        case icFuncParseStackUnderflow:
          parseStr += "Stack underflow detected while parsing Main Calculator Function from \"";
          break;
        case icFuncParseInvalidChannel:
          parseStr += "Invalid Channel detected while parsing Main Calculator Function from \"";
          break;
        default:
          parseStr += "Unable to parse Main Calculator Function from \"";
      }
      parseStr += buf;
      parseStr += "\"\n";
      return false;
    }
  }
  clean();
 
  return true;
}

References clean(), Flatten(), icFuncParseInvalidChannel, icFuncParseInvalidOperation, icFuncParseNoError, icFuncParseStackUnderflow, icFuncParseSyntaxError, icIntMin(), icXmlAttrValue(), icXmlFindNode(), m_declVarMap, m_inputMap, m_macroLocalMap, m_mpeList, CIccMultiProcessElement::m_nInputChannels, m_nNextVar, CIccMultiProcessElement::m_nOutputChannels, m_outputMap, CIccTempDeclVar::m_pos, CIccMpePtr::m_ptr, CIccTempDeclVar::m_size, ParseChanMap(), ParseImport(), CIccMpeCalculator::SetCalcFunc(), CIccMpeCalculator::SetSize(), CIccMpeCalculator::SetSubElem(), UpdateLocals(), and ValidateMacroCalls().

Referenced by CIccSampledCalculatorCurveXml::ParseXml().

Here is the call graph for this function:

Here is the caller graph for this function:

Read()

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

virtualinherited

Name: CIccMpeCalculator::Read

Purpose:

Args:

Return:

Implements CIccMultiProcessElement.

{
  icElemTypeSignature sig;
 
  icUInt32Number startPos = pIO->Tell();
  
  icUInt32Number headerSize = sizeof(icTagTypeSignature) + 
    sizeof(icUInt32Number) + 
    sizeof(icUInt16Number) + 
    sizeof(icUInt16Number) +
    sizeof(icUInt16Number) +
    sizeof(icUInt16Number) +
    sizeof(icUInt16Number) +
    sizeof(icUInt16Number);
 
  if (headerSize > size)
    return false;
 
  if (!pIO) {
    return false;
  }
 
  icUInt16Number nInputChannels, nOutputChannels;
 
  if (!pIO->Read32(&sig))
    return false;
 
  if (!pIO->Read32(&m_nReserved))
    return false;
 
  if (!pIO->Read16(&nInputChannels))
    return false;
 
  if (!pIO->Read16(&nOutputChannels))
    return false;
 
  SetSize(nInputChannels, nOutputChannels);
 
  icUInt32Number nSubElem;
 
  if (!pIO->Read32(&nSubElem))
    return false;
 
  icUInt32Number nPos = nSubElem + 1;
 
  if (headerSize + (icUInt64Number)nPos*sizeof(icPositionNumber) > size) {
    return false;
  }
 
  icPositionNumber *pos, *posvals = (icPositionNumber*)malloc(nPos*sizeof(icPositionNumber));
  if (!posvals) {
    return false;
  }
 
  icUInt32Number n = nPos * (sizeof(icPositionNumber)/sizeof(icUInt32Number));
  if (pIO->Read32(posvals, n)!=n) {
    free(posvals);
    return false;
  }
 
  pos = &posvals[1];
  if (nSubElem) {
    icElemTypeSignature elemSig;
 
    SetSubElem(nSubElem-1, NULL); //Initialize array
 
    for (n=0; n<nSubElem; n++) {
      if (pos->offset + pos->size > size) {
        free(posvals);
        return false;
      }
      pIO->Seek(startPos + pos->offset, icSeekSet);
 
      if (!pIO->Read32(&elemSig)) {
        free(posvals);
        return false;
      }
 
      CIccMultiProcessElement *pElem = CIccMultiProcessElement::Create(elemSig);
      if (!pElem) {
        free(posvals);
        return false;
      }
 
      pIO->Seek(startPos + pos->offset, icSeekSet);
      if (!pElem->Read(pos->size, pIO)) {
        free(posvals);
        return false;
      }
      SetSubElem((icUInt16Number)n, (CIccMpeCalculator*)pElem);
      pos++;
    }
  }  
 
  m_calcFunc = new CIccCalculatorFunc(this);
  pos = posvals;
 
  if (!m_calcFunc || pos->offset + pos->size > size) {
    free(posvals);
    return false;
  }
 
  pIO->Seek(startPos + pos->offset, icSeekSet);
 
  if (!m_calcFunc->Read(pos->size, pIO)) {
    return false;
  }
  free(posvals);
 
  pIO->Seek(startPos + size, icSeekSet);
 
  return true;
}

References CIccCalculatorFunc::CIccCalculatorFunc(), CIccMultiProcessElement::Create(), icSeekSet, CIccMpeCalculator::m_calcFunc, CIccMultiProcessElement::m_nReserved, icPositionNumber::offset, CIccCalculatorFunc::Read(), CIccMultiProcessElement::Read(), CIccIO::Read16(), CIccIO::Read32(), CIccIO::Seek(), CIccMpeCalculator::SetSize(), CIccMpeCalculator::SetSubElem(), icPositionNumber::size, and CIccIO::Tell().

Referenced by CIccSampledCalculatorCurve::Read().

Here is the call graph for this function:

Here is the caller graph for this function:

Reset()

void CIccMpeCalculator::Reset ( )

inlineinherited

{ SetSize(0,0); }

References CIccMpeCalculator::SetSize().

Here is the call graph for this function:

SetCalcFunc() [1/2]

icFuncParseStatus CIccMpeCalculator::SetCalcFunc ( const char *  szFuncDef, std::string &  sReport  )

inherited

Name: CIccMpeCalculator::SetCalcFunc

Purpose:

Args:

Return:

{
 
  if (m_calcFunc) {
    delete m_calcFunc;
    m_calcFunc = NULL;
  }
 
  CIccCalculatorFunc *pFunc = new CIccCalculatorFunc(this);
  icFuncParseStatus rv = pFunc->SetFunction(szFuncDef, sReport);
  
  if (rv!=icFuncParseNoError) {
    delete pFunc;
    m_calcFunc = NULL;
 
    return rv;
  }
 
  m_calcFunc = pFunc;
 
  return rv;
}

References CIccCalculatorFunc::CIccCalculatorFunc(), icFuncParseNoError, CIccMpeCalculator::m_calcFunc, and CIccCalculatorFunc::SetFunction().

Referenced by ParseXml().

Here is the call graph for this function:

Here is the caller graph for this function:

SetCalcFunc() [2/2]

icFuncParseStatus CIccMpeCalculator::SetCalcFunc ( icCalculatorFuncPtr  newChannelFunc )

inherited

Name: CIccMpeCalculator::SetCalcFunc

Purpose:

Args:

Return:

{
  if (m_calcFunc) {
    delete m_calcFunc;
  }
  m_calcFunc = newChannelFunc;
  
  return icFuncParseNoError;
}

References icFuncParseNoError, and CIccMpeCalculator::m_calcFunc.

SetElem()

bool CIccMpeCalculator::SetElem ( icUInt32Number  idx, CIccMultiProcessElement *  pElem, icUInt32Number &  count, CIccMultiProcessElement ***  pArray  )

protectedinherited

Name: CIccMpeCalculator::GetSubApply

Purpose:

Args:

Return:

{
  bool rv = true;
 
  if (idx + 1 > count) {
    if (*pArray) {
      *pArray = (CIccMultiProcessElement**)icRealloc(*pArray, (idx + 1) * sizeof(CIccMultiProcessElement*));
 
      if (!(*pArray))
        return false;
 
      icUInt32Number i;
      for (i = count; i <= idx; i++) {
        (*pArray)[i] = NULL;
      }
    }
    else {
      *pArray = (CIccMultiProcessElement**)calloc(idx + 1, sizeof(CIccMultiProcessElement*));
 
      if (!(*pArray))
        return false;
    }
    count = idx + 1;
  }
  else if (!(*pArray))
    return false;
 
  if ((*pArray)[idx]) {
    delete (*pArray)[idx];
    rv = false;
  }
 
  (*pArray)[idx] = pElem;
 
  return rv;
}

References icRealloc().

Referenced by CIccMpeCalculator::SetSubElem().

Here is the call graph for this function:

Here is the caller graph for this function:

SetSize()

void CIccMpeCalculator::SetSize ( icUInt16Number  nInputChannels, icUInt16Number  nOutputChannels  )

inherited

Name: CIccMpeCalculator::SetSize

Purpose:

Args:

Return:

{
  if (m_calcFunc) {
    delete m_calcFunc;
    m_calcFunc = NULL;
  }
  icUInt32Number i;
 
  if (m_SubElem) {
    for (i=0; i<m_nSubElem; i++) {
      if (m_SubElem[i])
        delete m_SubElem[i];
    }
    free(m_SubElem);
    m_SubElem = NULL;
    m_nSubElem = 0;
  }
 
  m_nInputChannels = nInputChannels;
  m_nOutputChannels = nOutputChannels;
}

References CIccMpeCalculator::m_calcFunc, CIccMultiProcessElement::m_nInputChannels, CIccMultiProcessElement::m_nOutputChannels, CIccMpeCalculator::m_nSubElem, and CIccMpeCalculator::m_SubElem.

Referenced by CIccMpeCalculator::~CIccMpeCalculator(), CIccMpeCalculator::operator=(), ParseXml(), CIccMpeCalculator::Read(), and CIccMpeCalculator::Reset().

Here is the caller graph for this function:

SetSubElem()

bool CIccMpeCalculator::SetSubElem ( icUInt32Number  idx, CIccMultiProcessElement *  pElem  )

inlineinherited

{ return SetElem(idx, pElem, m_nSubElem, &m_SubElem); }

References CIccMpeCalculator::m_nSubElem, CIccMpeCalculator::m_SubElem, and CIccMpeCalculator::SetElem().

Referenced by ParseXml(), and CIccMpeCalculator::Read().

Here is the call graph for this function:

Here is the caller graph for this function:

ToXml()

bool CIccMpeXmlCalculator::ToXml ( std::string &  xml, std::string  blanks = ""  )

virtual

Implements CIccMpeXml.

{
  char line[256];
  std::string blanks2 = blanks + "  ";
 
  sprintf(line, "<CalculatorElement InputChannels=\"%d\" OutputChannels=\"%d\"", NumInputChannels(), NumOutputChannels());
  xml += blanks + line;
 
  if (m_nReserved) {
    sprintf(line, " Reserved=\"%u\"", m_nReserved);
    xml += line;
  }
  xml += ">\n";
 
  int i;
 
  if (m_SubElem && m_nSubElem) {
    xml += blanks2 + "<SubElements>\n";
    for (i=0; i<(int)m_nSubElem; i++) {
      if (m_SubElem[i]) {
        IIccExtensionMpe *pExt = m_SubElem[i]->GetExtension();
        if (pExt && !strcmp(pExt->GetExtClassName(), "CIccMpeXml")) {
          CIccMpeXml *pMpe = (CIccMpeXml*)pExt;
          pMpe->ToXml(xml, blanks2+"  ");
        }
        else {
          return false;
        }
      }
      else {
        return false;
      }
    }
    xml += blanks2 + "</SubElements>\n";
  }
 
  if (m_calcFunc) {
    std::string desc;
 
    xml += blanks2 + "<MainFunction>\n";
 
    m_calcFunc->Describe(desc, 100, (int)blanks2.size()+2);
    xml += desc;
 
    xml+= blanks2 + "</MainFunction>\n";
  }
 
  xml += blanks + "</CalculatorElement>\n";
  return true;
}

References CIccCalculatorFunc::Describe(), IIccExtensionMpe::GetExtClassName(), CIccMultiProcessElement::GetExtension(), CIccMpeCalculator::m_calcFunc, CIccMultiProcessElement::m_nReserved, CIccMpeCalculator::m_nSubElem, CIccMpeCalculator::m_SubElem, CIccMultiProcessElement::NumInputChannels(), CIccMultiProcessElement::NumOutputChannels(), and CIccMpeXml::ToXml().

Referenced by CIccSampledCalculatorCurveXml::ToXml().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateLocals()

bool CIccMpeXmlCalculator::UpdateLocals ( std::string &  func, std::string  szFunc, std::string &  parseStr, int  nLocalsOffset  )

protected

{
  func.clear();
  CIccFuncTokenizer parse(sFunc.c_str(), true);
 
  while (parse.GetNext()) {
    std::string token = parse.GetLast();
    const char *tok = token.c_str();
 
    if (!strncmp(tok, "lget[", 5) ||
        !strncmp(tok, "lput[", 5) ||
        !strncmp(tok, "lsav[", 5)) {
      std::string op = parse.GetName();
      int voffset, vsize;
 
      CIccFuncTokenizer p2(tok+4);
      icUInt16Number _voffset = 0, _vsize = 1;
      p2.GetIndex(_voffset, _vsize, 0, 1);
      voffset = _voffset + nLocalsOffset;
      vsize = _vsize + 1;
 
      if (voffset + vsize > 65535) {
        parseStr += "Local variable out of bounds - too many variables.\n";
        return false;
      }
 
      char idx[80];
      if (vsize == 1) {
        sprintf(idx, "[%d]", voffset);
      }
      else {
        sprintf(idx, "[%d,%d]", voffset, vsize);
      }
      func +="t";
      func += op.substr(1);
      func += idx;
      func += " ";
    }
    else {
      func += tok;
      func += " ";
    }
  }
 
  return true;
}

References CIccFuncTokenizer::CIccFuncTokenizer(), CIccFuncTokenizer::GetIndex(), CIccFuncTokenizer::GetLast(), CIccFuncTokenizer::GetName(), and CIccFuncTokenizer::GetNext().

Referenced by ParseXml().

Here is the call graph for this function:

Here is the caller graph for this function:

Validate()

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

virtualinherited

Name: CIccMpeCalculator::Validate

Purpose:

Args:

Return:

Implements CIccMultiProcessElement.

{
  std::string mpeSigPath = sigPath + icGetSigPath(GetType());
  icValidateStatus rv = CIccMultiProcessElement::Validate(sigPath, sReport, pMPE, pProfile);
 
  icUInt32Number i;
 
  if (m_SubElem) {
    for (i=0; i<m_nSubElem; i++) {
      if (m_SubElem[i])
        rv = icMaxStatus(rv, m_SubElem[i]->Validate(mpeSigPath, sReport, pMPE, pProfile));
    }
  }
 
  bool empty=false;
  if (m_calcFunc) {
    rv = icMaxStatus(rv, m_calcFunc->Validate(mpeSigPath, sReport, this, pProfile));
  }
  else
    empty = true;
 
  if (empty) {
    CIccInfo Info;
    std::string sSigPathName = Info.GetSigPathName(sigPath);
 
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sReport += " - Has an Empty Calculator Functions!\n";
    rv = icMaxStatus(rv, icValidateCriticalError);
  }
 
  return rv;
}

References CIccInfo::GetSigPathName(), CIccMpeCalculator::GetType(), icGetSigPath(), icMaxStatus(), icMsgValidateCriticalError, icValidateCriticalError, CIccMpeCalculator::m_calcFunc, CIccMpeCalculator::m_nSubElem, CIccMpeCalculator::m_SubElem, CIccCalculatorFunc::Validate(), and CIccMultiProcessElement::Validate().

Referenced by CIccSampledCalculatorCurve::Validate().

Here is the call graph for this function:

Here is the caller graph for this function:

ValidateMacroCalls()

bool CIccMpeXmlCalculator::ValidateMacroCalls ( std::string &  parseStr ) const

protected

{
  MacroMap::const_iterator m;
 
  for (m = m_macroMap.begin(); m != m_macroMap.end(); m++) {
    if (!ValidMacroCalls(m->second.c_str(), "*", parseStr)) {
      return false;
    }
  }
  return true;
}

References m_macroMap, and ValidMacroCalls().

Referenced by ParseXml().

Here is the call graph for this function:

Here is the caller graph for this function:

ValidMacroCalls()

bool CIccMpeXmlCalculator::ValidMacroCalls ( const char *  szMacroText, std::string  macroStack, std::string &  parseStr  ) const

protected

{
  const char *ptr;
  for (ptr = strstr(szMacroText, "call{"); ptr; ptr = strstr(ptr, "call{")) {
    CIccFuncTokenizer parse(ptr, true);
    parse.GetNext();
 
    std::string name = parse.GetReference();
    MacroMap::const_iterator m = m_macroMap.find(name);
    if (m == m_macroMap.end()) {
      parseStr += "Call to undefined macro '" + name + "'\n";
      return false;
    }
    std::string sm = "*";
    sm += name + "*";
    if (strstr(macroStack.c_str(), sm.c_str())) {
      parseStr += "Macro recursion detected in call to '" + name + "'\n";
      return false;
    }
    if (!ValidMacroCalls(m->second.c_str(), macroStack + name + "*", parseStr)) {
      return false;
    }
    ptr++;
  }
  return true;
}

References CIccFuncTokenizer::CIccFuncTokenizer(), CIccFuncTokenizer::GetNext(), CIccFuncTokenizer::GetReference(), m_macroMap, and ValidMacroCalls().

Referenced by ValidateMacroCalls(), and ValidMacroCalls().

Here is the call graph for this function:

Here is the caller graph for this function:

validName()

bool CIccMpeXmlCalculator::validName ( const char *  saName )

staticprotected

{
  const char *ptr;
  if (!szName || !*szName) {
    return false;
  }
 
  for (ptr = szName; *ptr; ptr++) {
    if (!validNameChar(*ptr, ptr == szName))
      return false;
  }
 
  return true;
}

References validNameChar().

Referenced by ParseImport().

Here is the call graph for this function:

Here is the caller graph for this function:

validNameChar()

bool CIccMpeXmlCalculator::validNameChar ( char  c, bool  bFirst  )

staticprotected

{
  if (bFirst && !((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c == '_')))
    return false;
  else if (!((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || (c == '_')))
    return false;
 
  return true;
}

Referenced by ParseChanMap(), and validName().

Here is the caller graph for this function:

Write()

bool CIccMpeCalculator::Write ( CIccIO *  pIO )

virtualinherited

Name: CIccMpeCalculator::Write

Purpose:

Args:

Return:

Implements CIccMultiProcessElement.

{
  icElemTypeSignature sig = GetType();
 
  if (!pIO)
    return false;
 
  icUInt32Number elemStart = pIO->Tell();
 
  if (!pIO->Write32(&sig))
    return false;
 
  if (!pIO->Write32(&m_nReserved))
    return false;
 
  if (!pIO->Write16(&m_nInputChannels))
    return false;
 
  if (!pIO->Write16(&m_nOutputChannels))
    return false;
 
  if (!pIO->Write32(&m_nSubElem))
    return false;
 
  icUInt32Number nPos = m_nSubElem + 1;
 
  icPositionNumber *pos, *posvals = (icPositionNumber*)calloc(nPos, sizeof(icPositionNumber));
  if (!posvals) {
    return false;
  }
  icUInt32Number nPositionStart = pIO->Tell();
 
  icUInt32Number n, np = nPos * (sizeof(icPositionNumber)/sizeof(icUInt32Number));
  if (pIO->Write32(posvals, np)!=np) {
    free(posvals);
    return false;
  }
 
  if (m_calcFunc) {
    posvals[0].offset = pIO->Tell()-elemStart;
    if (!m_calcFunc->Write(pIO)) {
      free(posvals);
      return false;
    }
    posvals[0].size = pIO->Tell()-elemStart - posvals[nPos-1].offset;
    pIO->Align32();
  }
 
  pos = &posvals[1];
 
  if (m_nSubElem) {
    for(n=0; n<m_nSubElem; n++) {
      if (m_SubElem[n]) {
        pos->offset = pIO->Tell()-elemStart;
        if (!m_SubElem[n]->Write(pIO)) {
          free(posvals);
          return false;
        }
        pos->size = pIO->Tell()-elemStart - pos->offset;
        pIO->Align32();
      }
      pos++;
    }
  }
  icUInt32Number endPos = pIO->Tell();
 
  pIO->Seek(nPositionStart, icSeekSet);
 
  if (pIO->Write32(posvals, np)!=np) {
    free(posvals);
    return false;
  }
  free(posvals);
 
  pIO->Seek(endPos, icSeekSet);
 
  return true;
}

References CIccIO::Align32(), CIccMpeCalculator::GetType(), icSeekSet, CIccMpeCalculator::m_calcFunc, CIccMultiProcessElement::m_nInputChannels, CIccMultiProcessElement::m_nOutputChannels, CIccMultiProcessElement::m_nReserved, CIccMpeCalculator::m_nSubElem, CIccMpeCalculator::m_SubElem, icPositionNumber::offset, CIccIO::Seek(), icPositionNumber::size, CIccIO::Tell(), CIccCalculatorFunc::Write(), CIccMultiProcessElement::Write(), CIccIO::Write16(), and CIccIO::Write32().

Referenced by CIccSampledCalculatorCurve::Write().

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

m_bNeedTempReset

bool CIccMpeCalculator::m_bNeedTempReset

protectedinherited

Referenced by CIccMpeCalculator::CIccMpeCalculator(), CIccMpeCalculator::CIccMpeCalculator(), CIccMpeCalculator::Apply(), and CIccMpeCalculator::Begin().

m_calcFunc

icCalculatorFuncPtr CIccMpeCalculator::m_calcFunc

protectedinherited

Referenced by CIccMpeCalculator::CIccMpeCalculator(), CIccMpeCalculator::CIccMpeCalculator(), CIccMpeCalculator::Apply(), CIccMpeCalculator::Begin(), CIccMpeCalculator::Describe(), CIccMpeCalculator::operator=(), CIccMpeCalculator::Read(), CIccMpeCalculator::SetCalcFunc(), CIccMpeCalculator::SetCalcFunc(), CIccMpeCalculator::SetSize(), ToXml(), CIccMpeCalculator::Validate(), and CIccMpeCalculator::Write().

m_declVarMap

TempDeclVarMap CIccMpeXmlCalculator::m_declVarMap

protected

Referenced by clean(), Flatten(), ParseImport(), and ParseXml().

m_inputMap

ChanVarMap CIccMpeXmlCalculator::m_inputMap

protected

Referenced by Flatten(), and ParseXml().

m_macroLocalMap

TempDeclVarMap CIccMpeXmlCalculator::m_macroLocalMap

protected

Referenced by Flatten(), ParseImport(), and ParseXml().

m_macroMap

MacroMap CIccMpeXmlCalculator::m_macroMap

protected

Referenced by clean(), Flatten(), ParseImport(), ValidateMacroCalls(), and ValidMacroCalls().

m_mpeList

MpePtrList CIccMpeXmlCalculator::m_mpeList

protected

Referenced by clean(), Flatten(), ParseImport(), and ParseXml().

m_mpeMap

MpePtrMap CIccMpeXmlCalculator::m_mpeMap

protected

Referenced by clean(), Flatten(), and ParseImport().

m_nInputChannels

icUInt16Number CIccMultiProcessElement::m_nInputChannels

protectedinherited

Referenced by CIccMpeBAcs::CIccMpeBAcs(), CIccMpeBAcs::CIccMpeBAcs(), CIccMpeCalculator::CIccMpeCalculator(), CIccMpeCalculator::CIccMpeCalculator(), CIccMpeCAM::CIccMpeCAM(), CIccMpeCLUT::CIccMpeCLUT(), CIccMpeCLUT::CIccMpeCLUT(), CIccMpeCurveSet::CIccMpeCurveSet(), CIccMpeCurveSet::CIccMpeCurveSet(), CIccMpeEAcs::CIccMpeEAcs(), CIccMpeEAcs::CIccMpeEAcs(), CIccMpeExtCLUT::CIccMpeExtCLUT(), CIccMpeMatrix::CIccMpeMatrix(), CIccMpeMatrix::CIccMpeMatrix(), CIccMpeSpectralCLUT::CIccMpeSpectralCLUT(), CIccMpeSpectralCLUT::CIccMpeSpectralCLUT(), CIccMpeSpectralMatrix::CIccMpeSpectralMatrix(), CIccMpeSpectralMatrix::CIccMpeSpectralMatrix(), CIccMpeSpectralObserver::CIccMpeSpectralObserver(), CIccMpeSpectralObserver::CIccMpeSpectralObserver(), CIccMpeTintArray::CIccMpeTintArray(), CIccMpeTintArray::CIccMpeTintArray(), CIccMpeToneMap::CIccMpeToneMap(), CIccMpeToneMap::CIccMpeToneMap(), CIccMultiProcessElement::CIccMultiProcessElement(), CIccMpeAcs::Apply(), CIccMpeCurveSet::Apply(), CIccMpeMatrix::Apply(), CIccMpeAcs::Begin(), CIccMpeCurveSet::Begin(), CIccMpeMatrix::Begin(), CIccMpeCLUT::Begin(), CIccMpeEmissionMatrix::Begin(), CIccMpeInvEmissionMatrix::Begin(), CIccMpeEmissionCLUT::Begin(), CIccMpeReflectanceCLUT::Begin(), CIccMpeEmissionObserver::Begin(), CIccMpeReflectanceObserver::Begin(), CIccMpeSpectralCLUT::copyData(), CIccMpeSpectralMatrix::copyData(), CIccMpeSpectralObserver::copyData(), CIccMpeCurveSet::Describe(), CIccMpeMatrix::Describe(), CIccMpeCalculator::Describe(), CIccMpeSpectralMatrix::Describe(), CIccMpeSpectralObserver::Describe(), Flatten(), CIccMultiProcessElement::NumInputChannels(), CIccMpeEmissionMatrix::numVectors(), CIccMpeBAcs::operator=(), CIccMpeCalculator::operator=(), CIccMpeCLUT::operator=(), CIccMpeCurveSet::operator=(), CIccMpeEAcs::operator=(), CIccMpeMatrix::operator=(), CIccMpeTintArray::operator=(), CIccMpeToneMap::operator=(), CIccMpeXmlTintArray::ParseXml(), CIccMpeXmlToneMap::ParseXml(), CIccMpeXmlMatrix::ParseXml(), CIccMpeXmlCLUT::ParseXml(), CIccMpeXmlExtCLUT::ParseXml(), CIccMpeXmlBAcs::ParseXml(), CIccMpeXmlEAcs::ParseXml(), CIccMpeXmlJabToXYZ::ParseXml(), CIccMpeXmlXYZToJab::ParseXml(), ParseXml(), CIccMpeXmlEmissionCLUT::ParseXml(), CIccMpeXmlReflectanceCLUT::ParseXml(), CIccMpeAcs::Read(), CIccMpeCurveSet::Read(), CIccMpeTintArray::Read(), CIccMpeToneMap::Read(), CIccMpeMatrix::Read(), CIccMpeCLUT::Read(), CIccMpeExtCLUT::Read(), CIccMpeCAM::Read(), CIccMpeSpectralCLUT::Read(), CIccMpeCLUT::SetCLUT(), CIccMpeCurveSet::SetCurve(), CIccMpeSpectralCLUT::SetData(), CIccMpeCalculator::SetSize(), CIccMpeMatrix::SetSize(), CIccMpeSpectralMatrix::SetSize(), CIccMpeSpectralObserver::SetSize(), CIccMpeCurveSet::SetSize(), CIccMpeCurveSet::Validate(), CIccMpeTintArray::Validate(), CIccMpeToneMap::Validate(), CIccMpeCAM::Validate(), CIccMpeInvEmissionMatrix::Validate(), CIccMpeAcs::Write(), CIccMpeCurveSet::Write(), CIccMpeTintArray::Write(), CIccMpeToneMap::Write(), CIccMpeMatrix::Write(), CIccMpeCLUT::Write(), CIccMpeExtCLUT::Write(), CIccMpeCAM::Write(), CIccMpeCalculator::Write(), CIccMpeSpectralMatrix::Write(), CIccMpeSpectralCLUT::Write(), and CIccMpeSpectralObserver::Write().

m_nNextMpe

int CIccMpeXmlCalculator::m_nNextMpe

protected

Referenced by clean(), Flatten(), and ParseImport().

m_nNextVar

int CIccMpeXmlCalculator::m_nNextVar

protected

Referenced by clean(), Flatten(), and ParseXml().

m_nOutputChannels

icUInt16Number CIccMultiProcessElement::m_nOutputChannels

protectedinherited

Referenced by CIccMpeBAcs::CIccMpeBAcs(), CIccMpeBAcs::CIccMpeBAcs(), CIccMpeCalculator::CIccMpeCalculator(), CIccMpeCalculator::CIccMpeCalculator(), CIccMpeCAM::CIccMpeCAM(), CIccMpeCLUT::CIccMpeCLUT(), CIccMpeCLUT::CIccMpeCLUT(), CIccMpeCurveSet::CIccMpeCurveSet(), CIccMpeCurveSet::CIccMpeCurveSet(), CIccMpeEAcs::CIccMpeEAcs(), CIccMpeEAcs::CIccMpeEAcs(), CIccMpeExtCLUT::CIccMpeExtCLUT(), CIccMpeMatrix::CIccMpeMatrix(), CIccMpeMatrix::CIccMpeMatrix(), CIccMpeSpectralCLUT::CIccMpeSpectralCLUT(), CIccMpeSpectralCLUT::CIccMpeSpectralCLUT(), CIccMpeSpectralMatrix::CIccMpeSpectralMatrix(), CIccMpeSpectralMatrix::CIccMpeSpectralMatrix(), CIccMpeSpectralObserver::CIccMpeSpectralObserver(), CIccMpeSpectralObserver::CIccMpeSpectralObserver(), CIccMpeTintArray::CIccMpeTintArray(), CIccMpeTintArray::CIccMpeTintArray(), CIccMpeToneMap::CIccMpeToneMap(), CIccMpeToneMap::CIccMpeToneMap(), CIccMultiProcessElement::CIccMultiProcessElement(), CIccMpeTintArray::Apply(), CIccMpeToneMap::Apply(), CIccMpeMatrix::Apply(), CIccMpeAcs::Begin(), CIccMpeTintArray::Begin(), CIccMpeToneMap::Begin(), CIccMpeMatrix::Begin(), CIccMpeEmissionMatrix::Begin(), CIccMpeInvEmissionMatrix::Begin(), CIccMpeEmissionCLUT::Begin(), CIccMpeReflectanceCLUT::Begin(), CIccMpeEmissionObserver::Begin(), CIccMpeReflectanceObserver::Begin(), CIccMpeToneMap::ClearToneFuncs(), CIccMpeSpectralCLUT::copyData(), CIccMpeSpectralMatrix::copyData(), CIccMpeSpectralObserver::copyData(), CIccMpeToneMap::CopyToneFuncs(), CIccMpeMatrix::Describe(), CIccMpeCalculator::Describe(), CIccMpeSpectralMatrix::Describe(), CIccMpeSpectralObserver::Describe(), CIccMpeTintArray::Describe(), CIccMpeToneMap::Describe(), Flatten(), CIccMpeToneMap::Insert(), CIccMultiProcessElement::NumOutputChannels(), CIccMpeInvEmissionMatrix::numVectors(), CIccMpeBAcs::operator=(), CIccMpeCalculator::operator=(), CIccMpeCLUT::operator=(), CIccMpeCurveSet::operator=(), CIccMpeEAcs::operator=(), CIccMpeMatrix::operator=(), CIccMpeTintArray::operator=(), CIccMpeToneMap::operator=(), CIccMpeXmlTintArray::ParseXml(), CIccMpeXmlToneMap::ParseXml(), CIccMpeXmlMatrix::ParseXml(), CIccMpeXmlCLUT::ParseXml(), CIccMpeXmlExtCLUT::ParseXml(), CIccMpeXmlBAcs::ParseXml(), CIccMpeXmlEAcs::ParseXml(), CIccMpeXmlJabToXYZ::ParseXml(), CIccMpeXmlXYZToJab::ParseXml(), ParseXml(), CIccMpeXmlEmissionCLUT::ParseXml(), CIccMpeXmlReflectanceCLUT::ParseXml(), CIccMpeAcs::Read(), CIccMpeTintArray::Read(), CIccMpeToneMap::Read(), CIccMpeMatrix::Read(), CIccMpeCLUT::Read(), CIccMpeExtCLUT::Read(), CIccMpeCAM::Read(), CIccMpeSpectralCLUT::Read(), CIccMpeCLUT::SetCLUT(), CIccMpeSpectralCLUT::SetData(), CIccMpeToneMap::SetNumOutputChannels(), CIccMpeCalculator::SetSize(), CIccMpeMatrix::SetSize(), CIccMpeSpectralMatrix::SetSize(), CIccMpeSpectralObserver::SetSize(), CIccMpeCurveSet::SetSize(), CIccMpeTintArray::SetVectorSize(), CIccMpeTintArray::Validate(), CIccMpeToneMap::Validate(), CIccMpeCAM::Validate(), CIccMpeSpectralMatrix::Validate(), CIccMpeSpectralObserver::Validate(), CIccMpeAcs::Write(), CIccMpeTintArray::Write(), CIccMpeToneMap::Write(), CIccMpeMatrix::Write(), CIccMpeCLUT::Write(), CIccMpeExtCLUT::Write(), CIccMpeCAM::Write(), CIccMpeCalculator::Write(), CIccMpeSpectralMatrix::Write(), CIccMpeSpectralCLUT::Write(), and CIccMpeSpectralObserver::Write().

m_nReserved

icUInt32Number CIccMultiProcessElement::m_nReserved

inherited

Referenced by CIccMpeAcs::CIccMpeAcs(), CIccMpeBAcs::CIccMpeBAcs(), CIccMpeCalculator::CIccMpeCalculator(), CIccMpeCalculator::CIccMpeCalculator(), CIccMpeCAM::CIccMpeCAM(), CIccMpeCLUT::CIccMpeCLUT(), CIccMpeCLUT::CIccMpeCLUT(), CIccMpeCurveSet::CIccMpeCurveSet(), CIccMpeCurveSet::CIccMpeCurveSet(), CIccMpeEAcs::CIccMpeEAcs(), CIccMpeExtCLUT::CIccMpeExtCLUT(), CIccMpeMatrix::CIccMpeMatrix(), CIccMpeMatrix::CIccMpeMatrix(), CIccMpeSpectralCLUT::CIccMpeSpectralCLUT(), CIccMpeSpectralCLUT::CIccMpeSpectralCLUT(), CIccMpeSpectralMatrix::CIccMpeSpectralMatrix(), CIccMpeSpectralMatrix::CIccMpeSpectralMatrix(), CIccMpeSpectralObserver::CIccMpeSpectralObserver(), CIccMpeSpectralObserver::CIccMpeSpectralObserver(), CIccMpeTintArray::CIccMpeTintArray(), CIccMpeTintArray::CIccMpeTintArray(), CIccMpeToneMap::CIccMpeToneMap(), CIccMpeToneMap::CIccMpeToneMap(), CIccMultiProcessElement::CIccMultiProcessElement(), CIccMpeSpectralCLUT::copyData(), CIccMpeSpectralMatrix::copyData(), CIccMpeSpectralObserver::copyData(), CIccMpeBAcs::operator=(), CIccMpeCalculator::operator=(), CIccMpeCLUT::operator=(), CIccMpeCurveSet::operator=(), CIccMpeEAcs::operator=(), CIccMpeMatrix::operator=(), CIccMpeTintArray::operator=(), CIccMpeToneMap::operator=(), CIccTagXmlMultiProcessElement::ParseElement(), ParseImport(), CIccMpeAcs::Read(), CIccMpeCurveSet::Read(), CIccMpeTintArray::Read(), CIccMpeToneMap::Read(), CIccMpeMatrix::Read(), CIccMpeCLUT::Read(), CIccMpeExtCLUT::Read(), CIccMpeCAM::Read(), CIccMpeCalculator::Read(), CIccMpeSpectralMatrix::Read(), CIccMpeSpectralCLUT::Read(), CIccMpeSpectralObserver::Read(), CIccMpeXmlCurveSet::ToXml(), CIccMpeXmlTintArray::ToXml(), CIccMpeXmlToneMap::ToXml(), CIccMpeXmlMatrix::ToXml(), CIccMpeXmlCLUT::ToXml(), CIccMpeXmlExtCLUT::ToXml(), CIccMpeXmlBAcs::ToXml(), CIccMpeXmlEAcs::ToXml(), CIccMpeXmlJabToXYZ::ToXml(), CIccMpeXmlXYZToJab::ToXml(), ToXml(), CIccMpeXmlEmissionMatrix::ToXml(), CIccMpeXmlInvEmissionMatrix::ToXml(), CIccMpeXmlEmissionCLUT::ToXml(), CIccMpeXmlReflectanceCLUT::ToXml(), CIccMpeXmlEmissionObserver::ToXml(), CIccMpeXmlReflectanceObserver::ToXml(), CIccMultiProcessElement::Validate(), CIccMpeAcs::Write(), CIccMpeCurveSet::Write(), CIccMpeTintArray::Write(), CIccMpeToneMap::Write(), CIccMpeMatrix::Write(), CIccMpeCLUT::Write(), CIccMpeExtCLUT::Write(), CIccMpeCAM::Write(), CIccMpeCalculator::Write(), CIccMpeSpectralMatrix::Write(), CIccMpeSpectralCLUT::Write(), and CIccMpeSpectralObserver::Write().

m_nSubElem

icUInt32Number CIccMpeCalculator::m_nSubElem

protectedinherited

Referenced by CIccMpeCalculator::CIccMpeCalculator(), CIccMpeCalculator::CIccMpeCalculator(), CIccMpeCalculator::Begin(), CIccMpeCalculator::Describe(), CIccMpeCalculator::GetElem(), CIccMpeCalculator::GetNewApply(), CIccMpeCalculator::IsLateBinding(), CIccMpeCalculator::IsLateBindingReflectance(), CIccMpeCalculator::operator=(), CIccMpeCalculator::SetSize(), CIccMpeCalculator::SetSubElem(), ToXml(), CIccMpeCalculator::Validate(), and CIccMpeCalculator::Write().

m_nTempChannels

icUInt32Number CIccMpeCalculator::m_nTempChannels

protectedinherited

Referenced by CIccMpeCalculator::CIccMpeCalculator(), CIccMpeCalculator::CIccMpeCalculator(), CIccMpeCalculator::Apply(), CIccMpeCalculator::Begin(), and CIccMpeCalculator::GetNewApply().

m_outputMap

ChanVarMap CIccMpeXmlCalculator::m_outputMap

protected

Referenced by Flatten(), and ParseXml().

m_pCmmEnvVarLookup

IIccCmmEnvVarLookup* CIccMpeCalculator::m_pCmmEnvVarLookup

protectedinherited

Referenced by CIccMpeCalculator::CIccMpeCalculator(), CIccMpeCalculator::CIccMpeCalculator(), CIccMpeCalculator::Begin(), CIccMpeCalculator::GetNewApply(), and CIccMpeCalculator::operator=().

m_sImport

std::string CIccMpeXmlCalculator::m_sImport

protected

Referenced by CIccMpeXmlCalculator(), clean(), and ParseImport().

m_SubElem

CIccMultiProcessElement** CIccMpeCalculator::m_SubElem

protectedinherited

Referenced by CIccMpeCalculator::CIccMpeCalculator(), CIccMpeCalculator::CIccMpeCalculator(), CIccMpeCalculator::Begin(), CIccMpeCalculator::Describe(), CIccMpeCalculator::GetElem(), CIccMpeCalculator::GetNewApply(), CIccMpeCalculator::IsLateBinding(), CIccMpeCalculator::IsLateBindingReflectance(), CIccMpeCalculator::operator=(), CIccMpeCalculator::SetSize(), CIccMpeCalculator::SetSubElem(), ToXml(), CIccMpeCalculator::Validate(), and CIccMpeCalculator::Write().

m_varMap

TempVarMap CIccMpeXmlCalculator::m_varMap

protected

Referenced by clean(), and Flatten().

---

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

• IccXML/IccLibXML/IccMpeXml.h
• IccXML/IccLibXML/IccMpeXml.cpp