CIccFormulaCurveSegment Class Reference

#include <IccMpeBasic.h>

Inheritance diagram for CIccFormulaCurveSegment:

Collaboration diagram for CIccFormulaCurveSegment:

Public Member Functions
	CIccFormulaCurveSegment (const CIccFormulaCurveSegment &seg)
	CIccFormulaCurveSegment (icFloatNumber start, icFloatNumber end)
virtual	~CIccFormulaCurveSegment ()
virtual icFloatNumber	Apply (icFloatNumber v) const
virtual bool	Begin (CIccCurveSegment *pPrevSeg)
virtual void	Describe (std::string &sDescription, int nVerboseness)
icFloatNumber	EndPoint ()
virtual const icChar *	GetClassName () const
virtual icCurveSegSignature	GetType () const
virtual CIccCurveSegment *	NewCopy () const
CIccFormulaCurveSegment &	operator= (const CIccFormulaCurveSegment &seg)
virtual bool	Read (icUInt32Number size, CIccIO *pIO)
void	SetFunction (icUInt16Number functionType, icUInt8Number num_parameters, icFloatNumber *parameters)
icFloatNumber	StartPoint ()
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 CIccCurveSegment *	Create (icCurveSegSignature sig, icFloatNumber start, icFloatNumber end)

Protected Attributes
icFloatNumber	m_endPoint
icUInt16Number	m_nFunctionType
icUInt8Number	m_nParameters
icUInt32Number	m_nReserved
icUInt16Number	m_nReserved2
icUInt16Number	m_nShortcutType
icFloatNumber *	m_params
icFloatNumber	m_startPoint

Detailed Description

Class: CIccTagFormulaCurveSegment

Purpose: The parametric curve segment

Constructor & Destructor Documentation

CIccFormulaCurveSegment() [1/2]

CIccFormulaCurveSegment::CIccFormulaCurveSegment	(	icFloatNumber	start,
		icFloatNumber	end
	)

Name: CIccFormulaCurveSegment::CIccFormulaCurveSegment

Purpose:

Args:

Return:

{
  m_nReserved = 0;
  m_nReserved2 = 0;
  m_startPoint = start;
  m_endPoint = end;
 
  m_nFunctionType = 0;
  m_nShortcutType = 0;
  m_nParameters = 0;
  m_params = NULL;
}

References CIccCurveSegment::m_endPoint, m_nFunctionType, m_nParameters, CIccCurveSegment::m_nReserved, m_nReserved2, m_nShortcutType, m_params, and CIccCurveSegment::m_startPoint.

Referenced by CIccFormulaCurveSegmentXml::CIccFormulaCurveSegmentXml(), and CIccCurveSegment::Create().

Here is the caller graph for this function:

CIccFormulaCurveSegment() [2/2]

CIccFormulaCurveSegment::CIccFormulaCurveSegment

(

const CIccFormulaCurveSegment &

seg

)

Name: CIccFormulaCurveSegment::CIccFormulaCurveSegment

Purpose:

Args:

Return:

{
  m_nReserved = seg.m_nReserved;
  m_nReserved2 = seg.m_nReserved2;
  m_startPoint = seg.m_startPoint;
  m_endPoint = seg.m_endPoint;
 
  m_nFunctionType = seg.m_nFunctionType;
  m_nShortcutType = seg.m_nShortcutType;
  m_nParameters = seg.m_nParameters;
 
  if (seg.m_params) {
    m_params = (icFloatNumber*)malloc(m_nParameters*sizeof(icFloatNumber));
    if (m_params)
      memcpy(m_params, seg.m_params, m_nParameters*sizeof(icFloatNumber));
  }
  else
    m_params = NULL;
}

References CIccCurveSegment::m_endPoint, m_nFunctionType, m_nParameters, CIccCurveSegment::m_nReserved, m_nReserved2, m_nShortcutType, m_params, and CIccCurveSegment::m_startPoint.

Referenced by NewCopy().

Here is the caller graph for this function:

~CIccFormulaCurveSegment()

CIccFormulaCurveSegment::~CIccFormulaCurveSegment ( )

virtual

Name: CIccFormulaCurveSegment::~CIccFormulaCurveSegment

Purpose: Releases any dynamic memory associated with the curve segment.

Args: None

Return: None

{
    if (m_params) {
        free(m_params);
        m_params = nullptr;  // Defensive: avoid UAF in case of lingering references
    }
}

