CIccSinglSampledeCurveXml Class Reference

Inheritance diagram for CIccSinglSampledeCurveXml:

Collaboration diagram for CIccSinglSampledeCurveXml:

Public Member Functions
	CIccSinglSampledeCurveXml (icFloatNumber first=0, icFloatNumber last=0)
virtual icFloatNumber	Apply (icFloatNumber v) const
virtual bool	Begin (icElemInterp nInterp, CIccTagMultiProcessElement *pMPE)
virtual void	Describe (std::string &sDescription, int nVerboseness)
virtual const icChar *	GetClassName () const
icUInt16Number	GetExtensionType ()
virtual icFloatNumber *	GetSamples ()
virtual icUInt32Number	GetSize ()
icUInt16Number	GetStorageType ()
virtual icCurveElemSignature	GetType () const
virtual CIccCurveSetCurve *	NewCopy () const
bool	ParseXml (xmlNode *pNode, std::string &parseStr)
virtual bool	Read (icUInt32Number size, CIccIO *pIO)
bool	SetExtensionType (icUInt16Number nExtensionType)
void	SetRange (icFloatNumber first=0.0f, icFloatNumber last=1.0f)
virtual bool	SetSize (icUInt32Number nSize, bool bZeroAlloc=true)
bool	SetStorageType (icUInt16Number nStorateType)
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 CIccCurveSetCurve *	Create (icCurveElemSignature sig)

Protected Attributes
icUInt16Number	m_extensionType
icFloatNumber	m_firstEntry
icFloatNumber	m_hiIntercept
icFloatNumber	m_hiSlope
icFloatNumber	m_last
icFloatNumber	m_lastEntry
icFloatNumber	m_loIntercept
icFloatNumber	m_loSlope
icUInt32Number	m_nCount
icUInt32Number	m_nReserved
icFloatNumber *	m_pSamples
icFloatNumber	m_range
icUInt16Number	m_storageType

Detailed Description

Constructor & Destructor Documentation

CIccSinglSampledeCurveXml()

CIccSinglSampledeCurveXml::CIccSinglSampledeCurveXml ( icFloatNumber  first = 0, icFloatNumber  last = 0  )

inline

: CIccSingleSampledCurve(first, last) {}

References CIccSingleSampledCurve::CIccSingleSampledCurve().

Referenced by ParseXmlCurve().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

Apply()

icFloatNumber CIccSingleSampledCurve::Apply ( icFloatNumber  v ) const

virtualinherited

Name: CIccSingleSampledCurve::Apply

Purpose:

Args:

Return:

Implements CIccCurveSetCurve.

{
  if (v<m_firstEntry) {
    return m_loSlope * v + m_loIntercept;;
  }
  else if (v>m_lastEntry) {
    return m_hiSlope * v + m_hiIntercept;
  }
 
  icFloatNumber pos = (v-m_firstEntry)/m_range * m_last;
  icUInt32Number index = (icUInt32Number) pos;
  icFloatNumber remainder = pos - (icFloatNumber)index;
 
  if (remainder==0.0)
    return m_pSamples[index];
 
  return (icFloatNumber)((1.0-remainder)*m_pSamples[index] + remainder*m_pSamples[index+1]);
}

References CIccSingleSampledCurve::m_firstEntry, CIccSingleSampledCurve::m_hiIntercept, CIccSingleSampledCurve::m_hiSlope, CIccSingleSampledCurve::m_last, CIccSingleSampledCurve::m_lastEntry, CIccSingleSampledCurve::m_loIntercept, CIccSingleSampledCurve::m_loSlope, CIccSingleSampledCurve::m_pSamples, and CIccSingleSampledCurve::m_range.

Begin()

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

virtualinherited

Name: CIccSingleSampledCurve::Begin

Purpose:

Args:

Return:

Implements CIccCurveSetCurve.

{
  if (m_nCount<2)
    return false;
 
  m_range = m_lastEntry - m_firstEntry;
  m_last = (icFloatNumber)(m_nCount - 1);
  icFloatNumber stepSize = m_range / m_last;
 
  if (m_range == 0.0)
    return false;
 
  switch(m_extensionType) {
    case icClipSingleSampledCurve:
      m_loSlope=0.0;
      m_loIntercept = m_pSamples[0];
 
      m_hiSlope=0.0;
      m_hiIntercept = m_pSamples[m_nCount-1];
      break;
 
    case icExtendSingleSampledCurve:
      m_loSlope = (m_pSamples[1]-m_pSamples[0])/stepSize;
      m_loIntercept = m_pSamples[0] - m_loSlope*m_firstEntry;
 
      m_hiSlope = (m_pSamples[m_nCount-1] - m_pSamples[m_nCount-2])/stepSize;
      m_hiIntercept = m_pSamples[m_nCount-1] - m_hiSlope*m_lastEntry;
      break;
 
    default:
      return false;
  }
 
  return true;
}

