IccMpeXml.cpp File Reference

#include "IccTagXml.h"
#include "IccMpeXml.h"
#include "IccUtilXml.h"
#include "IccIoXml.h"
#include "IccCAM.h"
#include <cstring>

Include dependency graph for IccMpeXml.cpp:

Go to the source code of this file.

Data Structures
class	CIccFormulaCurveSegmentXml
class	CIccSampledCalculatorCurveXml
class	CIccSampledCurveSegmentXml
class	CIccSinglSampledeCurveXml

Functions
CIccCLUT *	icCLutFromXml (xmlNode *pNode, int nIn, int nOut, icConvertType nType, std::string &parseStr)
icFloatNumber	icGetSegPos (const char *str)
static char *	icSegPos (char *buf, icFloatNumber pos)
static bool	icXmlDumpColorAppearanceParams (std::string &xml, std::string blanks, CIccCamConverter *pCam)
static bool	icXmlParseColorAppearanceParams (xmlNode *pNode, std::string &parseStr, CIccCamConverter *pCam)
static icCurveSetCurvePtr	ParseXmlCurve (xmlNode *pNode, std::string parseStr)
static bool	ToXmlCurve (std::string &xml, std::string blanks, icCurveSetCurvePtr pCurve)

Detailed Description

File: IccMpeXml.cpp

Contains: Implementation of MultiProcessElementType Element XML conversion functionality

Version: V1

Copyright: (c) see ICC Software License

Definition in file IccMpeXml.cpp.

Function Documentation

icCLutFromXml()

CIccCLUT * icCLutFromXml ( xmlNode *  pNode, int  nIn, int  nOut, icConvertType  nType, std::string &  parseStr  )

extern