References m_params.

Member Function Documentation

Apply()

icFloatNumber CIccFormulaCurveSegment::Apply ( icFloatNumber  v ) const

virtual

Name: CIccFormulaCurveSegment::Apply

Purpose:

Args:

Return:

Implements CIccCurveSegment.

{
  switch (m_nFunctionType) {
  case 0x0000:
    //Y = (a * X + b) ^ g  + c        : g a b c
    switch (m_nShortcutType) {
    case 0:
    default:
      return (icFloatNumber)(pow(m_params[1] * v + m_params[2], m_params[0]) + m_params[3]);
    case 1:
      return (m_params[1] * v);
    case 2:
      return (m_params[1] * v + m_params[3]);
    case 3:
      return (m_params[1] * v + m_params[2]);
    case 4:
      return (m_params[1] * v + m_params[2] + m_params[3]);
    }
 
  case 0x0001:
    // Y = a * log (b * X^g + c) + d      : g a b c d
    return (icFloatNumber)(m_params[1] * log10(m_params[2] * pow(v, m_params[0]) + m_params[3]) + m_params[4]);
 
  case 0x0002:
    //Y = a * b^(c*X+d) + e               : a b c d e
    return (icFloatNumber)(m_params[0] * pow(m_params[1], m_params[2] * v + m_params[3]) + m_params[4]);
 
  case 0x0003:
    //Y = a * (b * X + c) ^ g  + d        : g a b c d
    return (icFloatNumber)(m_params[1] * clipPow(m_params[2] * v + m_params[3], m_params[0]) + m_params[4]);
 
  case 0x0004:
    //Y = a * ln(d * X^g - b) + c         : g a b c d
    if (m_nShortcutType != 1)
      return (icFloatNumber)(m_params[1] * log(m_params[4] * pow(v, m_params[0]) - m_params[2]) + m_params[3]);
    else
      return (icFloatNumber)(m_params[1] * log(m_params[4] * v - m_params[2]) + m_params[3]);
 
  case 0x0005:
    //Y = e * exp((d * X^g - c) / a) + b  : g a b c d e
    if (m_nShortcutType != 1)
      return (icFloatNumber)(m_params[5] * exp((m_params[4] * pow(v, m_params[0]) - m_params[3]) / m_params[1]) + m_params[2]);
    else
      return (icFloatNumber)(m_params[5] * exp((m_params[4] * v - m_params[3]) / m_params[1]) + m_params[2]);
 
  case 0x0006:
    //Y = d * (max(e * X^g - a, 0)/(b - c * X^g))^w  : w g a b c d e
    if (m_nShortcutType!=1) {
      return (icFloatNumber)(m_params[5] * pow(icMax((icFloatNumber)(m_params[6] * pow(v, m_params[1]) - m_params[2]), 0.0f) /
                                               (m_params[3] - m_params[4] * pow(v, m_params[1])), m_params[0]));
    }
    else { //m_nShortcutType == 1
      return (icFloatNumber)(m_params[5] * pow(icMax((icFloatNumber)(m_params[6] * v - m_params[2]), 0.0f) /
                                               (m_params[3] - m_params[4] * v), m_params[0]));
    }
 
  case 0x0007:
    //Y = d * ((a + b * X^g)/(1 + c * X^g)) ^ w     : w g a b c d
    if (m_nShortcutType != 1) {
      return (icFloatNumber)(m_params[5] * pow((m_params[2] + m_params[3] * pow(v, m_params[1])) /
                                               (1.0 + m_params[4] * pow(v, m_params[1])), m_params[0]));
    }
    else { //m_nShortcutType == 1
      return (icFloatNumber)(m_params[5] * pow((m_params[2] + m_params[3] * v) /
                                               (1.0 + m_params[4] * v), m_params[0]));
    }
  }
 
  //Shouldn't get here!
  return v;
}

References clipPow(), icMax(), m_nFunctionType, m_nShortcutType, and m_params.

Here is the call graph for this function:

Begin()

bool CIccFormulaCurveSegment::Begin ( CIccCurveSegment *  pPrevSeg = NULL )

virtual

Name: CIccFormulaCurveSegment::Begin

Purpose:

Args:

Return:

Implements CIccCurveSegment.

{
  switch (m_nFunctionType) {
  case 0x0000:
    if (!m_params || m_nParameters<4)
      return false;
 
    if (icIsNear(m_params[0], 1.0)) { //don't apply gamma
      if (icIsNear(m_params[2], 0.0) && icIsNear(m_params[3], 0.0))
        m_nShortcutType = 1;
      else if (icIsNear(m_params[2], 0.0))
        m_nShortcutType = 2;
      else if (icIsNear(m_params[3], 0.0))
        m_nShortcutType = 3;
      else
        m_nShortcutType = 4;
    }
    else {
      m_nShortcutType = 0;
    }
 
    return true;
 
  case 0x0001:
    if (!m_params || m_nParameters<5)
      return false;
 
    return true;
 
  case 0x0002:
  case 0x0003:
    if (!m_params || m_nParameters < 5)
      return false;
 
  case 0x0004:
    if (!m_params || m_nParameters < 5)
      return false;
 
    if (icIsNear(m_params[0], 1.0)) { //don't apply gamma
      m_nShortcutType = 1;
    }
    else {
      m_nShortcutType = 0;
    }
    return true;
 
  case 0x0005:
    if (!m_params || m_nParameters < 6)
      return false;
 
    if (icIsNear(m_params[0], 1.0)) { //don't apply gamma
      m_nShortcutType = 1;
    }
    else {
      m_nShortcutType = 0;
    }
    return true;
 
  case 0x0006:
    if (!m_params || m_nParameters < 7)
      return false;
 
    if (icIsNear(m_params[1], 1.0)) { //don't apply gamma
      m_nShortcutType = 1;
    }
    else {
      m_nShortcutType = 0;
    }
    return true;
 
  case 0x0007:
    if (!m_params || m_nParameters < 6)
      return false;
 
    if (icIsNear(m_params[1], 1.0)) { //don't apply gamma
      m_nShortcutType = 1;
    }
    else {
      m_nShortcutType = 0;
    }
    return true;
 
 
  default:
    return false;
  }
 
  return true;
}

References icIsNear(), m_nFunctionType, m_nParameters, m_nShortcutType, and m_params.

Here is the call graph for this function:

Create()

CIccCurveSegment * CIccCurveSegment::Create ( icCurveSegSignature  sig, icFloatNumber  start, icFloatNumber  end  )

staticinherited

Name: CIccCurveSegment::Create

Purpose:

Args:

Return:

{
  switch(sig) {
  case icSigFormulaCurveSeg:
    return new CIccFormulaCurveSegment(start, end);
  case icSigSampledCurveSeg:
    return new CIccSampledCurveSegment(start, end);
  default:
    return NULL;
  }
 
}

References CIccFormulaCurveSegment(), CIccSampledCurveSegment::CIccSampledCurveSegment(), icSigFormulaCurveSeg, and icSigSampledCurveSeg.

Referenced by CIccSegmentedCurve::Read().

Here is the call graph for this function:

Here is the caller graph for this function:

Describe()

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

virtual

Name: CIccFormulaCurveSegment::Describe

Purpose:

Args:

Return:

Implements CIccCurveSegment.

{
  icChar buf[256];
 
  sDescription += "Segment [";
  if (m_startPoint==icMinFloat32Number)
    sDescription += "-Infinity, ";
  else {
  sprintf(buf, "%.8f, ", m_startPoint);
  sDescription += buf;
  }
  if (m_endPoint==icMaxFloat32Number)
    sDescription += "+Infinity";
  else {
  sprintf(buf, "%.8f", m_endPoint);
  sDescription += buf;
  }
  sprintf(buf, "]\nFunctionType: %04Xh\n", m_nFunctionType);
  sDescription += buf;
 
  switch(m_nFunctionType) {
  case 0x0000:
    if (icIsNear(m_params[1], 0.0) && icIsNear(m_params[2], 0.0))
      sprintf(buf, "Y = %.8f\n\n", m_params[3]);
    else if (icIsNear(m_params[0], 1.0) && icIsNear(m_params[1], 1.0) &&
             icIsNear(m_params[2], 0.0) && icIsNear(m_params[3], 0.0))
      sprintf(buf, "Y = X\n\n");
    else if (icIsNear(m_params[0], 1.0) && icIsNear(m_params[2], 0.0))
      sprintf(buf, "Y = %.8f * X + %.8f\n\n", 
              m_params[1], m_params[3]);
    else
      sprintf(buf, "Y = (%.8f * X + %.8f)^%.4f + %.8f\n\n", 
              m_params[1], m_params[2], m_params[0], m_params[3]);
    sDescription += buf;
    return;
 
  case 0x0001:
    sprintf(buf, "Y = %.8f * log (%.8f * (X ^ %.8f)  + %.8f) + %.8f\n\n",
            m_params[1], m_params[2], m_params[0], m_params[3], m_params[4]);
    sDescription += buf;
    return;
 
  case 0x0002:
    sprintf(buf, "Y = %.8f * (%.8f ^ (%.8f * X + %.8f)) + %.8f\n\n",
            m_params[0], m_params[1], m_params[2], m_params[3], m_params[4]);
    sDescription += buf;
    return;
 
  case 0x0003:
    if (icIsNear(m_params[1],0.0) && icIsNear(m_params[2], 0.0))
      sprintf(buf, "Y = %.8f\n\n", m_params[3]);
    else if (icIsNear(m_params[0], 1.0) && icIsNear(m_params[1], 1.0) &&
             icIsNear(m_params[2], 1.0) && icIsNear(m_params[3], 0.0) &&
             icIsNear(m_params[4], 0.0))
      sprintf(buf, "Y = X\n\n");
    else if (icIsNear(m_params[0], 1.0) && icIsNear(m_params[1], 1.0) &&
             icIsNear(m_params[3], 0.0))
      sprintf(buf, "Y = %.8f * X + %.8f\n\n", 
              m_params[2], m_params[3]);
    else if (icIsNear(m_params[0], 1.0) && icIsNear(m_params[2], 1.0) &&
             icIsNear(m_params[3], 0.0))
      sprintf(buf, "Y = %.8f * X + %.8f\n\n", 
      m_params[1], m_params[3]);
    else
      sprintf(buf, "Y = %8f * (%.8f * X + %.8f)^%.4f + %.8f\n\n", 
              m_params[1], m_params[2], m_params[3], m_params[0], m_params[4]);
    sDescription += buf;
    return;
 
  case 0x0004:
    if (!icIsNear(m_params[0], 1.0))
      sprintf(buf, "Y = %.8f * ln(%.8f * X^%8.f - %.8f) + %.8f\n\n",
        m_params[1], m_params[4], m_params[0], m_params[2], m_params[3]);
    else
      sprintf(buf, "Y = %.8f * ln(%.8f * X - %.8f) + %.8f\n\n",
        m_params[1], m_params[4], m_params[2], m_params[3]);
 
    sDescription += buf;
    return;
 
  case 0x0005:
    if (!icIsNear(m_params[0], 1.0))
      sprintf(buf, "Y = %.8f * exp((%.8f * X^%.8f - %.8f) / %.8f) + %.8f\n\n",
        m_params[5], m_params[4], m_params[0], m_params[3], m_params[1], m_params[2]);
    else
      sprintf(buf, "Y = %.8f * exp((%.8f * X - %.8f) / %.8f) + %.8f\n\n",
        m_params[5], m_params[4], m_params[3], m_params[1], m_params[2]);
 
    sDescription += buf;
    return;
 
  case 0x0006:
    if (!icIsNear(m_params[1], 1.0))
      sprintf(buf, "Y = %.8f * (max[(%.8f * X^%.8f - %.8f), 0] / (%.8f - %.8f * X^%.8f))^%.8f\n\n",
        m_params[5], m_params[6], m_params[1], m_params[2], m_params[3], m_params[4], m_params[1], m_params[0]);
    else
      sprintf(buf, "Y = %.8f * (max[(%.8f * X - %.8f), 0] / (%.8f - %.8f * X))^%.8f\n\n",
        m_params[5], m_params[6], m_params[2], m_params[3], m_params[4], m_params[0]);
    sDescription += buf;
    return;
 
  case 0x0007:
    if (!icIsNear(m_params[1], 1.0))
      sprintf(buf, "Y = %.8f * ((%.8f + %.8f * X^%.8f) / (1 + %.8f * X^%.8f))^%.8f\n\n",
        m_params[5], m_params[2], m_params[3], m_params[1], m_params[4], m_params[1], m_params[0]);
    else
      sprintf(buf, "Y = %.8f * ((%.8f + %.8f * X) / (1 + %.8f * X))^%.8f\n\n",
        m_params[5], m_params[2], m_params[3], m_params[4], m_params[0]);
    sDescription += buf;
    return;
 
  default:
    int i;
    sprintf(buf, "Unknown Function with %d parameters:\n\n", m_nParameters);
    sDescription += buf;
 
    for (i=0; i<m_nParameters; i++) {
      sprintf(buf, "Param[%d] = %.8lf\n\n", i, m_params[i]);
      sDescription += buf;
    }
  }
}

References icIsNear(), CIccCurveSegment::m_endPoint, m_nFunctionType, m_nParameters, m_params, and CIccCurveSegment::m_startPoint.

Here is the call graph for this function:

EndPoint()

icFloatNumber CIccCurveSegment::EndPoint ( )

inlineinherited

{ return m_endPoint;}

References CIccCurveSegment::m_endPoint.

Referenced by CIccSegmentedCurve::Apply(), and CIccSegmentedCurve::Insert().

Here is the caller graph for this function:

GetClassName()

virtual const icChar * CIccFormulaCurveSegment::GetClassName ( ) const

inlinevirtual

Implements CIccCurveSegment.

{ return "CIccFormulaCurveSegment"; }

GetType()

virtual icCurveSegSignature CIccFormulaCurveSegment::GetType ( ) const

inlinevirtual

Implements CIccCurveSegment.

{ return icSigFormulaCurveSeg; }

References icSigFormulaCurveSeg.

Referenced by Write().

Here is the caller graph for this function:

NewCopy()

virtual CIccCurveSegment * CIccFormulaCurveSegment::NewCopy ( ) const

inlinevirtual

Implements CIccCurveSegment.

{ return new CIccFormulaCurveSegment(*this);}

References CIccFormulaCurveSegment().

Here is the call graph for this function:

operator=()

CIccFormulaCurveSegment & CIccFormulaCurveSegment::operator=

(

const CIccFormulaCurveSegment &

seg

)

Name: &CIccFormulaCurveSegment::operator=

Purpose:

Args:

Return:

{
    if (this == &seg)
        return *this;
 
    if (m_params) {
        free(m_params);
        m_params = nullptr;
    }
 
    m_nReserved = seg.m_nReserved;
    m_nReserved2 = seg.m_nReserved2;
    m_startPoint = seg.m_startPoint;
    m_endPoint = seg.m_endPoint;
    m_nFunctionType = seg.m_nFunctionType;
    m_nShortcutType = seg.m_nShortcutType;
    m_nParameters = seg.m_nParameters;
 
    if (seg.m_params && m_nParameters > 0) {
        m_params = (icFloatNumber*)malloc(m_nParameters * sizeof(icFloatNumber));
        if (m_params)
            memcpy(m_params, seg.m_params, m_nParameters * sizeof(icFloatNumber));
        else
            m_nParameters = 0;  // fallback safety
    }
    else {
        m_params = nullptr;
    }
 
    return *this;
}

References CIccCurveSegment::m_endPoint, m_nFunctionType, m_nParameters, CIccCurveSegment::m_nReserved, m_nReserved2, m_nShortcutType, m_params, and CIccCurveSegment::m_startPoint.

Read()

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

virtual

Name: CIccFormulaCurveSegment::Read

Purpose:

Args:

Return:

Implements CIccCurveSegment.

{
  icCurveSegSignature sig;
 
  icUInt32Number headerSize = sizeof(icTagTypeSignature) + 
    sizeof(icUInt32Number) + 
    sizeof(icUInt16Number) + 
    sizeof(icUInt16Number);
 
  if (headerSize > size)
    return false;
 
  if (!pIO) {
    return false;
  }
 
  if (!pIO->Read32(&sig))
    return false;
 
  if (!pIO->Read32(&m_nReserved))
    return false;
 
  if (!pIO->Read16(&m_nFunctionType))
    return false;
 
  if (!pIO->Read16(&m_nReserved2))
    return false;
 
  if (m_params) {
    free(m_params);
    m_params = NULL;
  }
 
  switch(m_nFunctionType) {
    case 0x0000:
      m_nParameters = 4;
      break;
 
    case 0x0001:
    case 0x0002:
    case 0x0003:
    case 0x0004:
      m_nParameters = 5;
      break;
 
    case 0x0005:
    case 0x0007:
      m_nParameters = 6;
      break;
 
    case 0x0006:
      m_nParameters = 7;
      break;
 
    default:
      return false;
  }
 
  if (m_nParameters) {
 
    m_params = (icFloatNumber*)malloc(m_nParameters * sizeof(icFloatNumber));
    if (!m_params)
      return false;
 
    if (pIO->ReadFloat32Float(m_params, m_nParameters)!= m_nParameters) {
      return false;
    }
  }
  else
    m_params = NULL;
 
  return true;
}

References m_nFunctionType, m_nParameters, CIccCurveSegment::m_nReserved, m_nReserved2, m_params, CIccIO::Read16(), CIccIO::Read32(), and CIccIO::ReadFloat32Float().

Here is the call graph for this function:

SetFunction()

void CIccFormulaCurveSegment::SetFunction	(	icUInt16Number	functionType,
		icUInt8Number	num_parameters,
		icFloatNumber *	parameters
	)

Name: CIccFormulaCurveSegment::SetFunction

Purpose:

Args:

Return:

{
  if (m_params)
    free(m_params);
 
  if (num_parameters) {
    m_params = (icFloatNumber*)malloc(num_parameters * sizeof(icFloatNumber));
    if (m_params)
      memcpy(m_params, parameters, num_parameters * sizeof(icFloatNumber));
  }
  else
    m_params = NULL;
 
  m_nFunctionType = functionType;
  m_nParameters = num_parameters;
}

References m_nFunctionType, m_nParameters, and m_params.

StartPoint()

icFloatNumber CIccCurveSegment::StartPoint ( )

inlineinherited

{ return m_startPoint; }

References CIccCurveSegment::m_startPoint.

Referenced by CIccSegmentedCurve::Insert(), and CIccSegmentedCurve::Write().

Here is the caller graph for this function:

Validate()

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

virtual

Name: CIccFormulaCurveSegment::Validate

Purpose:

Args:

Return:

Implements CIccCurveSegment.

{
  CIccInfo Info;
  std::string sSigPathName = Info.GetSigPathName(sigPath);
 
  icValidateStatus rv = icValidateOK;
  if (m_nReserved || m_nReserved2) {
    sReport += icMsgValidateWarning;
    sReport += sSigPathName;
    sReport += " formula curve has non zero reserved data.\n";
    rv = icMaxStatus(rv, icValidateWarning);
  }
 
  switch (m_nFunctionType) {
  case 0x0000:
    if (!m_params || m_nParameters<4) {
      sReport += icMsgValidateCriticalError;
      sReport += sSigPathName;
      sReport += " formula curve has Invalid formulaCurveSegment parameters.\n";
      rv = icMaxStatus(rv, icValidateCriticalError);
    }
    else if (m_nParameters > 4) {
      sReport += icMsgValidateWarning;
      sReport += sSigPathName;
      sReport += " formula curve has too many formulaCurveSegment parameters.\n";
      rv = icMaxStatus(rv, icValidateWarning);
    }
    break;
 
  case 0x0001:
    if (!m_params || m_nParameters<5) {
      sReport += icMsgValidateCriticalError;
      sReport += sSigPathName;
      sReport += " formula curve has Invalid formulaCurveSegment parameters.\n";
      rv = icMaxStatus(rv, icValidateCriticalError);
    }
    else if (m_nParameters > 5) {
      sReport += icMsgValidateWarning;
      sReport += sSigPathName;
      sReport += " formula curve has too many formulaCurveSegment parameters.\n";
      rv = icMaxStatus(rv, icValidateWarning);
    }
    break;
 
  case 0x0002:
    if (!m_params || m_nParameters<5) {
      sReport += icMsgValidateCriticalError;
      sReport += sSigPathName;
      sReport += " formula curve has Invalid formulaCurveSegment parameters.\n";
      rv = icMaxStatus(rv, icValidateCriticalError);
    }
    else if (m_nParameters > 5) {
      sReport += icMsgValidateWarning;
      sReport += sSigPathName;
      sReport += " formula curve has too many formulaCurveSegment parameters.\n";
      rv = icMaxStatus(rv, icValidateWarning);
    }
    break;
 
  case 0x0003:
    if (!m_params || m_nParameters<5) {
      sReport += icMsgValidateCriticalError;
      sReport += sSigPathName;
      sReport += " formula curve has Invalid formulaCurveSegment parameters.\n";
      rv = icMaxStatus(rv, icValidateCriticalError);
    }
    else if (m_nParameters > 5) {
      sReport += icMsgValidateWarning;
      sReport += sSigPathName;
      sReport += " formula curve has too many formulaCurveSegment parameters.\n";
      rv = icMaxStatus(rv, icValidateWarning);
    }
    break;
 
  case 0x0004:
    if (!m_params || m_nParameters < 5) {
      sReport += icMsgValidateCriticalError;
      sReport += sSigPathName;
      sReport += " formula curve has Invalid formulaCurveSegment parameters.\n";
      rv = icMaxStatus(rv, icValidateCriticalError);
    }
    else if (m_nParameters > 5) {
      sReport += icMsgValidateWarning;
      sReport += sSigPathName;
      sReport += " formula curve has too many formulaCurveSegment parameters.\n";
      rv = icMaxStatus(rv, icValidateWarning);
    }
    break;
 
  case 0x0005:
    if (!m_params || m_nParameters < 6) {
      sReport += icMsgValidateCriticalError;
      sReport += sSigPathName;
      sReport += " formula curve has Invalid formulaCurveSegment parameters.\n";
      rv = icMaxStatus(rv, icValidateCriticalError);
    }
    else if (m_nParameters > 6) {
      sReport += icMsgValidateWarning;
      sReport += sSigPathName;
      sReport += " formula curve has too many formulaCurveSegment parameters.\n";
      rv = icMaxStatus(rv, icValidateWarning);
    }
    break;
 
  case 0x0006:
    if (!m_params || m_nParameters < 6) {
      sReport += icMsgValidateCriticalError;
      sReport += sSigPathName;
      sReport += " formula curve has Invalid formulaCurveSegment parameters.\n";
      rv = icMaxStatus(rv, icValidateCriticalError);
    }
    else if (m_nParameters > 6) {
      sReport += icMsgValidateWarning;
      sReport += sSigPathName;
      sReport += " formula curve has too many formulaCurveSegment parameters.\n";
      rv = icMaxStatus(rv, icValidateWarning);
    }
    break;
 
  case 0x0007:
    if (!m_params || m_nParameters < 6) {
      sReport += icMsgValidateCriticalError;
      sReport += sSigPathName;
      sReport += " formula curve has Invalid formulaCurveSegment parameters.\n";
      rv = icMaxStatus(rv, icValidateCriticalError);
    }
    else if (m_nParameters > 6) {
      sReport += icMsgValidateWarning;
      sReport += sSigPathName;
      sReport += " formula curve has too many formulaCurveSegment parameters.\n";
      rv = icMaxStatus(rv, icValidateWarning);
    }
    break;
 
  default:
    {
      icChar buf[128];
      sReport += icMsgValidateCriticalError;
      sReport += sSigPathName;
      sprintf(buf, " formula curve uses unknown formulaCurveSegment function type %d\n", m_nFunctionType);
      sReport += buf;
      rv = icMaxStatus(rv, icValidateCriticalError);
    }
  }
 
  return rv;
}

References CIccInfo::GetSigPathName(), icMaxStatus(), icMsgValidateCriticalError, icMsgValidateWarning, icValidateCriticalError, icValidateOK, icValidateWarning, m_nFunctionType, m_nParameters, CIccCurveSegment::m_nReserved, m_nReserved2, and m_params.

Here is the call graph for this function:

Write()

bool CIccFormulaCurveSegment::Write ( CIccIO *  pIO )

virtual

Name: CIccFormulaCurveSegment::Write

Purpose:

Args:

Return:

Implements CIccCurveSegment.

{
  icCurveSegSignature sig = GetType();
 
  if (!pIO)
    return false;
 
  if (!pIO->Write32(&sig))
    return false;
 
  if (!pIO->Write32(&m_nReserved))
    return false;
 
  if (!pIO->Write16(&m_nFunctionType))
    return false;
 
  if (!pIO->Write16(&m_nReserved2))
    return false;
 
  switch(m_nFunctionType) {
    case 0x0000:
      if (m_nParameters!=4)
        return false;
      break;
 
    case 0x0001:
    case 0x0002:
    case 0x0003:
    case 0x0004:
      if (m_nParameters!=5)
        return false;
      break;
 
    case 0x0005:
    case 0x0007:
      if (m_nParameters != 6)
        return false;
      break;
 
    case 0x0006:
      if (m_nParameters != 7)
        return false;
      break;
  }
 
  if (m_nParameters) {
    if (pIO->WriteFloat32Float(m_params, m_nParameters)!=m_nParameters)
      return false;
  }
 
  return true;
}