References icClipSingleSampledCurve, icExtendSingleSampledCurve, CIccSingleSampledCurve::m_extensionType, CIccSingleSampledCurve::m_firstEntry, CIccSingleSampledCurve::m_hiIntercept, CIccSingleSampledCurve::m_hiSlope, CIccSingleSampledCurve::m_last, CIccSingleSampledCurve::m_lastEntry, CIccSingleSampledCurve::m_loIntercept, CIccSingleSampledCurve::m_loSlope, CIccSingleSampledCurve::m_nCount, CIccSingleSampledCurve::m_pSamples, and CIccSingleSampledCurve::m_range.

Create()

CIccCurveSetCurve * CIccCurveSetCurve::Create ( icCurveElemSignature  sig )

staticinherited

Name: CIccCurveSetCurve::Create

Purpose:

Args:

Return:

{
  switch (sig) {
  case icSigSegmentedCurve:
    return new CIccSegmentedCurve();
  case icSigSingleSampledCurve:
    return new CIccSingleSampledCurve();
  case icSigSampledCalculatorCurve:
    return new CIccSampledCalculatorCurve();
  default:
    return NULL;
  }
}

References CIccSampledCalculatorCurve::CIccSampledCalculatorCurve(), CIccSegmentedCurve::CIccSegmentedCurve(), CIccSingleSampledCurve::CIccSingleSampledCurve(), icSigSampledCalculatorCurve, icSigSegmentedCurve, and icSigSingleSampledCurve.

Referenced by CIccMpeCurveSet::Read(), and CIccMpeToneMap::Read().

Here is the call graph for this function:

Here is the caller graph for this function:

Describe()

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

virtualinherited

Name: CIccSingleSampledCurve::Describe

Purpose:

Args:

Return:

Implements CIccCurveSetCurve.

{
  icChar buf[128];
 
  if (m_nCount<2) {
    sDescription += "Empty Single Sampled Curve [";
    sprintf(buf, "%.8f, ", m_firstEntry);
    sDescription += buf;
 
    sprintf(buf, "%.8f", m_lastEntry);
    sDescription += buf;
 
    sprintf(buf, "]\n");
    sDescription += buf;
  }
  else {
    sDescription += "Single Sampled Curve [";
 
    sprintf(buf, "%.8f, ", m_firstEntry);
    sDescription += buf;
 
    sprintf(buf, "%.8f", m_lastEntry);
    sDescription += buf;
 
    sprintf(buf, "]\n");
    sDescription += buf;
 
    switch(m_storageType) {
      case icValueTypeUInt8:
        sDescription +="UInt8Number Array\n";
        break;
      case icValueTypeUInt16:
        sDescription +="UInt16Number Array\n";
        break;
      case icValueTypeFloat16:
        sDescription +="Float16Number Array\n";
        break;
      case icValueTypeFloat32:
        sDescription +="Float32Number Array\n";
        break;
      default:
        sDescription +="Unknown Data Type\n";
        break;
    }
 
    switch(m_extensionType) {
      case icClipSingleSampledCurve:
        sDescription += "Clip End Points\n";
        break;
      case icExtendSingleSampledCurve:
        sDescription += "Extend End Points\n";
        break;
      default:
        sDescription += "Unknown extension handling\n";
        break;
    }
    sDescription += "IN  OUT\n";
 
    icUInt32Number i;
 
    icFloatNumber range = m_lastEntry - m_firstEntry;
    icFloatNumber last = (icFloatNumber)(m_nCount-1);
 
    for (i=0; i<m_nCount; i++) {
      sprintf(buf, "%.8f %.8f\n", m_firstEntry + (icFloatNumber)i*range/last, m_pSamples[i]);
      sDescription += buf;
    }
  }
  sDescription += "\n";
}

References icClipSingleSampledCurve, icExtendSingleSampledCurve, icValueTypeFloat16, icValueTypeFloat32, icValueTypeUInt16, icValueTypeUInt8, CIccSingleSampledCurve::m_extensionType, CIccSingleSampledCurve::m_firstEntry, CIccSingleSampledCurve::m_lastEntry, CIccSingleSampledCurve::m_nCount, CIccSingleSampledCurve::m_pSamples, and CIccSingleSampledCurve::m_storageType.

GetClassName()

virtual const icChar * CIccSingleSampledCurve::GetClassName ( ) const

inlinevirtualinherited

Implements CIccCurveSetCurve.

{ return "CIccSingleSampledCurve"; }

GetExtensionType()

icUInt16Number CIccSingleSampledCurve::GetExtensionType ( )

inlineinherited

{ return m_extensionType; }

References CIccSingleSampledCurve::m_extensionType.

GetSamples()

virtual icFloatNumber * CIccSingleSampledCurve::GetSamples ( )

inlinevirtualinherited

{ return m_pSamples; }

References CIccSingleSampledCurve::m_pSamples.

Referenced by CDevLinkWriter::begin(), and main().

Here is the caller graph for this function:

GetSize()

virtual icUInt32Number CIccSingleSampledCurve::GetSize ( )

inlinevirtualinherited

{ return m_nCount; }

References CIccSingleSampledCurve::m_nCount.

GetStorageType()

icUInt16Number CIccSingleSampledCurve::GetStorageType ( )

inlineinherited

{ return m_storageType; }

References CIccSingleSampledCurve::m_storageType.

GetType()

virtual icCurveElemSignature CIccSingleSampledCurve::GetType ( ) const

inlinevirtualinherited

Implements CIccCurveSetCurve.

{ return icSigSingleSampledCurve; }

References icSigSingleSampledCurve.

Referenced by CIccSingleSampledCurve::Read(), and CIccSingleSampledCurve::Write().

Here is the caller graph for this function:

NewCopy()

virtual CIccCurveSetCurve * CIccSingleSampledCurve::NewCopy ( ) const

inlinevirtualinherited

Implements CIccCurveSetCurve.

{ return new CIccSingleSampledCurve(*this); }

References CIccSingleSampledCurve::CIccSingleSampledCurve().

Here is the call graph for this function:

ParseXml()

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