{
  CIccCLUT *pCLUT = NULL;
 
  int nPrecision = 2;
  if (nType == icConvert8Bit)
    nPrecision = 1;  
 
  icUInt8Number nInput = (icUInt8Number)nIn;
  icUInt16Number nOutput = (icUInt16Number)nOut;
 
  pCLUT = new CIccCLUT(nInput, nOutput, nPrecision);
 
  if (!pCLUT){
    parseStr += "Error in creating CLUT Table. Check values of Precision, InputChannel, or OutputChannels.\n";
    return NULL;
  }
 
  xmlNode *grid = icXmlFindNode(pNode->children, "GridPoints");
  if (grid) {
    CIccUInt8Array points;
 
    if (points.ParseArray(grid->children)) {
      if (!pCLUT->Init(points.GetBuf())) {
        parseStr += "Error in setting the size of GridPoints. Check values of GridPoints, InputChannel, or OutputChannels.\n";
        delete pCLUT;
        return NULL;
      }
    }
    else {
      parseStr += "Error parsing GridPoints.\n";
      delete pCLUT;
      return NULL;
    }
  }
  else {
    icUInt8Number nGridGranularity;
 
    xmlAttr *gridGranularity = icXmlFindAttr(pNode, "GridGranularity");
 
    if (gridGranularity) {
      nGridGranularity = (icUInt8Number)atoi(icXmlAttrValue(gridGranularity));
    }
    else {
      delete pCLUT;
      return NULL;
    }
    if (!pCLUT->Init(nGridGranularity)) {
      parseStr += "Error in setting the size of GridGranularity. Check values of GridGranularity, InputChannel, or OutputChannels.\n";
      delete pCLUT;
      return NULL;
    }
  }
 
  xmlNode *table = icXmlFindNode(pNode->children, "TableData");
 
  if (table) {
    if (nType == icConvertVariable) {
      const char *precision = icXmlAttrValue(table, "Precision");
      if (precision && atoi(precision) == 1) {
        nType = icConvert8Bit;
        pCLUT->SetPrecision(1);
      }
      else {
        nType = icConvert16Bit;
        pCLUT->SetPrecision(2);
      }
    }
 
    const char *filename = icXmlAttrValue(table, "Filename");
    if (!filename || !filename[0]) {
      filename = icXmlAttrValue(table, "File");
    }
 
    if (filename[0]) {
      CIccIO *file = IccOpenFileIO(filename, "rb");
 
      if (!file) {
        // added error message
        parseStr += "Error! - File '";
        parseStr += filename;
        parseStr +="' not found.\n";
        delete pCLUT;
        return NULL;
      }
 
      const char *format = icXmlAttrValue(table, "Format");
 
      if (!strcmp(format, "text")) {
        icUInt32Number num = file->GetLength();
        char *buf = (char *)malloc(num);
 
        if (!buf) {  
          perror("Memory Error");
          parseStr += "'";
          parseStr += filename;
          parseStr += "' may not be a valid text file.\n";
          delete file;
          delete pCLUT;
          return NULL;
        }
 
        //Allow for different encoding in text file than implied by the table type
        const char *encoding = icXmlAttrValue(table, "FileEncoding");
 
        if (!strcmp(encoding, "int8"))
          nType = icConvert8Bit;
        else if (!strcmp(encoding, "int16"))
          nType = icConvert16Bit;
        else if (!strcmp(encoding, "float"))
          nType = icConvertFloat;
        else if (encoding[0]) {
          parseStr+= "Unknown encoding \"";
          parseStr+= encoding;
          parseStr+= "\" - using default encoding\n";
        }
 
        if (file->Read8(buf, num)!=num) { 
          perror("Read-File Error");
          parseStr += "'";
          parseStr += filename;
          parseStr += "' may not be a valid text file.\n";
          free(buf);
          delete file;
          delete pCLUT;
          return NULL;
        }
 
        if (nType == icConvert8Bit) {
          CIccUInt8Array data;
 
          if (!data.ParseTextArrayNum(buf, num, parseStr)) {
            parseStr += "File '";
            parseStr += filename;
            parseStr += "' is not a valid text file.\n";
            free(buf);
            delete file;
            delete pCLUT;
            return NULL;
          }
 
          if (data.GetSize()!=pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {     
            parseStr += "Error! - Number of entries in file '";
            parseStr += filename;
            parseStr += "'is not equal to the size of the CLUT Table.\n";  
            parseStr += "    a. Check values of GridGranularity/GridPoints, InputChannel, or OutputChannels.\n";
            parseStr += "    b. File may not be a valid text file.\n";
            free(buf);
            delete file;
            delete pCLUT;
            return NULL;
          }
          icUInt8Number *src = data.GetBuf();
          icFloatNumber *dst = pCLUT->GetData(0);
 
          icUInt32Number i;
          for (i=0; i<data.GetSize(); i++) {
            *dst++ = (icFloatNumber)(*src++) / 255.0f;
          }
        }
        else if (nType == icConvert16Bit) {
          CIccUInt16Array data;
 
          if (!data.ParseTextArrayNum(buf, num, parseStr)) {
            parseStr += "File '";
            parseStr += filename;
            parseStr += "' is not a valid text file.\n";      
            free(buf);
            delete file;
            delete pCLUT;
            return NULL;
          }
 
          if (data.GetSize()!=pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
            parseStr += "Error! - Number of entries in file '";
            parseStr += filename;
            parseStr += "'is not equal to the size of the CLUT Table.\n";  
            parseStr += "    a. Check values of GridGranularity/GridPoints, InputChannel, or OutputChannels.\n";
            parseStr += "    b. File may not be a valid text file.\n";
            free(buf);
            delete file;
            delete pCLUT;
            return NULL;
          }
          icUInt16Number *src = data.GetBuf();
          icFloatNumber *dst = pCLUT->GetData(0);
 
          icUInt32Number i;
          for (i=0; i<data.GetSize(); i++) {
            *dst++ = (icFloatNumber)(*src++) / 65535.0f;
          }
        }
        else if (nType == icConvertFloat) {
          CIccFloatArray data;
 
          if (!data.ParseTextArrayNum(buf, num, parseStr)) {
            parseStr += "File '";
            parseStr += filename;
            parseStr += "' is not a valid text file.\n";
            free(buf);
            delete file;
            delete pCLUT;
            return NULL;
          }
 
          if (data.GetSize()!=pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
            parseStr += "Error! - Number of entries in file '";
            parseStr += filename;
            parseStr += "'is not equal to the size of the CLUT Table.\n";  
            parseStr += "    a. Check values of GridGranularity/GridPoints, InputChannel, or OutputChannels.\n";
            parseStr += "    b. File may not be a valid text file.\n";
            free(buf);
            delete file;
            delete pCLUT;
            return NULL;
          }
          icFloatNumber *src = data.GetBuf();
          icFloatNumber *dst = pCLUT->GetData(0);
 
          icUInt32Number i;
          for (i=0; i<data.GetSize(); i++) {
            *dst++ = *src++;
          }
        }
        else {
          parseStr += "Error! Unknown text data type.\n";
          free(buf);
          delete file;
          delete pCLUT;
          return NULL;
        }
        free(buf);
      }
      else if (!strcmp(format, "binary")) {
        const char *order = icXmlAttrValue(table, "Endian");
        bool little_endian = !strcmp(order, "little");
 
        if (nType==icConvertVariable) {
          //Allow encoding to be defined
          const char *encoding = icXmlAttrValue(table, "FileEncoding");
 
          if (!strcmp(encoding, "int8"))
            nType = icConvert8Bit;
          else if (!strcmp(encoding, "int16"))
            nType = icConvert16Bit;
          else if (!strcmp(encoding, "float"))
            nType = icConvertFloat;
          else if (encoding[0]) {
            parseStr+= "Unknown encoding \"";
            parseStr+= encoding;
            parseStr+= "\" - using int16.\n";
            nType = icConvert16Bit;
          }
          else {
            parseStr+= "CLUT TableData Encoding type not specified.\n";
          }
        }
 
        if (nType == icConvert8Bit){
          icUInt32Number num = file->GetLength();
          icUInt8Number value;      
          // if number of entries in file is not equal to size of CLUT table, flag as error
          if (num!=pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
            parseStr += "Error! - Number of entries in file '";
            parseStr += filename;
            parseStr += "'is not equal to the size of the CLUT Table.\n";  
            parseStr += "    a. Check values of GridGranularity/GridPoints, InputChannel, or OutputChannels.\n";
            parseStr += "    b. File may not be a valid binary file.\n";
            delete file;
            delete pCLUT;
            return NULL;
          }
          icFloatNumber *dst = pCLUT->GetData(0);
          icUInt32Number i;
          for (i=0; i<num; i++) {
            if (!file->Read8(&value)) {
              perror("Read-File Error");
              parseStr += "'";
              parseStr += filename;
              parseStr += "' may not be a valid binary file.\n";
              delete file;
              delete pCLUT;
              return NULL;
            }      
            *dst++ = (icFloatNumber)value / 255.0f;
          }
        }
        else if (nType == icConvert16Bit){
          icUInt32Number num = file->GetLength() / sizeof(icUInt16Number);
          icUInt16Number value;
          icUInt8Number *ptr = (icUInt8Number*)&value;
 
          if (num<pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
            parseStr += "Error! - Number of entries in file '";
            parseStr += filename;
            parseStr += "'is not equal to the size of the CLUT Table.\n";
            parseStr += "    a. Check values of GridGranularity/GridPoints, InputChannel, or OutputChannels.\n";
            parseStr += "    b. File may not be a valid binary file.\n";
            delete file;
            delete pCLUT;
            return NULL;
          }
          icFloatNumber *dst = pCLUT->GetData(0);
 
          icUInt32Number i;
          for (i=0; i<num; i++) {
            if (!file->Read16(&value)) {  //this assumes data is big endian
              perror("Read-File Error");
              parseStr += "'";
              parseStr += filename;
              parseStr += "' may not be a valid binary file.\n";
              delete file;
              delete pCLUT;
              return NULL;
            }
#ifdef ICC_BYTE_ORDER_LITTLE_ENDIAN
            if (little_endian) {
#else
            if (!little_endian) {
#endif
              icUInt8Number t = ptr[0];
              ptr[0] = ptr[1];
              ptr[1] = t;
            }
            *dst++ = (icFloatNumber)value / 65535.0f;
          }
        }
        else if (nType == icConvertFloat){
          icUInt32Number num = file->GetLength()/sizeof(icFloat32Number);
          icFloat32Number value;
          icUInt8Number *ptr = (icUInt8Number*)&value;
 
          if (num<pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
            parseStr += "Error! - Number of entries in file '";
            parseStr += filename;
            parseStr += "'is not equal to the size of the CLUT Table.\n";  
            parseStr += "    a. Check values of GridGranularity/GridPoints, InputChannel, or OutputChannels.\n";
            parseStr += "    b. File may not be a valid binary file.\n";
            delete file;
            delete pCLUT;
            return NULL;
          }
          icFloatNumber *dst = pCLUT->GetData(0);
 
          icUInt32Number i;
          for (i=0; i<num; i++) {
            if (!file->ReadFloat32Float(&value)) {  //this assumes data is big endian
              perror("Read-File Error");
              parseStr += "'";
              parseStr += filename;
              parseStr += "' may not be a valid binary file.\n";
              delete file;
              delete pCLUT;
              return NULL;
            }
#ifdef ICC_BYTE_ORDER_LITTLE_ENDIAN
            if (little_endian) {
#else
            if (!little_endian) {
#endif
              icUInt8Number tmp;
              tmp = ptr[0]; ptr[0] = ptr[3]; ptr[3] = tmp;
              tmp = ptr[1]; ptr[1] = ptr[2]; ptr[2] = tmp;
            }
            *dst++ = value;
          }
        }
        else {
          parseStr += "Error! Unknown binary data type.\n";
          delete file;
          delete pCLUT;
          return NULL;
        }
 
      }
      else {
        parseStr += "Error! Unknown Format type.\n";
        delete pCLUT;
        return NULL;
      }
 
      delete file;
    }
    else { // no file
      if (nType == icConvert8Bit) {
        CIccUInt8Array data;
 
        if (!data.ParseArray(table->children)) {
          parseStr += "Error! - unable to parse data in CLUT.\n";
          delete pCLUT;
          return NULL;
        }
 
        if (data.GetSize()!=pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
          parseStr += "Error! - Number of entries is not equal to the size of the CLUT Table.\n";  
          delete pCLUT;
          return NULL;
        }
        icUInt8Number *src = data.GetBuf();
        icFloatNumber *dst = pCLUT->GetData(0);
 
        icUInt32Number i;
        for (i=0; i<data.GetSize(); i++) {
          *dst++ = (icFloatNumber)(*src++) / 255.0f;
        }
      }
      else if (nType == icConvert16Bit || nType==icConvertVariable) {
        CIccUInt16Array data;
 
        if (!data.ParseArray(table->children)) {
          parseStr += "Error! - unable to parse data in CLUT.\n";
          delete pCLUT;
          return NULL;
        }
 
        if (data.GetSize()!=pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
          parseStr += "Error! - Number of entries is not equal to the size of the CLUT Table.\n";  
          delete pCLUT;
          return NULL;
        }
        icUInt16Number *src = data.GetBuf();
        icFloatNumber *dst = pCLUT->GetData(0);
 
        icUInt32Number i;
        for (i=0; i<data.GetSize(); i++) {
          *dst++ = (icFloatNumber)(*src++) / 65535.0f;
        }    
      }      
      else if (nType == icConvertFloat){
        CIccFloatArray data;
 
        if (!data.ParseArray(table->children)) {
          parseStr += "Error! - unable to parse data in CLUT.\n";
          delete pCLUT;
          return NULL;
        }
 
        if (data.GetSize()!=pCLUT->NumPoints()*pCLUT->GetOutputChannels()) {
          parseStr += "Error! - Number of entries is not equal to the size of the CLUT Table.\n";  
          delete pCLUT;
          return NULL;
        }
        icFloatNumber *src = data.GetBuf();
        icFloatNumber *dst = pCLUT->GetData(0);
 
        icUInt32Number i;
        for (i=0; i<data.GetSize(); i++) {
          *dst++ = *src++;
        }
      }
      else {
        parseStr += "Error! Unknown table data type.";
        delete pCLUT;
        return NULL;
      }
    }
  }
  else {
    parseStr += "Error! Cannot find table data.";
    delete pCLUT;
    return NULL;
  }
 
  return pCLUT;
}

References CIccCLUT::CIccCLUT(), CIccXmlArrayType< T, Tsig >::GetBuf(), CIccCLUT::GetData(), CIccIO::GetLength(), CIccCLUT::GetOutputChannels(), CIccXmlArrayType< T, Tsig >::GetSize(), icConvert16Bit, icConvert8Bit, icConvertFloat, icConvertVariable, IccOpenFileIO(), icXmlAttrValue(), icXmlAttrValue(), icXmlFindAttr(), icXmlFindNode(), CIccCLUT::Init(), CIccCLUT::Init(), CIccCLUT::NumPoints(), CIccXmlArrayType< T, Tsig >::ParseArray(), CIccXmlArrayType< T, Tsig >::ParseTextArrayNum(), CIccIO::Read16(), CIccIO::Read8(), CIccIO::ReadFloat32Float(), and CIccCLUT::SetPrecision().

Referenced by icMBBFromXml(), CIccMpeXmlCLUT::ParseXml(), CIccMpeXmlExtCLUT::ParseXml(), CIccMpeXmlEmissionCLUT::ParseXml(), and CIccMpeXmlReflectanceCLUT::ParseXml().

Here is the call graph for this function:

Here is the caller graph for this function:

icGetSegPos()

icFloatNumber icGetSegPos

(

const char *

str

)

{
  if (!strncmp(str, "-inf", 4)) {
    return icMinFloat32Number;
  }
  if (!strncmp(str, "+inf", 4)) {
    return icMaxFloat32Number;
  }
 
  return (icFloatNumber)atof(str);
}

Referenced by CIccSegmentedCurveXml::ParseXml().

Here is the caller graph for this function:

icSegPos()

static char * icSegPos ( char *  buf, icFloatNumber  pos  )

static

{
  if (pos==icMinFloat32Number)
    strcpy(buf, "-infinity");
  else if (pos==icMaxFloat32Number)
    strcpy(buf, "+infinity");
  else
    sprintf(buf, "%.8" ICFLOATSFX, pos);
 
  return buf;
}

Referenced by CIccFormulaCurveSegmentXml::ToXml(), and CIccSampledCurveSegmentXml::ToXml().

Here is the caller graph for this function:

icXmlDumpColorAppearanceParams()

static bool icXmlDumpColorAppearanceParams ( std::string &  xml, std::string  blanks, CIccCamConverter *  pCam  )

static

{
  char line[256];
  icFloatNumber xyz[3];
 
  xml += blanks + "<ColorAppearanceParams>\n";
  
  pCam->GetParameter_WhitePoint(&xyz[0]);
  sprintf(line, "  <XYZNumber X=\"" icXmlFloatFmt "\" Y=\"" icXmlFloatFmt "\" Z=\"" icXmlFloatFmt "\"/>", xyz[0], xyz[1], xyz[2]);
 
  xml += blanks + " <WhitePoint>\n";
  xml += blanks + line;
  xml += blanks + " </WhitePoint>\n";
  
  sprintf(line, " <Luminance>" icXmlFloatFmt "</Luminance>\n", pCam->GetParameter_La());
  xml += blanks + line;
 
  sprintf(line, " <BackgroundLuminance>" icXmlFloatFmt "</BackgroundLuminance>\n", pCam->GetParameter_Yb());
  xml += blanks + line;
 
  sprintf(line, " <ImpactSurround>" icXmlFloatFmt "</ImpactSurround>\n", pCam->GetParameter_C());
  xml += blanks + line;
 
  sprintf(line, " <ChromaticInductionFactor>" icXmlFloatFmt "</ChromaticInductionFactor>\n", pCam->GetParameter_Nc());
  xml += blanks + line;
 
  sprintf(line, " <AdaptationFactor>" icXmlFloatFmt "</AdaptationFactor>\n", pCam->GetParameter_F());
  xml += blanks + line;
 
  xml += "</ColorAppearanceParams>\n";
 
  return true;
}

References CIccCamConverter::GetParameter_C(), CIccCamConverter::GetParameter_F(), CIccCamConverter::GetParameter_La(), CIccCamConverter::GetParameter_Nc(), CIccCamConverter::GetParameter_WhitePoint(), and CIccCamConverter::GetParameter_Yb().

Referenced by CIccMpeXmlJabToXYZ::ToXml(), and CIccMpeXmlXYZToJab::ToXml().

Here is the call graph for this function:

Here is the caller graph for this function:

icXmlParseColorAppearanceParams()

static bool icXmlParseColorAppearanceParams ( xmlNode *  pNode, std::string &  parseStr, CIccCamConverter *  pCam  )

static

{
   xmlNode *pChild = icXmlFindNode(pNode, "WhitePoint");
   if (!pChild) {
     parseStr += "Unable to find CAM Whitepoint\n";
     return false;
   }
 
   xmlNode *xyzNode = icXmlFindNode(pChild->children, "XYZNumber");
 
   if (!xyzNode) {
     parseStr += "Unable to find valid CAM WhitePoint XYZ\n";
     return false;
   }
 
   xmlAttr *x = icXmlFindAttr(xyzNode, "X");
   xmlAttr *y = icXmlFindAttr(xyzNode, "Y");
   xmlAttr *z = icXmlFindAttr(xyzNode, "Z");
 
   icFloatNumber xyz[3];
   if (x && y && z) {
     xyz[0] = (icFloatNumber)atof(icXmlAttrValue(x));
     xyz[1] = (icFloatNumber)atof(icXmlAttrValue(y));
     xyz[2] = (icFloatNumber)atof(icXmlAttrValue(z));
   }
   else {
     parseStr += "Invalid CAM WhitePoint XYZNumber\n";
     return false;
   }
   pCam->SetParameter_WhitePoint(&xyz[0]);
 
   pChild = icXmlFindNode(pNode, "Luminance");
   if (!pChild || !pChild->children || !pChild->children->content) {
     parseStr += "Invalid CAM Luminance\n";
     return false;
   }
   pCam->SetParameter_La((icFloatNumber)atof((const char*)pChild->children->content));
 
   pChild = icXmlFindNode(pNode, "BackgroundLuminance");
   if (!pChild || !pChild->children || !pChild->children->content) {
     parseStr += "Invalid CAM Luminance\n";
     return false;
   }
   pCam->SetParameter_Yb((icFloatNumber)atof((const char*)pChild->children->content));
 
   pChild = icXmlFindNode(pNode, "ImpactSurround");
   if (!pChild || !pChild->children || !pChild->children->content) {
     parseStr += "Invalid CAM ImpactSurround\n";
     return false;
   }
   pCam->SetParameter_C((icFloatNumber)atof((const char*)pChild->children->content));
 
   pChild = icXmlFindNode(pNode, "ChromaticInductionFactor");
   if (!pChild || !pChild->children || !pChild->children->content) {
     parseStr += "Invalid CAM ChromaticInductionFactor\n";
     return false;
   }
   pCam->SetParameter_Nc((icFloatNumber)atof((const char*)pChild->children->content));
 
   pChild = icXmlFindNode(pNode, "AdaptationFactor");
   if (!pChild || !pChild->children || !pChild->children->content) {
     parseStr += "Invalid CAM AdaptationFactor\n";
     return false;
   }
   pCam->SetParameter_F((icFloatNumber)atof((const char*)pChild->children->content));
 
   return true;
}

References icXmlAttrValue(), icXmlFindAttr(), icXmlFindNode(), CIccCamConverter::SetParameter_C(), CIccCamConverter::SetParameter_F(), CIccCamConverter::SetParameter_La(), CIccCamConverter::SetParameter_Nc(), CIccCamConverter::SetParameter_WhitePoint(), and CIccCamConverter::SetParameter_Yb().

Referenced by CIccMpeXmlJabToXYZ::ParseXml(), and CIccMpeXmlXYZToJab::ParseXml().

Here is the call graph for this function:

Here is the caller graph for this function:

ParseXmlCurve()

static icCurveSetCurvePtr ParseXmlCurve ( xmlNode *  pNode, std::string  parseStr  )

static

{
  icCurveSetCurvePtr rv = NULL;
  
  if (!pNode)
    return rv;
 
  if (!strcmp((const char*)pNode->name, "SegmentedCurve")) {
    CIccSegmentedCurveXml* pCurve = new CIccSegmentedCurveXml();
 
    if (pCurve->ParseXml(pNode, parseStr)) {
      rv = pCurve;
    }
    else
      delete pCurve;
  }
  else if (!strcmp((const char*)pNode->name, "SingleSampledCurve")) {
    CIccSinglSampledeCurveXml* pCurve = new CIccSinglSampledeCurveXml();
 
    if (pCurve->ParseXml(pNode, parseStr)) {
      rv = pCurve;
    }
    else
      delete pCurve;
  }
  else if (!strcmp((const char*)pNode->name, "SampledCalculatorCurve")) {
    CIccSampledCalculatorCurveXml* pCurve = new CIccSampledCalculatorCurveXml();
 
    if (pCurve->ParseXml(pNode, parseStr)) {
      rv = pCurve;
    }
    else
      delete pCurve;
  }
 
  return rv;
}

References CIccSampledCalculatorCurveXml::CIccSampledCalculatorCurveXml(), CIccSinglSampledeCurveXml::CIccSinglSampledeCurveXml(), CIccSampledCalculatorCurveXml::ParseXml(), CIccSinglSampledeCurveXml::ParseXml(), and CIccSegmentedCurveXml::ParseXml().

Referenced by CIccMpeXmlCurveSet::ParseXml(), and CIccMpeXmlToneMap::ParseXml().

Here is the call graph for this function:

Here is the caller graph for this function:

ToXmlCurve()

static bool ToXmlCurve ( std::string &  xml, std::string  blanks, icCurveSetCurvePtr  pCurve  )

static

{
  if (pCurve->GetType() == icSigSingleSampledCurve) {
    CIccSinglSampledeCurveXml* m_ptr = (CIccSinglSampledeCurveXml*)pCurve;
 
    if (!(m_ptr->ToXml(xml, blanks + "  ")))
      return false;
  }
  else if (pCurve->GetType() == icSigSegmentedCurve) {
    CIccSegmentedCurveXml* m_ptr = (CIccSegmentedCurveXml*)pCurve;
 
    if (!(m_ptr->ToXml(xml, blanks + "  ")))
      return false;
  }
  else if (pCurve->GetType() == icSigSampledCalculatorCurve) {
    CIccSampledCalculatorCurveXml* m_ptr = (CIccSampledCalculatorCurveXml*)pCurve;
 
    if (!(m_ptr->ToXml(xml, blanks + "  ")))
      return false;
  }
  else
    return false;
 
  return true;
}

References CIccCurveSetCurve::GetType(), icSigSampledCalculatorCurve, icSigSegmentedCurve, icSigSingleSampledCurve, CIccSampledCalculatorCurveXml::ToXml(), CIccSinglSampledeCurveXml::ToXml(), and CIccSegmentedCurveXml::ToXml().

Referenced by CIccMpeXmlCurveSet::ToXml(), and CIccMpeXmlToneMap::ToXml().

Here is the call graph for this function:

Here is the caller graph for this function: