CIccDefaultEncProfileConverter Class Reference

Inheritance diagram for CIccDefaultEncProfileConverter:

Collaboration diagram for CIccDefaultEncProfileConverter:

Public Member Functions
	CIccDefaultEncProfileConverter ()
virtual icStatusEncConvert	ConvertFromParams (CIccProfilePtr &newIcc, CIccTagStruct *pParams, icHeader *pHeader)

Static Public Member Functions
static IIccEncProfileConverter *	GetHandler ()
static void	SetEncProfileConverter (IIccEncProfileConverter *pConverter)

Detailed Description

Constructor & Destructor Documentation

CIccDefaultEncProfileConverter()

CIccDefaultEncProfileConverter::CIccDefaultEncProfileConverter ( )

inline

{}

Referenced by IIccEncProfileConverter::GetHandler().

Here is the caller graph for this function:

Member Function Documentation

ConvertFromParams()

icStatusEncConvert CIccDefaultEncProfileConverter::ConvertFromParams ( CIccProfilePtr &  newIcc, CIccTagStruct *  pParams, icHeader *  pHeader  )

virtual

Implements IIccEncProfileConverter.

{
  newIcc = NULL;
 
  if (!pParams || pParams->GetTagStructType() != icSigColorEncodingParamsSruct || !pHeader)
    return icEncConvertBadParams;
 
  CIccTagFloat32* pWhitePt = (CIccTagFloat32*)pParams->FindElemOfType(icSigCeptWhitePointChromaticityMbr, icSigFloat32ArrayType);
  CIccTagFloat32* pMediaWhitePt = (CIccTagFloat32*)pParams->FindElemOfType(icSigCeptMediumWhitePointChromaticityMbr, icSigFloat32ArrayType);
 
  if (!pWhitePt || pWhitePt->GetNumValues() < 2) {
    return icEncConvertBadParams;
  }
 
  if (!pMediaWhitePt)
    pMediaWhitePt = pWhitePt;
 
  if (!pMediaWhitePt || pMediaWhitePt->GetNumValues() < 2) {
    return icEncConvertBadParams;
  }
 
  CIccProfile* pIcc = new CIccProfile;
  pIcc->m_Header = *pHeader;
 
  struct tm* newtime;
  time_t long_time;
 
  time(&long_time);                /* Get time as long integer. */
  newtime = gmtime(&long_time);
 
  pIcc->m_Header.date.year = newtime->tm_year + 1900;
  pIcc->m_Header.date.month = newtime->tm_mon + 1;
  pIcc->m_Header.date.day = newtime->tm_mday;
  pIcc->m_Header.date.hours = newtime->tm_hour;
  pIcc->m_Header.date.minutes = newtime->tm_min;
  pIcc->m_Header.date.seconds = newtime->tm_sec;
 
  float XYZWhite[3];
  icYxy2XYZVector(XYZWhite, 1.0f, &(*pWhitePt)[0], 1);
  //Fill header from pParams
  pIcc->m_Header.pcs = icSigXYZPcsData;
  pIcc->m_Header.deviceClass = icSigDisplayClass;
  pIcc->m_Header.illuminant.X = icDtoF(XYZWhite[0]);
  pIcc->m_Header.illuminant.Y = icDtoF(XYZWhite[1]);
  pIcc->m_Header.illuminant.Z = icDtoF(XYZWhite[2]);
 
  //Fill Media White Point tag
  CIccTagXYZ* pXYZ = new CIccTagXYZ();
  float XYZMedia[3];
  icYxy2XYZVector(XYZMedia, 1.0f, &(*pMediaWhitePt)[0], 1);
  if (!pXYZ->SetSize(1)) {
    delete pIcc;
    return icEncConvertMemoryError;
  }
 
  (*pXYZ)[0].X = icDtoF(XYZMedia[0]);
  (*pXYZ)[0].Y = icDtoF(XYZMedia[1]);
  (*pXYZ)[0].Z = icDtoF(XYZMedia[2]);
  pIcc->AttachTag(icSigMediaWhitePointTag, pXYZ);
 
  //Create A2B tag from pParams
  CIccTagMultiProcessElement *pMpeTag = (CIccTagMultiProcessElement*)CIccTag::Create(icSigMultiProcessElementType);
  if (!pMpeTag) {
    delete pIcc;
    return icEncConvertMemoryError;
  }
 
  pMpeTag->SetChannels(3, 3);
 
  CIccMpeMatrix *pMtx;
  CIccTagFloat32 *pLumMtx = (CIccTagFloat32*)pParams->FindElemOfType(icSigCeptLumaChromaMatrixMbr, icSigFloat32ArrayType);
  icFloatNumber lumMtx[9];
  bool bHaveLumMtx = false;
  if (pLumMtx) {
    if (pLumMtx->GetSize()<9) {
      delete pMpeTag;
      delete pIcc;
      return icEncConvertBadParams;
    }
    pMtx = (CIccMpeMatrix*)CIccMultiProcessElement::Create(icSigMatrixElemType);
    if (!pMtx) {
      delete pMpeTag;
      delete pIcc;
      return icEncConvertMemoryError;
    }
    if (!pMtx->SetSize(3, 3))
      return icEncConvertMemoryError;
 
    pLumMtx->GetValues(pMtx->GetMatrix(), 0, 9);
    pLumMtx->GetValues(&lumMtx[0], 0, 9);
    pMpeTag->Attach(pMtx);
    delete pLumMtx;
    bHaveLumMtx = true;
  }
 
  CIccTagSegmentedCurve *pSegCurve = (CIccTagSegmentedCurve*)pParams->FindElemOfType(icSigCeptTransferFunctionMbr, icSigSegmentedCurveType);
  if (pSegCurve && pSegCurve->GetCurve()) {
    CIccSegmentedCurve *pCurve = pSegCurve->GetCurve();
    CIccMpeCurveSet *pCurves = (CIccMpeCurveSet*)CIccMultiProcessElement::Create(icSigCurveSetElemType);
    if (!pCurves) {
      delete pMpeTag;
      delete pIcc;
      return icEncConvertMemoryError;
    }
    pCurves->SetSize(3);
    pCurves->SetCurve(0, pCurve->NewCopy());
    pCurves->SetCurve(1, pCurve->NewCopy());
    pCurves->SetCurve(2, pCurve->NewCopy());
    pMpeTag->Attach(pCurves);
  }
  pMtx = (CIccMpeMatrix*)CIccMultiProcessElement::Create(icSigMatrixElemType);
  if (!pMtx) {
    delete pMpeTag;
    delete pIcc;
    return icEncConvertMemoryError;
  }
 
  CIccTagFloat32 *pxy;
  if (!pMtx->SetSize(3,3)) {
    delete pMtx;
    delete pMpeTag;
    delete pIcc;
    return icEncConvertMemoryError;
  }
  icFloatNumber *mtx=pMtx->GetMatrix();
  
  pxy = (CIccTagFloat32*)pParams->FindElemOfType(icSigCeptRedPrimaryXYZMbr, icSigFloat32ArrayType);
  if (!pxy || pxy->GetSize()<2) {
    delete pMpeTag;
    delete pIcc;
    return icEncConvertMemoryError;
  }
  mtx[0]=(*pxy)[0] * XYZMedia[0];
  mtx[3]=(*pxy)[1] * XYZMedia[1];
  mtx[6]=(1.0f - (*pxy)[0] - (*pxy)[1]) * XYZMedia[2];
 
  pxy = (CIccTagFloat32*)pParams->FindElemOfType(icSigCeptGreenPrimaryXYZMbr, icSigFloat32ArrayType);
  if (!pxy || pxy->GetSize()<2) {
    delete pMpeTag;
    delete pIcc;
    return icEncConvertMemoryError;
  }
  mtx[1]=(*pxy)[0] * XYZMedia[0];
  mtx[4]=(*pxy)[1] * XYZMedia[1];
  mtx[7]=(1.0f - (*pxy)[0] - (*pxy)[1]) * XYZMedia[2];
 
  pxy = (CIccTagFloat32*)pParams->FindElemOfType(icSigCeptBluePrimaryXYZMbr, icSigFloat32ArrayType);
  if (!pxy || pxy->GetSize()<2) {
    delete pMpeTag;
    delete pIcc;
    return icEncConvertMemoryError;
  }
  mtx[2]=(*pxy)[0] * XYZMedia[0];
  mtx[5]=(*pxy)[1] * XYZMedia[1];
  mtx[8]=(1.0f - (*pxy)[0] - (*pxy)[1]) * XYZMedia[2];
 
  CIccMpeMatrix *pMtx2 = (CIccMpeMatrix*)pMtx->NewCopy();
  pMpeTag->Attach(pMtx);
 
  pIcc->AttachTag(icSigAToB3Tag, pMpeTag);
 
  if (!icMatrixInvert3x3(pMtx2->GetMatrix())) {
    delete pMtx2;
    delete pIcc;
    return icEncConvertBadParams;
  }
 
  //Create B2A tag from pParams
  pMpeTag = (CIccTagMultiProcessElement*)CIccTag::Create(icSigMultiProcessElementType);
  if (!pMpeTag) {
    delete pMtx2;
    delete pIcc;
    return icEncConvertMemoryError;
  }
 
  pMpeTag->SetChannels(3, 3);
 
  pMpeTag->Attach(pMtx2);
 
  pSegCurve = (CIccTagSegmentedCurve*)pParams->FindElemOfType(icSigCeptInverseTransferFunctionMbr, icSigSegmentedCurveType);
  if (pSegCurve && pSegCurve->GetCurve()) {
    CIccSegmentedCurve *pCurve = pSegCurve->GetCurve();
    CIccMpeCurveSet *pCurves = (CIccMpeCurveSet*)CIccMultiProcessElement::Create(icSigCurveSetElemType);
    if (!pCurves || !pCurves->SetSize(3)) {
      delete pMpeTag;
      delete pIcc;
      return icEncConvertMemoryError;
    }
    pCurves->SetCurve(0, pCurve->NewCopy());
    pCurves->SetCurve(1, pCurve->NewCopy());
    pCurves->SetCurve(2, pCurve->NewCopy());
    pMpeTag->Attach(pCurves);
  }
 
  if (bHaveLumMtx) {
    if (!icMatrixInvert3x3(&lumMtx[0])) {
      delete pMpeTag;
      delete pIcc;
      return icEncConvertBadParams;
    }
 
    pMtx = (CIccMpeMatrix*)CIccMultiProcessElement::Create(icSigMatrixElemType);
    if (!pMtx) {
      delete pMpeTag;
      delete pIcc;
      return icEncConvertMemoryError;
    }
    pMpeTag->Attach(pMtx);
  }
  pIcc->AttachTag(icSigBToA3Tag, pMpeTag);
 
  //Add ProfileConnectionConditions (if needed)
  if (pIcc->m_Header.illuminant.X!=icDtoF(icD50XYZ[0]) ||
      pIcc->m_Header.illuminant.Y!=icDtoF(icD50XYZ[1]) ||
      pIcc->m_Header.illuminant.Z!=icDtoF(icD50XYZ[2])) {
 
     //Set Spectral Viewing Conditions
    CIccTagSpectralViewingConditions *pCond = (CIccTagSpectralViewingConditions*)CIccTag::Create(icSigSpectralViewingConditionsType);
    if (!pCond) {
      delete pIcc;
      return icEncConvertMemoryError;
    }
 
    icFloatNumber illXYZ[3];
    icFloatNumber Lw = pParams->GetElemNumberValue(icSigCeptWhitePointLuminanceMbr, 100);
    pCond->setIlluminant(XYZWhite);
    //pCond->m_stdIlluminant = icIlluminantCustom;
    illXYZ[0] = pCond->m_illuminantXYZ.X = Lw * XYZWhite[0];
    illXYZ[1] = pCond->m_illuminantXYZ.Y = Lw * XYZWhite[1];
    illXYZ[2] = pCond->m_illuminantXYZ.Z = Lw * XYZWhite[2];
 
    icFloatNumber La = pParams->GetElemNumberValue(icSigCeptAmbientWhitePointLuminanceMbr, Lw/5.0f);
    CIccTagFloat32 *pSurround = (CIccTagFloat32*)pParams->FindElemOfType(icSigCeptAmbientWhitePointChromaticityMbr, icSigFloat32ArrayType);
    if (pSurround && pSurround->GetSize()>=2) {
      icFloatNumber XYZSurround[3];
      icYxy2XYZVector(XYZSurround, 1, &(*pSurround)[0], 1);
      pCond->m_surroundXYZ.X = La * XYZSurround[0];
      pCond->m_surroundXYZ.Y = La * XYZSurround[1];
      pCond->m_surroundXYZ.Z = La * XYZSurround[2];
    }
    else {
      pCond->m_surroundXYZ.X = La * XYZWhite[0];
      pCond->m_surroundXYZ.Y = La * XYZWhite[1];
      pCond->m_surroundXYZ.Z = La * XYZWhite[2];
    }
 
    pIcc->AttachTag(icSigSpectralViewingConditionsTag, pCond);
 
    icFloatNumber Lsw=pParams->GetElemNumberValue(icSigCeptViewingSurroundMbr, Lw/5.0f - 0.001f);
    CIccCamConverter *pCstmConvert = new CIccCamConverter();
    if (!pCstmConvert) {
      delete pIcc;
      return icEncConvertMemoryError;
    }
    pCstmConvert->SetParameter_WhitePoint(&illXYZ[0]);
    pCstmConvert->SetParameter_La(La);
    pCstmConvert->SetParameter_Yb(Lw);
 
    icFloatNumber SWr = Lsw / Lw;
 
    if (SWr>0.2) { //Average Surround
      pCstmConvert->SetParameter_C(0.69f);
      pCstmConvert->SetParameter_Nc(1.0f);
      pCstmConvert->SetParameter_F(1.0f);
    }
    else if (SWr>0.0) { //Dim Surround
      pCstmConvert->SetParameter_C(0.59f);
      pCstmConvert->SetParameter_Nc(0.95f);
      pCstmConvert->SetParameter_F(0.9f);
    }
    else { //Dark Surround
      pCstmConvert->SetParameter_C(0.525f);
      pCstmConvert->SetParameter_Nc(0.8f);
      pCstmConvert->SetParameter_F(0.8f);
    }
 
    CIccCamConverter *pCstmConvert2 = new CIccCamConverter();
    if (!pCstmConvert2) {
      delete pCstmConvert;
      delete pIcc;
      return icEncConvertMemoryError;
    }
    *pCstmConvert2 = *pCstmConvert;
 
    //By default New CIccCamConverter objects are initialized with default PCS conditions
    CIccCamConverter *pStdConvert = new CIccCamConverter();
    if (!pStdConvert) {
      delete pCstmConvert;
      delete pCstmConvert2;
      delete pIcc;
      return icEncConvertMemoryError;
    }
    CIccCamConverter *pStdConvert2 = new CIccCamConverter();
    if (!pStdConvert2) {
      delete pCstmConvert;
      delete pCstmConvert2;
      delete pStdConvert;
      delete pIcc;
      return icEncConvertMemoryError;
    }
 
    CIccMpeCAM *pCam;
    pMpeTag = (CIccTagMultiProcessElement*)CIccTag::Create(icSigMultiProcessElementType);
    if (!pMpeTag) {
      delete pCstmConvert;
      delete pStdConvert;
      delete pCstmConvert2;
      delete pStdConvert2;
      delete pIcc;
      return icEncConvertMemoryError;
    }
    pMpeTag->SetChannels(3, 3);
 
    pCam = (CIccMpeCAM*)CIccMultiProcessElement::Create(icSigXYZToJabElemType);
    if (!pCam) {
      delete pCstmConvert;
      delete pStdConvert;
      delete pCstmConvert2;
      delete pStdConvert2;
      delete pIcc;
      return icEncConvertMemoryError;
    }
    pCam->SetCAM(pCstmConvert);
    pMpeTag->Attach(pCam);
 
    pCam = (CIccMpeCAM*)CIccMultiProcessElement::Create(icSigJabToXYZElemType);
    if (!pCam) {
      delete pStdConvert;
      delete pCstmConvert2;
      delete pStdConvert2;
      delete pIcc;
      return icEncConvertMemoryError;
    }
    pCam->SetCAM(pStdConvert);
    pMpeTag->Attach(pCam);
    pIcc->AttachTag(icSigCustomToStandardPccTag, pMpeTag);
 
    pMpeTag = (CIccTagMultiProcessElement*)CIccTag::Create(icSigMultiProcessElementType);
    if (!pMpeTag) {
      delete pCstmConvert2;
      delete pStdConvert2;
      delete pIcc;
      return icEncConvertMemoryError;
    }
    pMpeTag->SetChannels(3,3);
 
    pCam = (CIccMpeCAM*)CIccMultiProcessElement::Create(icSigXYZToJabElemType);
    if (!pCam) {
      delete pCstmConvert2;
      delete pStdConvert2;
      delete pIcc;
      return icEncConvertMemoryError;
    }
    pCam->SetCAM(pStdConvert2);
    pMpeTag->Attach(pCam);
 
    pCam = (CIccMpeCAM*)CIccMultiProcessElement::Create(icSigJabToXYZElemType);
    if (!pCam) {
      delete pCstmConvert2;
      delete pIcc;
      return icEncConvertMemoryError;
    }
    pCam->SetCAM(pCstmConvert2);
    pMpeTag->Attach(pCam);
    pIcc->AttachTag(icSigStandardToCustomPccTag, pMpeTag);
  }
 
#if 1 && defined(_DEBUG)
  SaveIccProfile("WEncConv.icc", pIcc);
#endif
 
  newIcc = pIcc;
  return icEncConvertOk;
}

References CIccCamConverter::CIccCamConverter(), CIccTagXYZ::CIccTagXYZ(), CIccTagMultiProcessElement::Attach(), CIccProfile, CIccMultiProcessElement::Create(), CIccTag::Create(), icHeader::date, icDateTimeNumber::day, icHeader::deviceClass, CIccTagStruct::FindElemOfType(), CIccTagSegmentedCurve::GetCurve(), CIccTagStruct::GetElemNumberValue(), CIccMpeMatrix::GetMatrix(), CIccTagFloatNum< T, Tsig >::GetNumValues(), CIccTagFloatNum< T, Tsig >::GetSize(), CIccTagStruct::GetTagStructType(), CIccTagFloatNum< T, Tsig >::GetValues(), icDateTimeNumber::hours, icD50XYZ, icDtoF(), icEncConvertBadParams, icEncConvertMemoryError, icEncConvertOk, icMatrixInvert3x3(), icSigAToB3Tag, icSigBToA3Tag, icSigCeptAmbientWhitePointChromaticityMbr, icSigCeptAmbientWhitePointLuminanceMbr, icSigCeptBluePrimaryXYZMbr, icSigCeptGreenPrimaryXYZMbr, icSigCeptInverseTransferFunctionMbr, icSigCeptLumaChromaMatrixMbr, icSigCeptMediumWhitePointChromaticityMbr, icSigCeptRedPrimaryXYZMbr, icSigCeptTransferFunctionMbr, icSigCeptViewingSurroundMbr, icSigCeptWhitePointChromaticityMbr, icSigCeptWhitePointLuminanceMbr, icSigColorEncodingParamsSruct, icSigCurveSetElemType, icSigCustomToStandardPccTag, icSigDisplayClass, icSigFloat32ArrayType, icSigJabToXYZElemType, icSigMatrixElemType, icSigMediaWhitePointTag, icSigMultiProcessElementType, icSigSegmentedCurveType, icSigSpectralViewingConditionsTag, icSigSpectralViewingConditionsType, icSigStandardToCustomPccTag, icSigXYZToJabElemType, icYxy2XYZVector(), icHeader::illuminant, CIccTagSpectralViewingConditions::m_illuminantXYZ, CIccTagSpectralViewingConditions::m_surroundXYZ, icDateTimeNumber::minutes, icDateTimeNumber::month, CIccSegmentedCurve::NewCopy(), CIccMpeMatrix::NewCopy(), CIccCamConverter::operator=(), CIccTagFloatNum< T, Tsig >::operator[](), CIccTagXYZ::operator[](), icHeader::pcs, icDateTimeNumber::seconds, CIccMpeCAM::SetCAM(), CIccTagMultiProcessElement::SetChannels(), CIccMpeCurveSet::SetCurve(), CIccTagSpectralViewingConditions::setIlluminant(), CIccCamConverter::SetParameter_C(), CIccCamConverter::SetParameter_F(), CIccCamConverter::SetParameter_La(), CIccCamConverter::SetParameter_Nc(), CIccCamConverter::SetParameter_WhitePoint(), CIccCamConverter::SetParameter_Yb(), CIccMpeMatrix::SetSize(), CIccTagXYZ::SetSize(), CIccMpeCurveSet::SetSize(), icXYZNumber::X, icFloatXYZNumber::X, icXYZNumber::Y, icFloatXYZNumber::Y, icDateTimeNumber::year, icXYZNumber::Z, and icFloatXYZNumber::Z.

Here is the call graph for this function:

GetHandler()

IIccEncProfileConverter * IIccEncProfileConverter::GetHandler ( )

staticinherited

{
  if (!g_pEncProfileConverter) {
    g_pEncProfileConverter = new CIccDefaultEncProfileConverter();
  }
  return g_pEncProfileConverter;
}

References CIccDefaultEncProfileConverter(), and g_pEncProfileConverter.

Referenced by icConvertEncodingProfile().

Here is the call graph for this function:

Here is the caller graph for this function:

SetEncProfileConverter()

void IIccEncProfileConverter::SetEncProfileConverter ( IIccEncProfileConverter *  pConverter )

staticinherited

{
  if (pConverter) {
    if (g_pEncProfileConverter) {
      delete g_pEncProfileConverter;
    }
    g_pEncProfileConverter = pConverter;
  }
}

References g_pEncProfileConverter.

---

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

• IccProfLib/IccEncoding.cpp