{
  xmlAttr *attr = icXmlFindAttr(pNode, "FirstEntry");
 
  if (!attr) {
    parseStr += "Bad FirstEntry in Simple Sampled Segment\n";
    return false;
  }
 
  m_firstEntry = (icFloatNumber)atof(icXmlAttrValue(attr));
 
  attr = icXmlFindAttr(pNode, "LastEntry");
 
  if (!attr) {
    parseStr += "Bad LastEntry in Simple Sampled Segment\n";
    return false;
  }
 
  m_lastEntry = (icFloatNumber)atof(icXmlAttrValue(attr));
 
  m_storageType = icValueTypeFloat32;
  attr = icXmlFindAttr(pNode, "StorageType");
  if (attr) {
    m_storageType = (icUInt16Number)atoi(icXmlAttrValue(attr));
  }
 
  m_extensionType = icClipSingleSampledCurve;
  attr = icXmlFindAttr(pNode, "ExtensionType");
  if (attr) {
    m_extensionType = (icUInt16Number)atoi(icXmlAttrValue(attr));
  }
 
  const char *filename = icXmlAttrValue(pNode, "Filename");
 
  // file exists
  if (filename[0]) {
    CIccIO *file = IccOpenFileIO(filename, "rb");
    if (!file) {
      parseStr += "Error! - File '";
      parseStr += filename;
      parseStr += "' not found.\n";
      delete file;
      return false;
    }
 
    const char *format = icXmlAttrValue(pNode, "Format");
 
    // format is text
    if (!strcmp(format, "text")) {
      icUInt32Number num = file->GetLength();
      char *buf = new char[num];
 
      if (!buf) {
        perror("Memory Error");
        parseStr += "'";
        parseStr += filename;
        parseStr += "' may not be a valid text file.\n";
        delete file;
        return false;
      }
 
      if (file->Read8(buf, num) != num) {
        perror("Read-File Error");
        parseStr += "'";
        parseStr += filename;
        parseStr += "' may not be a valid text file.\n";
        delete [] buf;
        delete file;
        return false;
      }
 
      // lut8type
      if (m_storageType == icValueTypeUInt8) {
        CIccUInt8Array data;
 
        //if (!data.ParseTextArray(buf)) {
        if (!data.ParseTextArrayNum(buf, num, parseStr)) {
          parseStr += "File '";
          parseStr += filename;
          parseStr += "' is not a valid text file.\n";
          SetSize(0);
          delete [] buf;
          delete file;
          return false;
        }
 
        else {
          SetSize(data.GetSize());
          icUInt8Number *src = data.GetBuf();
          icFloatNumber *dst = m_pSamples;
 
          icUInt32Number i;
          for (i = 0; i < data.GetSize(); i++) {
            *dst = (icFloatNumber)(*src) / 255.0f;
            dst++;
            src++;
          }
 
          //if (i!=256) {
          //printf("Error! - Input/Output table does not have 256 entries.\n");                            
          //SetSize(0);
          //return false;
          //}
          delete[] buf;
          delete file;
          return true;
        }
      }
 
      //lut16type
      else if (m_storageType == icValueTypeUInt16) {
        CIccUInt16Array data;
 
        //if (!data.ParseTextArray(buf)) {
        if (!data.ParseTextArrayNum(buf, num, parseStr)) {
          parseStr += "File '";
          parseStr += filename;
          parseStr += "' is not a valid text file.\n";
          SetSize(0);
          delete[] buf;
          delete file;
          return false;
        }
 
        else {
          SetSize(data.GetSize());
 
          icUInt16Number *src = data.GetBuf();
          icFloatNumber *dst = m_pSamples;
 
          icUInt32Number i;
          for (i = 0; i < data.GetSize(); i++) {
            *dst = (icFloatNumber)(*src) / 65535.0f;
            dst++;
            src++;
          }
        }
        delete[] buf;
        delete file;
        return true;
      }
 
      //float type
      else if (m_storageType == icValueTypeFloat32) {
        CIccFloatArray data;
 
        //if (!data.ParseTextArray(buf)) {
        if (!data.ParseTextArrayNum(buf, num, parseStr)) {
          parseStr += "File '";
          parseStr += filename;
          parseStr += "' is not a valid text file.\n";
          SetSize(0);
          delete[] buf;
          delete file;
          return false;
        }
 
        else {
          SetSize(data.GetSize());
          icFloatNumber *src = data.GetBuf();
          icFloatNumber *dst = m_pSamples;
 
          icUInt32Number i;
          for (i = 0; i < data.GetSize(); i++) {
            *dst = *src;
            dst++;
            src++;
          }
        }
        delete[] buf;
        delete file;
        return true;
      }
      else {
        delete[]buf;
        delete file;
        return false;
      }
    }
    // format is binary
    else if (!strcmp(format, "binary")) {
      const char *order = icXmlAttrValue(pNode, "Endian");
      bool little_endian = !strcmp(order, "little");
 
      if (m_storageType == icValueTypeUInt8) {
        icUInt32Number num = file->GetLength();
        icUInt8Number value;
 
        SetSize(num);
        icFloatNumber *dst = m_pSamples;
        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;
            return false;
          }
          *dst++ = (icFloatNumber)value / 255.0f;
        }
        delete file;
        return true;
      }
      else if (m_storageType == icValueTypeUInt16) {
        icUInt32Number num = file->GetLength() / sizeof(icUInt16Number);
        icUInt16Number value;
        icUInt8Number *m_ptr = (icUInt8Number*)&value;
 
        SetSize(num);
        icFloatNumber *dst = m_pSamples;
        icUInt32Number i;
        for (i = 0; i < num; i++) {
          if (!file->Read16(&value)) { //assumes data is big endian
            perror("Read-File Error");
            parseStr += "'";
            parseStr += filename;
            parseStr += "' may not be a valid binary file.\n";
            delete file;
            return false;
          }
#ifdef ICC_BYTE_ORDER_LITTLE_ENDIAN
          if (little_endian) {
#else
          if (!little_endian) {
#endif
            icUInt8Number t = m_ptr[0];
            m_ptr[0] = m_ptr[1];
            m_ptr[1] = t;
          }
          *dst++ = (icFloatNumber)value / 65535.0f;
          }
        delete file;
        return true;
        }
      else if (m_storageType == icValueTypeFloat16) {
        icUInt32Number num = file->GetLength() / sizeof(icFloat16Number);
        icFloat16Number value;
        icUInt8Number *m_ptr = (icUInt8Number*)&value;
 
        SetSize(num);
        icFloatNumber *dst = m_pSamples;
        icUInt32Number i;
        for (i = 0; i < num; i++) {
          if (!file->Read16(&value)) {  //assumes data is big endian
            perror("Read-File Error");
            parseStr += "'";
            parseStr += filename;
            parseStr += "' may not be a valid binary file.\n";
            delete file;
            return false;
          }
#ifdef ICC_BYTE_ORDER_LITTLE_ENDIAN
          if (little_endian) {
#else
          if (!little_endian) {
#endif
            icUInt8Number t = m_ptr[0];
            m_ptr[0] = m_ptr[1];
            m_ptr[1] = t;
          }
          *dst++ = icF16toF(value);
          }
        delete file;
        return true;
        }
      else if (m_storageType == icValueTypeFloat32) {
        icUInt32Number num = file->GetLength() / sizeof(icFloat32Number);
        icFloat32Number value;
        icUInt8Number *m_ptr = (icUInt8Number*)&value;
 
        SetSize(num);
        icFloatNumber *dst = m_pSamples;
 
        icUInt32Number i;
        for (i = 0; i < num; i++) {
          if (!file->ReadFloat32Float(&value)) {
            perror("Read-File Error");
            parseStr += "'";
            parseStr += filename;
            parseStr += "' may not be a valid binary file.\n";
            delete file;
            return false;
          }
#ifdef ICC_BYTE_ORDER_LITTLE_ENDIAN
          if (little_endian) {
#else
          if (!little_endian) {
#endif
            icUInt8Number tmp;
            tmp = m_ptr[0]; m_ptr[0] = m_ptr[3]; m_ptr[3] = tmp;
            tmp = m_ptr[1]; m_ptr[1] = m_ptr[2]; m_ptr[2] = tmp;
          }
          *dst++ = value;
          }
        delete file;
        return true;
        }
      else { //not 8bit/16bit/float        
        delete file;
        return false;
      }
      }
    else {//not text/binary
      delete file;
      return false;
    }
      }
  // no file
  else {
    CIccFloatArray samples;
 
    if (!samples.ParseArray(pNode->children)) {
      return false;
    }
 
    if (!SetSize(samples.GetSize())) {
      return false;
    }
 
    memcpy(m_pSamples, samples.GetBuf(), samples.GetSize() * sizeof(icFloatNumber));
  }
 
  return true;
      }

References CIccXmlArrayType< T, Tsig >::GetBuf(), CIccIO::GetLength(), CIccXmlArrayType< T, Tsig >::GetSize(), icClipSingleSampledCurve, IccOpenFileIO(), icF16toF(), icValueTypeFloat16, icValueTypeFloat32, icValueTypeUInt16, icValueTypeUInt8, icXmlAttrValue(), icXmlAttrValue(), icXmlFindAttr(), CIccSingleSampledCurve::m_extensionType, CIccSingleSampledCurve::m_firstEntry, CIccSingleSampledCurve::m_lastEntry, CIccSingleSampledCurve::m_pSamples, CIccSingleSampledCurve::m_storageType, CIccXmlArrayType< T, Tsig >::ParseArray(), CIccXmlArrayType< T, Tsig >::ParseTextArrayNum(), CIccIO::Read16(), CIccIO::Read8(), CIccIO::ReadFloat32Float(), and CIccSingleSampledCurve::SetSize().

Referenced by ParseXmlCurve().

Here is the call graph for this function:

Here is the caller graph for this function:

Read()

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

virtualinherited

Name: CIccSingleSampledCurve::Read

Purpose:

Args:

Return:

Implements CIccCurveSetCurve.

{
  icCurveSegSignature sig;
 
  icUInt32Number headerSize = sizeof(icTagTypeSignature) + 
    sizeof(icUInt32Number) + 
    sizeof(icUInt32Number) +
    sizeof(icFloat32Number) +
    sizeof(icFloat32Number) + 
    sizeof(icUInt16Number) + 
    sizeof(icUInt16Number);
 
  if (headerSize > size)
    return false;
 
  if (!pIO) {
    return false;
  }
 
  if (!pIO->Read32(&sig) || sig!=GetType())
    return false;
 
  if (!pIO->Read32(&m_nReserved))
    return false;
 
  if (!pIO->Read32(&m_nCount))
    return false;
 
  if (!pIO->ReadFloat32Float(&m_firstEntry))
    return false;
 
  if (!pIO->ReadFloat32Float(&m_lastEntry))
    return false;
 
  if (!pIO->Read16(&m_extensionType))
    return false;
 
  if (!pIO->Read16(&m_storageType))
    return false;
 
  if (!SetSize(m_nCount, false))
    return false;
 
  if (m_nCount > size - headerSize)
    return false;
 
  if (m_nCount) {
    switch(m_storageType) {
      case icValueTypeUInt8:
        if (m_nCount * sizeof(icUInt8Number) > size - headerSize)
          return false;
 
        if (pIO->ReadUInt8Float(m_pSamples, m_nCount)!=(icInt32Number)(m_nCount))
          return false;
        break;
      case icValueTypeUInt16:
        if (m_nCount * 2 > size - headerSize)
          return false;
 
        if (pIO->ReadUInt16Float(m_pSamples, m_nCount)!=(icInt32Number)(m_nCount))
          return false;
        break;
      case icValueTypeFloat16:
        if (m_nCount * 2 > size - headerSize)
          return false;
 
        if (pIO->ReadFloat16Float(m_pSamples, m_nCount)!=(icInt32Number)(m_nCount))
          return false;
        break;
      case icValueTypeFloat32:
        if (m_nCount * sizeof(icFloat32Number) > size - headerSize)
          return false;
 
        if (pIO->ReadFloat32Float(m_pSamples, m_nCount)!=(icInt32Number)(m_nCount))
          return false;
        break;
      default:
        return false;
    }
  }
 
  return true;
}

References CIccSingleSampledCurve::GetType(), icValueTypeFloat16, icValueTypeFloat32, icValueTypeUInt16, icValueTypeUInt8, CIccSingleSampledCurve::m_extensionType, CIccSingleSampledCurve::m_firstEntry, CIccSingleSampledCurve::m_lastEntry, CIccSingleSampledCurve::m_nCount, CIccSingleSampledCurve::m_nReserved, CIccSingleSampledCurve::m_pSamples, CIccSingleSampledCurve::m_storageType, CIccIO::Read16(), CIccIO::Read32(), CIccIO::ReadFloat16Float(), CIccIO::ReadFloat32Float(), CIccIO::ReadUInt16Float(), CIccIO::ReadUInt8Float(), and CIccSingleSampledCurve::SetSize().

Here is the call graph for this function:

SetExtensionType()

bool CIccSingleSampledCurve::SetExtensionType ( icUInt16Number  nExtensionType )

inherited

Name: CIccSingleSampledCurve::SetExtensionType

Purpose: Sets extension type of the single sampled curve

Args: nExtensionType is type of extension to use

Return: true if valid extension type, false otherwise

{
  m_extensionType = nExtensionType;
 
  switch (nExtensionType) {
    case icClipSingleSampledCurve:
    case icExtendSingleSampledCurve:
      return true;
  }
  return false;
}

References icClipSingleSampledCurve, icExtendSingleSampledCurve, and CIccSingleSampledCurve::m_extensionType.

SetRange()

void CIccSingleSampledCurve::SetRange ( icFloatNumber  first = 0.0f, icFloatNumber  last = 1.0f  )

inherited

Name: CIccSingleSampledCurve::SetRange

Purpose: Sets range of sampled lookup table.

Args: first = first entry input position last = last entry input position

{
  if (first < last) {
    m_firstEntry = first;
    m_lastEntry = last;
  }
  else {
    m_firstEntry = last;
    m_lastEntry = first;
  }
}

References CIccSingleSampledCurve::m_firstEntry, and CIccSingleSampledCurve::m_lastEntry.

SetSize()

bool CIccSingleSampledCurve::SetSize ( icUInt32Number  nCount, bool  bZeroAlloc = true  )

virtualinherited

Name: CIccSingleSampledCurve::SetSize

Purpose: Sets size of sampled lookup table. Previous data (if exists) is lost.

Args: nCount = number of elements in lut (must be >= 2).
bZeroAlloc = flag to decide if memory should be set to zero.

Return: true if allocation successful.

{
  if (!nCount) {
    if (m_pSamples)
      free(m_pSamples);
    m_pSamples = NULL;
    m_nCount = nCount;
    return true;
  }
 
  if (m_pSamples) {
    free(m_pSamples);
  }
 
  if (bZeroAlloc)
    m_pSamples = (icFloatNumber*)calloc(nCount, sizeof(icFloatNumber));
  else
    m_pSamples = (icFloatNumber*)malloc(nCount * sizeof(icFloatNumber));
 
  if (m_pSamples)
    m_nCount = nCount;
  else
    m_nCount = 0;
 
  return (m_pSamples != NULL);
}

References CIccSingleSampledCurve::m_nCount, and CIccSingleSampledCurve::m_pSamples.

Referenced by CDevLinkWriter::begin(), main(), ParseXml(), and CIccSingleSampledCurve::Read().

Here is the caller graph for this function:

SetStorageType()

bool CIccSingleSampledCurve::SetStorageType ( icUInt16Number  nStorateType )

inherited

Name: CIccSingleSampledCurve::SetStorageType

Purpose: Sets storate type of the data stored in the single sampled curve

Args: nStorageType is type of data to use

Return: true if valid storage type, false otherwise

{
  m_storageType = nStorateType;
 
  switch (nStorateType) {
    case icValueTypeUInt8:
    case icValueTypeUInt16:
    case icValueTypeFloat16:
    case icValueTypeFloat32:
      return true;
  }
  return false;
}

References icValueTypeFloat16, icValueTypeFloat32, icValueTypeUInt16, icValueTypeUInt8, and CIccSingleSampledCurve::m_storageType.

ToXml()

bool CIccSinglSampledeCurveXml::ToXml	(	std::string &	xml,
		std::string	blanks
	)

{
  char line[256];
 
  xml += blanks;
  sprintf(line, "<SingleSampledCurve FirstEntry=\"" icXmlFloatFmt "\"", m_firstEntry);
  xml += line;
 
  sprintf(line, " LastEntry=\"" icXmlFloatFmt "\"", m_lastEntry);
  xml += line;
 
  sprintf(line, " StorageType=\"%u\"", m_storageType);
  xml += line;
 
  sprintf(line, " ExtensionType=\"%u\">\n", m_extensionType);
  xml += line;
 
  CIccFloatArray::DumpArray(xml, blanks + "  ", m_pSamples, m_nCount, icConvertFloat, 8);
 
  xml += blanks + "</SingleSampledCurve>\n";
 
  return true;
}

References CIccXmlArrayType< T, Tsig >::DumpArray(), icConvertFloat, CIccSingleSampledCurve::m_extensionType, CIccSingleSampledCurve::m_firstEntry, CIccSingleSampledCurve::m_lastEntry, CIccSingleSampledCurve::m_nCount, CIccSingleSampledCurve::m_pSamples, and CIccSingleSampledCurve::m_storageType.

Referenced by ToXmlCurve().

Here is the call graph for this function:

Here is the caller graph for this function:

Validate()

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

virtualinherited

Name: CIccSingleSampledCurve::Validate

Purpose:

Args:

Return:

Implements CIccCurveSetCurve.

{
  CIccInfo Info;
  std::string sSigPathName = Info.GetSigPathName(sigPath);
 
  icValidateStatus rv = icValidateOK;
  if (m_nReserved) {
    sReport += icMsgValidateWarning;
    sReport += sSigPathName;
    sReport += " single sampled curve has non zero reserved data.\n";
    rv = icValidateWarning;
  }
 
  if (m_extensionType > icMaxSingleSampledCurveType) {
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sReport += " single sampled curve has unknown extension type\n";
    rv = icMaxStatus(rv, icValidateCriticalError);
  }
 
  if (m_storageType > icMaxValueType) {
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sReport += " single sampled curve uses unknown value type\n";
    rv = icMaxStatus(rv, icValidateCriticalError);
  }
 
  if (m_nCount<2) {
    sReport += icMsgValidateCriticalError;
    sReport += sSigPathName;
    sReport += " single sampled curve has too few sample points.\n";
    rv = icMaxStatus(rv, icValidateCriticalError);
  }
  
  if (m_lastEntry-m_firstEntry <= 0.0) {
    sReport += icMsgValidateWarning;
    sReport += sSigPathName;
    sReport += " single sampled curve has an invalid sample range.\r\n";
    rv = icMaxStatus(rv, icValidateWarning);
  }
 
  return rv;
}

References CIccInfo::GetSigPathName(), icMaxStatus(), icMsgValidateCriticalError, icMsgValidateWarning, icValidateCriticalError, icValidateOK, icValidateWarning, CIccSingleSampledCurve::m_extensionType, CIccSingleSampledCurve::m_firstEntry, CIccSingleSampledCurve::m_lastEntry, CIccSingleSampledCurve::m_nCount, CIccSingleSampledCurve::m_nReserved, and CIccSingleSampledCurve::m_storageType.

Here is the call graph for this function:

Write()

bool CIccSingleSampledCurve::Write ( CIccIO *  pIO )

virtualinherited

Name: CIccSingleSampledCurve::Write

Purpose:

Args:

Return:

Implements CIccCurveSetCurve.

{
  icCurveElemSignature sig = GetType();
 
  if (!pIO)
    return false;
 
  if (!pIO->Write32(&sig))
    return false;
 
  if (!pIO->Write32(&m_nReserved))
    return false;
 
  if (!pIO->Write32(&m_nCount))
    return false;
 
  if (!pIO->WriteFloat32Float(&m_firstEntry))
    return false;
 
  if (!pIO->WriteFloat32Float(&m_lastEntry))
    return false;
 
  if (!pIO->Write16(&m_extensionType))
    return false;
 
  if (!pIO->Write16(&m_storageType))
    return false;
 
  if (m_nCount) {
 
    switch(m_storageType) {
      case icValueTypeUInt8:
        if (pIO->WriteUInt8Float(m_pSamples, m_nCount)!=(icInt32Number)(m_nCount))
          return false;
        break;
      case icValueTypeUInt16:
        if (pIO->WriteUInt16Float(m_pSamples, m_nCount)!=(icInt32Number)(m_nCount))
          return false;
        break;
      case icValueTypeFloat16:
        if (pIO->WriteFloat16Float(m_pSamples, m_nCount)!=(icInt32Number)(m_nCount))
          return false;
        break;
      case icValueTypeFloat32:
        if (pIO->WriteFloat32Float(m_pSamples, m_nCount)!=(icInt32Number)(m_nCount))
          return false;
        break;
      default:
        return false;
    }
  }
 
  return true;
}

References CIccSingleSampledCurve::GetType(), icValueTypeFloat16, icValueTypeFloat32, icValueTypeUInt16, icValueTypeUInt8, CIccSingleSampledCurve::m_extensionType, CIccSingleSampledCurve::m_firstEntry, CIccSingleSampledCurve::m_lastEntry, CIccSingleSampledCurve::m_nCount, CIccSingleSampledCurve::m_nReserved, CIccSingleSampledCurve::m_pSamples, CIccSingleSampledCurve::m_storageType, CIccIO::Write16(), CIccIO::Write32(), CIccIO::WriteFloat16Float(), CIccIO::WriteFloat32Float(), CIccIO::WriteUInt16Float(), and CIccIO::WriteUInt8Float().

Here is the call graph for this function:

Field Documentation

m_extensionType

icUInt16Number CIccSingleSampledCurve::m_extensionType

protectedinherited

Referenced by CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::Begin(), CIccSingleSampledCurve::Describe(), CIccSingleSampledCurve::GetExtensionType(), CIccSingleSampledCurve::operator=(), ParseXml(), CIccSingleSampledCurve::Read(), CIccSingleSampledCurve::SetExtensionType(), ToXml(), CIccSingleSampledCurve::Validate(), and CIccSingleSampledCurve::Write().

m_firstEntry

icFloatNumber CIccSingleSampledCurve::m_firstEntry

protectedinherited

Referenced by CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::Apply(), CIccSingleSampledCurve::Begin(), CIccSingleSampledCurve::Describe(), CIccSingleSampledCurve::operator=(), ParseXml(), CIccSingleSampledCurve::Read(), CIccSingleSampledCurve::SetRange(), ToXml(), CIccSingleSampledCurve::Validate(), and CIccSingleSampledCurve::Write().

m_hiIntercept

icFloatNumber CIccSingleSampledCurve::m_hiIntercept

protectedinherited

Referenced by CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::Apply(), CIccSingleSampledCurve::Begin(), and CIccSingleSampledCurve::operator=().

m_hiSlope

icFloatNumber CIccSingleSampledCurve::m_hiSlope

protectedinherited

Referenced by CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::Apply(), CIccSingleSampledCurve::Begin(), and CIccSingleSampledCurve::operator=().

m_last

icFloatNumber CIccSingleSampledCurve::m_last

protectedinherited

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

m_lastEntry

icFloatNumber CIccSingleSampledCurve::m_lastEntry

protectedinherited

Referenced by CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::Apply(), CIccSingleSampledCurve::Begin(), CIccSingleSampledCurve::Describe(), CIccSingleSampledCurve::operator=(), ParseXml(), CIccSingleSampledCurve::Read(), CIccSingleSampledCurve::SetRange(), ToXml(), CIccSingleSampledCurve::Validate(), and CIccSingleSampledCurve::Write().

m_loIntercept

icFloatNumber CIccSingleSampledCurve::m_loIntercept

protectedinherited

Referenced by CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::Apply(), CIccSingleSampledCurve::Begin(), and CIccSingleSampledCurve::operator=().

m_loSlope

icFloatNumber CIccSingleSampledCurve::m_loSlope

protectedinherited

Referenced by CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::Apply(), CIccSingleSampledCurve::Begin(), and CIccSingleSampledCurve::operator=().

m_nCount

icUInt32Number CIccSingleSampledCurve::m_nCount

protectedinherited

Referenced by CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::Begin(), CIccSingleSampledCurve::Describe(), CIccSingleSampledCurve::GetSize(), CIccSingleSampledCurve::operator=(), CIccSingleSampledCurve::Read(), CIccSingleSampledCurve::SetSize(), ToXml(), CIccSingleSampledCurve::Validate(), and CIccSingleSampledCurve::Write().

m_nReserved

icUInt32Number CIccSingleSampledCurve::m_nReserved

protectedinherited

Referenced by CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::operator=(), CIccSingleSampledCurve::Read(), CIccSingleSampledCurve::Validate(), and CIccSingleSampledCurve::Write().

m_pSamples

icFloatNumber* CIccSingleSampledCurve::m_pSamples

protectedinherited

Referenced by CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::~CIccSingleSampledCurve(), CIccSingleSampledCurve::Apply(), CIccSingleSampledCurve::Begin(), CIccSingleSampledCurve::Describe(), CIccSingleSampledCurve::GetSamples(), CIccSingleSampledCurve::operator=(), ParseXml(), CIccSingleSampledCurve::Read(), CIccSingleSampledCurve::SetSize(), ToXml(), and CIccSingleSampledCurve::Write().

m_range

icFloatNumber CIccSingleSampledCurve::m_range

protectedinherited

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

m_storageType

icUInt16Number CIccSingleSampledCurve::m_storageType

protectedinherited

Referenced by CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::CIccSingleSampledCurve(), CIccSingleSampledCurve::Describe(), CIccSingleSampledCurve::GetStorageType(), CIccSingleSampledCurve::operator=(), ParseXml(), CIccSingleSampledCurve::Read(), CIccSingleSampledCurve::SetStorageType(), ToXml(), CIccSingleSampledCurve::Validate(), and CIccSingleSampledCurve::Write().

---

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

• IccXML/IccLibXML/IccMpeXml.cpp