References GetType(), m_nFunctionType, m_nParameters, CIccCurveSegment::m_nReserved, m_nReserved2, m_params, CIccIO::Write16(), CIccIO::Write32(), and CIccIO::WriteFloat32Float().

Here is the call graph for this function:

Field Documentation

m_endPoint

icFloatNumber CIccCurveSegment::m_endPoint

protectedinherited

Referenced by CIccFormulaCurveSegment(), CIccFormulaCurveSegment(), CIccSampledCurveSegment::CIccSampledCurveSegment(), CIccSampledCurveSegment::CIccSampledCurveSegment(), CIccSampledCurveSegment::Apply(), CIccSampledCurveSegment::Begin(), Describe(), CIccSampledCurveSegment::Describe(), CIccCurveSegment::EndPoint(), operator=(), CIccSampledCurveSegment::operator=(), CIccFormulaCurveSegmentXml::ToXml(), CIccSampledCurveSegmentXml::ToXml(), and CIccSampledCurveSegment::Validate().

m_nFunctionType

icUInt16Number CIccFormulaCurveSegment::m_nFunctionType

protected

Referenced by CIccFormulaCurveSegment(), CIccFormulaCurveSegment(), Apply(), Begin(), Describe(), operator=(), CIccFormulaCurveSegmentXml::ParseXml(), Read(), SetFunction(), CIccFormulaCurveSegmentXml::ToXml(), Validate(), and Write().

m_nParameters

icUInt8Number CIccFormulaCurveSegment::m_nParameters

protected

Referenced by CIccFormulaCurveSegment(), CIccFormulaCurveSegment(), Begin(), Describe(), operator=(), CIccFormulaCurveSegmentXml::ParseXml(), Read(), SetFunction(), CIccFormulaCurveSegmentXml::ToXml(), Validate(), and Write().

m_nReserved

icUInt32Number CIccCurveSegment::m_nReserved

protectedinherited

Referenced by CIccFormulaCurveSegment(), CIccFormulaCurveSegment(), CIccSampledCurveSegment::CIccSampledCurveSegment(), CIccSampledCurveSegment::CIccSampledCurveSegment(), operator=(), CIccSampledCurveSegment::operator=(), Read(), CIccSampledCurveSegment::Read(), CIccFormulaCurveSegmentXml::ToXml(), Validate(), CIccSampledCurveSegment::Validate(), Write(), and CIccSampledCurveSegment::Write().

m_nReserved2

icUInt16Number CIccFormulaCurveSegment::m_nReserved2

protected

Referenced by CIccFormulaCurveSegment(), CIccFormulaCurveSegment(), operator=(), CIccFormulaCurveSegmentXml::ParseXml(), Read(), CIccFormulaCurveSegmentXml::ToXml(), Validate(), and Write().

m_nShortcutType

icUInt16Number CIccFormulaCurveSegment::m_nShortcutType

protected

Referenced by CIccFormulaCurveSegment(), CIccFormulaCurveSegment(), Apply(), Begin(), and operator=().

m_params

icFloatNumber* CIccFormulaCurveSegment::m_params

protected

Referenced by CIccFormulaCurveSegment(), CIccFormulaCurveSegment(), ~CIccFormulaCurveSegment(), Apply(), Begin(), Describe(), operator=(), CIccFormulaCurveSegmentXml::ParseXml(), Read(), SetFunction(), CIccFormulaCurveSegmentXml::ToXml(), Validate(), and Write().

m_startPoint

icFloatNumber CIccCurveSegment::m_startPoint

protectedinherited

Referenced by CIccFormulaCurveSegment(), CIccFormulaCurveSegment(), CIccSampledCurveSegment::CIccSampledCurveSegment(), CIccSampledCurveSegment::CIccSampledCurveSegment(), CIccSampledCurveSegment::Apply(), CIccSampledCurveSegment::Begin(), Describe(), CIccSampledCurveSegment::Describe(), operator=(), CIccSampledCurveSegment::operator=(), CIccCurveSegment::StartPoint(), CIccFormulaCurveSegmentXml::ToXml(), CIccSampledCurveSegmentXml::ToXml(), and CIccSampledCurveSegment::Validate().

---

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

• IccProfLib/IccMpeBasic.h
• IccProfLib/IccMpeBasic.cpp