std::string CIccStructBRDF::GetElemName(icSignature sigElem) const
{
CIccInfo info;
switch (sigElem) {
case icSigTypeBrdfMember:
return "TypeSubTag";
case icSigFunctionBrdfMember:
return "FunctionSubTag";
case icSigNumParamsBrdfMember:
return "NumParamsSubTag";
case icSigTransformBrdfMember:
return "TransformSubTag";
case icSigLightTransformBrdfMember:
return "LightTransformSubTag";
case icSigOutputTransformBrdfMember:
return "OutputTransformSubTag";
default:
break;
}
std::string str;
str = "UnknownSubTag_";
str += info.GetSigName(sigElem);
return str;
}
bool IIccStruct::Describe(std::string &sDescription) const
{
if (!m_pTagStruct) {
return false;
}
else {
char buf[256];
CIccInfo info;
sprintf(buf, "BEGIN UNKNOWN_TAG_STRUCT ");
sDescription += buf;
sDescription += info.GetStructSigName(m_pTagStruct->GetTagStructType());
sDescription += "\r\n\r\n";
TagEntryList::iterator i;
TagEntryList *pList = m_pTagStruct->GetElemList();
for (i=pList->begin(); i!=pList->end(); i++) {
i->pTag->Describe(sDescription);
}
sDescription += "\r\n";
sprintf(buf, "END TAG_STRUCT\r\n");
sDescription += buf;
sDescription += "\r\n";
}
return true;
}
bool ShowTag(CIccProfile *pIcc, icTagSignature sig)
{
CIccTag *pTag = pIcc->FindTag(sig);
icChar buf[64];
CIccInfo Fmt;
std::string contents;
if (!pTag)
return false;
printf("\n************ Tag Contents **************\n");
printf("\nContents of %s tag (%s)\n", Fmt.GetTagSigName(sig), icGetSig(buf, sig));
printf("Type: ");
if (pTag->IsArrayType()) {
printf("Array of ");
}
printf("%s\n", Fmt.GetTagTypeSigName(pTag->GetType()));
pTag->Describe(contents);
fwrite(contents.c_str(), contents.length(), 1, stdout);
printf("\n****************************************\n");
return true;
}
/**
******************************************************************************
* Name: CIccTagStruct::Validate
*
* Purpose:
*
* Args:
*
* Return:
******************************************************************************/
icValidateStatus CIccTagStruct::Validate(std::string sigPath, std::string &sReport,
const CIccProfile* pProfile /*=NULL*/) const
{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);
CIccInfo Info;
std::string sSigPathName = Info.GetSigPathName(sigPath);
// Check for duplicate tags
if (!AreElemsUnique()) {
sReport += icValidateWarning;
sReport += sSigPathName;
sReport += " - There are duplicate tags.\r\n";
rv =icMaxStatus(rv, icValidateWarning);
}
// Check Required Tags which includes exclusion tests
//rv = icMaxStatus(rv, CheckRequiredSubTags(sReport));
//rv = icMaxStatus(rv, CheckSubTagTypes(sig, sReport));
// Per Tag tests
TagEntryList::iterator i;
for (i=m_ElemEntries->begin(); i!=m_ElemEntries->end(); i++) {
rv = icMaxStatus(rv, i->pTag->Validate(sigPath + icGetSigPath(i->TagInfo.sig), sReport, pProfile));
}
return rv;
}
void ReadTag(CIccProfile *pIcc)
{
CIccInfo Fmt;
icChar buf[64];
printf("\nProfile Tags\n");
printf( "------------\n");
printf("%25s ID %8s\t%8s\n", "Tag", "Offset", "Size");
printf("%25s ------ %8s\t%8s\n", "----", "------", "----");
TagEntryList::iterator i;
for (i=pIcc->m_Tags->begin(); i!=pIcc->m_Tags->end(); i++) {
printf("%25s %s %8d\t%8d\n", Fmt.GetTagSigName(i->TagInfo.sig),
icGetSig(buf, i->TagInfo.sig, false),
i->TagInfo.offset, i->TagInfo.size);
}
printf("\nNote: The above Offset & Size parameters DO NOT reflect any unsaved changes to profile.\n");
printf("\nEnter the tag ID : ");
std::string TagID;
TagID = GetUserInput();
if(!ShowTag(pIcc, (icTagSignature)icGetSigVal(TagID.c_str())))
printf("Tag (%s) not found in profile\n", TagID.c_str());
}
std::string CIccStructUnknown::GetElemName(icSignature sigElem) const
{
CIccInfo info;
std::string str;
str = info.GetSigName(sigElem);
return str;
}
void CProfileDumpView::OnInitialUpdate()
{
CIccProfile *pIcc = GetDocument()->m_pProfile;
icHeader *pHdr = &pIcc->m_Header;
CIccInfo Fmt;
char buf[64];
int n;
m_sHdrAttributes = Fmt.GetDeviceAttrName(pHdr->attributes);
m_sHdrCmm = icGetSig(buf, pHdr->cmmId);
m_sHdrCreationDate.Format("%d/%d/%d %02u:%02u:%02u",
pHdr->date.month, pHdr->date.day, pHdr->date.year,
pHdr->date.hours, pHdr->date.minutes, pHdr->date.seconds);
m_sHdrCreator = icGetSig(buf, pHdr->creator);
m_sHdrDataColorspace = Fmt.GetColorSpaceSigName(pHdr->colorSpace);
m_sHdrFlags = Fmt.GetProfileFlagsName(pHdr->flags);
m_sHdrPcsColorSpace = Fmt.GetColorSpaceSigName(pHdr->pcs);
m_sHdrPlatform = Fmt.GetPlatformSigName(pHdr->platform);
m_sHdrRenderingIntent = Fmt.GetRenderingIntentName((icRenderingIntent)(pHdr->renderingIntent));
m_sHdrSize.Format("%d(0x%x) bytes", pHdr->size, pHdr->size);
m_sHdrType = Fmt.GetProfileClassSigName(pHdr->deviceClass);
m_sHdrVersion = Fmt.GetVersionName(pHdr->version);
m_sHdrIlluminant.Format("X=%.4lf, Y=%.4lf, Z=%.4lf",
icFtoD(pHdr->illuminant.X),
icFtoD(pHdr->illuminant.Y),
icFtoD(pHdr->illuminant.Z));
m_sHdrProfileID.Empty();
for (n=0; n<16; n++) {
sprintf(buf, "%02x", pHdr->profileID.ID8[n]);
if (n && !(n%4))
m_sHdrProfileID += " ";
m_sHdrProfileID += buf;
}
CFormView::OnInitialUpdate();
ResizeParentToFit(FALSE);
m_listTags.InsertColumn(0, "Tag ID", LVCFMT_LEFT, 200);
m_listTags.InsertColumn(1, "Offset", LVCFMT_RIGHT, 75);
m_listTags.InsertColumn(2, "Size", LVCFMT_RIGHT, 75);
int item;
TagEntryList::iterator i;
CString Text;
for (n=0, i=pIcc->m_Tags->begin(); i!=pIcc->m_Tags->end(); i++, n++) {
item = m_listTags.InsertItem(n, Fmt.GetTagSigName(i->TagInfo.sig));
Text.Format("%d", i->TagInfo.offset);
m_listTags.SetItemText(item, 1, Text);
Text.Format("%d", i->TagInfo.size);
m_listTags.SetItemText(item, 2, Text);
m_listTags.SetItemData(item, (DWORD)i->TagInfo.sig);
}
}
std::string CIccStructColorEncodingParams::GetElemName(icSignature sigElem) const
{
CIccInfo info;
switch (sigElem) {
case icBluePrimaryXYZCeptMember:
return "BluePrimaryXYZSubTag";
case icGreenPrimaryXYZCeptMember:
return "GreenPrimaryXYZSubTag";
case icRedPrimaryXYZCeptMember:
return "icRedPrimaryXYZSubTag";
case icTransferFunctionCeptMember:
return "icTransferFunctionSubTag";
case icLumaChromaMatrixCeptMember:
return "icLumaChromaMatrixSubTag";
case icWhitePointLuminanceCeptMember:
return "icWhitePointLuminanceSubTag";
case icWhitePointChromaticityCeptMember:
return "WhitePointChromaticitySubTag";
case icEncodingRangeCeptMember:
return "EncodingRangeSubTag";
case icBitDepthCeptMember:
return "BitDepthCSubTag";
case icImageStateCeptMember:
return "ImageStateSubTag";
case icImageBackgroundCeptMember:
return "ImageBackgroundSubTag";
case icViewingSurroundCeptMember:
return "ViewingSurroundSubTag";
case icAmbientIlluminanceCeptMember:
return "AmbientIlluminancembientIlluminanceSubTag";
case icAmbientWhitePointLuminanceCeptMember:
return "AmbientWhitePointLuminanceSubTag";
case icAmbientWhitePointChromaticityCeptMember:
return "AmbientWhitePointChromaticitySubTag";
case icViewingFlareCeptMember:
return "ViewingFlareSubTag";
case icValidRelativeLuminanceRangeCeptMember:
return "ValidRelativeLuminanceRangeSubTag";
case icMediumWhitePointLuminanceCeptMember:
return "MediumWhitePointLuminanceSubTag";
case icMediumWhitePointChromaticityCeptMember:
return "MediumWhitePointChromaticitySubTag";
case icMediumBlackPointLuminanceCeptMember:
return "MediumBlackPointLuminanceSubTag";
case icMediumBlackPointChromaticityCeptMember:
return "MediumBlackPointChromaticitySubTag";
default:
break;
}
std::string str;
str = "UnknownSubTag_";
str += info.GetSigName(sigElem);
return str;
}
/**
******************************************************************************
* Name: CIccTagProfileSequenceId::Validate
*
* Purpose:
*
* Args:
*
* Return:
******************************************************************************/
icValidateStatus CIccTagProfileSequenceId::Validate(std::string sigPath, std::string &sReport,
const CIccProfile* pProfile /*=NULL*/) const
{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);
CIccInfo Info;
std::string sSigName = Info.GetSigPathName(sigPath);
CIccProfileIdDescList::iterator i;
for (i=m_list->begin(); i!=m_list->end(); i++) {
rv = icMaxStatus(rv, i->Validate(sigPath+icGetSigPath(GetType()), sReport, pProfile));
}
return rv;
}
/**
******************************************************************************
* Name: CIccTagArray::Validate
*
* Purpose:
*
* Args:
*
* Return:
******************************************************************************/
icValidateStatus CIccTagArray::Validate(std::string sigPath, std::string &sReport,
const CIccProfile* pProfile /*=NULL*/) const
{
icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);
CIccInfo Info;
std::string sigAryPath = sigPath + icGetSigPath(m_sigArrayType);
if (m_pArray) { //Should call GetArrayHandler before validate to get
rv = icMaxStatus(rv, m_pArray->Validate(sigPath, sReport, pProfile));
}
else if (m_sigArrayType==icSigUtf8TextTypeArray) { //UTF8 text arrays are known
//Check # of channels
if (icGetFirstSigPathSig(sigPath) == icSigMaterialTypeArrayTag &&
pProfile &&
m_nSize != icGetMaterialColorSpaceSamples(pProfile->m_Header.mcs)) {
std::string sSigPathName = Info.GetSigPathName(sigPath);
sReport += icValidateCriticalErrorMsg;
sReport += sSigPathName;
sReport += " - Number of material channel names does not match MCS in header.\r\n";
rv = icMaxStatus(rv, icValidateCriticalError);
}
icUInt32Number i;
for (i=0; i<m_nSize; i++) {
rv = icMaxStatus(rv, m_TagVals[i].ptr->Validate(sigAryPath, sReport, pProfile));
}
}
else {
icUInt32Number i;
sReport += "Unknown tag array type - Validating array sub-tags\n";
rv = icMaxStatus(rv, icValidateWarning);
for (i=0; i<m_nSize; i++) {
rv = icMaxStatus(rv, m_TagVals[i].ptr->Validate(sigAryPath, sReport, pProfile));
}
}
return rv;
}
void DumpTag(CIccProfile *pIcc, icTagSignature sig)
{
CIccTag *pTag = pIcc->FindTag(sig);
char buf[64];
CIccInfo Fmt;
std::string contents;
if (pTag) {
printf("\nContents of %s tag (%s)\n", Fmt.GetTagSigName(sig), icGetSig(buf, sig));
printf("Type: ");
if (pTag->IsArrayType()) {
printf("Array of ");
}
printf("%s\n", Fmt.GetTagTypeSigName(pTag->GetType()));
pTag->Describe(contents);
fwrite(contents.c_str(), contents.length(), 1, stdout);
}
else {
printf("Tag (%s) not found in profile\n", icGetSig(buf, sig));
}
}
std::string CIccStructNamedColor::GetElemName(icSignature sigElem) const
{
CIccInfo info;
switch (sigElem) {
case icSigNameNamedColorMember:
return "NameSubTag";
case icSigDeviceNamedColorMember:
return "DeviceSubTag";
case icSigPcsNamedColorMember:
return "PcsSubTag";
case icSigSpectralNamedColorMember:
return "SpectralSubTag";
case icSigTintNamedColorMember:
return "TintSubTag";
default:
break;
}
std::string str;
str = "UnknownSubTag_";
str += info.GetSigName(sigElem);
return str;
}
int main(int argc, char* argv[])
{
int nArg = 1;
if (argc<=1) {
print_usage:
printf("Usage: iccDumpProfile profile {tagId to dump/\"ALL\")\n");
return -1;
}
CIccProfile *pIcc;
std::string sReport;
icValidateStatus nStatus;
if (!strncmp(argv[1], "-V", 2) || !strncmp(argv[1], "-v", 2)) {
if (argc<=2)
goto print_usage;
nArg = 2;
pIcc = ValidateIccProfile(argv[nArg], sReport, nStatus);
}
else
pIcc = OpenIccProfile(argv[nArg]);
if (!pIcc) {
printf("Unable to open '%s'\n", argv[nArg]);
}
else {
icHeader *pHdr = &pIcc->m_Header;
CIccInfo Fmt;
char buf[64];
printf("Profile: '%s'\n", argv[nArg]);
if(Fmt.IsProfileIDCalculated(&pHdr->profileID))
printf("Profile ID: %s\n", Fmt.GetProfileID(&pHdr->profileID));
else
printf("Profile ID: Profile ID not calculated.\n");
printf("Size: %d(0x%x) bytes\n", pHdr->size, pHdr->size);
printf("\nHeader\n");
printf( "------\n");
printf("Attributes: %s\n", Fmt.GetDeviceAttrName(pHdr->attributes));
printf("Cmm: %s\n", Fmt.GetCmmSigName((icCmmSignature)(pHdr->cmmId)));
printf("Creation Date: %d/%d/%d %02u:%02u:%02u\n",
pHdr->date.month, pHdr->date.day, pHdr->date.year,
pHdr->date.hours, pHdr->date.minutes, pHdr->date.seconds);
printf("Creator: %s\n", icGetSig(buf, pHdr->creator));
printf("Data Color Space: %s\n", Fmt.GetColorSpaceSigName(pHdr->colorSpace));
printf("Flags %s\n", Fmt.GetProfileFlagsName(pHdr->flags));
printf("PCS Color Space: %s\n", Fmt.GetColorSpaceSigName(pHdr->pcs));
printf("Platform: %s\n", Fmt.GetPlatformSigName(pHdr->platform));
printf("Rendering Intent: %s\n", Fmt.GetRenderingIntentName((icRenderingIntent)(pHdr->renderingIntent)));
printf("Type: %s\n", Fmt.GetProfileClassSigName(pHdr->deviceClass));
printf("Version: %s\n", Fmt.GetVersionName(pHdr->version));
printf("Illuminant: X=%.4lf, Y=%.4lf, Z=%.4lf\n",
icFtoD(pHdr->illuminant.X),
icFtoD(pHdr->illuminant.Y),
icFtoD(pHdr->illuminant.Z));
printf("\nProfile Tags\n");
printf( "------------\n");
printf("%25s ID %8s\t%8s\n", "Tag", "Offset", "Size");
printf("%25s ------ %8s\t%8s\n", "----", "------", "----");
int n;
TagEntryList::iterator i;
for (n=0, i=pIcc->m_Tags->begin(); i!=pIcc->m_Tags->end(); i++, n++) {
printf("%25s %s %8d\t%8d\n", Fmt.GetTagSigName(i->TagInfo.sig),
icGetSig(buf, i->TagInfo.sig, false),
i->TagInfo.offset, i->TagInfo.size);
}
if (argc>nArg+1) {
if (!stricmp(argv[nArg+1], "ALL")) {
for (n=0, i=pIcc->m_Tags->begin(); i!=pIcc->m_Tags->end(); i++, n++) {
DumpTag(pIcc, i->TagInfo.sig);
}
}
else {
DumpTag(pIcc, (icTagSignature)icGetSigVal(argv[nArg+1]));
}
}
}
if (nArg>1) {
printf("\nValidation Report\n");
printf( "-----------------\n");
switch (nStatus) {
case icValidateOK:
printf("Profile is valid\n\n");
break;
case icValidateWarning:
printf("Profile has warning(s)\n\n");
break;
case icValidateNonCompliant:
printf("Profile violates ICC specification\n\n");
break;
case icValidateCriticalError:
printf("Profile has Critical Error(s) that violate ICC specificaiton.\n\n");
break;
default:
printf("Profile has unknown status.\n\n");
break;
}
fwrite(sReport.c_str(), sReport.length(), 1, stdout);
}
delete pIcc;
return 0;
}
int main(int argc, char* argv[])
{
int nArg = 1;
if (argc<=1) {
printf("Usage: iccRoundTrip profile {rendering_intent=1 {use_mpe=0}}\n");
printf(" where rendering_intent is (0=perceptual, 1=relative, 2=saturation, 3=absolute)\n");
return -1;
}
icRenderingIntent nIntent = icRelativeColorimetric;
int nUseMPE = 0;
if (argc>2) {
nIntent = (icRenderingIntent)atoi(argv[2]);
if (argc>3) {
nUseMPE = atoi(argv[3]);
}
}
CIccMinMaxEval eval;
icStatusCMM stat = eval.EvaluateProfile(argv[1], 0, nIntent, icInterpLinear, (nUseMPE!=0));
if (stat!=icCmmStatOk) {
printf("Unable to perform round trip on '%s'\n", argv[1]);
return -1;
}
CIccPRMG prmg;
stat = prmg.EvaluateProfile(argv[1], nIntent, icInterpLinear, (nUseMPE!=0));
if (stat!=icCmmStatOk) {
printf("Unable to perform PRMG analysis on '%s'\n", argv[1]);
return -1;
}
CIccInfo info;
printf("Profile: '%s'\n", argv[1]);
printf("Rendering Intent: %s\n", info.GetRenderingIntentName(nIntent));
printf("Specified Gamut: %s\n", prmg.m_bPrmgImplied ? "Perceptual Reference Medium Gamut" : "Not Specified");
printf("\nRound Trip 1\n");
printf( "------------\n");
printf("Min DeltaE: %8.2" ICFLOATSFX "\n", eval.minDE1);
printf("Mean DeltaE: %8.2" ICFLOATSFX "\n", eval.GetMean1());
printf("Max DeltaE: %8.2" ICFLOATSFX "\n\n", eval.maxDE1);
printf("Max L, a, b: " ICFLOATFMT ", " ICFLOATFMT ", " ICFLOATFMT "\n", eval.maxLab1[0], eval.maxLab1[1], eval.maxLab1[2]);
printf("\nRound Trip 2\n");
printf( "------------\n");
printf("Min DeltaE: %8.2" ICFLOATSFX "\n", eval.minDE2);
printf("Mean DeltaE: %8.2" ICFLOATSFX "\n", eval.GetMean2());
printf("Max DeltaE: %8.2" ICFLOATSFX "\n\n", eval.maxDE2);
printf("Max L, a, b: " ICFLOATFMT ", " ICFLOATFMT ", " ICFLOATFMT "\n", eval.maxLab2[0], eval.maxLab2[1], eval.maxLab2[2]);
if (prmg.m_nTotal) {
printf("\nPRMG Interoperability - Round Trip Results\n");
printf( "------------------------------------------------------\n");
printf("DE <= 1.0 (%8u): %5.1f%%\n", prmg.m_nDE1, (float)prmg.m_nDE1/(float)prmg.m_nTotal*100.0);
printf("DE <= 2.0 (%8u): %5.1f%%\n", prmg.m_nDE2, (float)prmg.m_nDE2/(float)prmg.m_nTotal*100.0);
printf("DE <= 3.0 (%8u): %5.1f%%\n", prmg.m_nDE3, (float)prmg.m_nDE3/(float)prmg.m_nTotal*100.0);
printf("DE <= 5.0 (%8u): %5.1f%%\n", prmg.m_nDE5, (float)prmg.m_nDE5/(float)prmg.m_nTotal*100.0);
printf("DE <=10.0 (%8u): %5.1f%%\n", prmg.m_nDE10, (float)prmg.m_nDE10/(float)prmg.m_nTotal*100.0);
printf("Total (%8u)\n", prmg.m_nTotal);
}
return 0;
}
void ShowHeader(CIccProfile *pIcc)
{
icHeader *pHdr = &pIcc->m_Header;
CIccInfo Fmt;
icChar buf[64];
printf("\nHeader\n");
printf( "------\n");
printf("Profile Size: %d(0x%x) bytes\n", pHdr->size, pHdr->size);
if(Fmt.IsProfileIDCalculated(&pHdr->profileID))
printf("Profile ID: %s\n", Fmt.GetProfileID(&pHdr->profileID));
else
printf("Profile ID: Profile ID not calculated.\n");
printf("Attributes: %s\n", Fmt.GetDeviceAttrName(pHdr->attributes));
printf("Cmm: %s\n", Fmt.GetCmmSigName((icCmmSignature)(pHdr->cmmId)));
printf("Creation Date: %d/%d/%d %02u:%02u:%02u\n",
pHdr->date.month, pHdr->date.day, pHdr->date.year,
pHdr->date.hours, pHdr->date.minutes, pHdr->date.seconds);
printf("Creator: %s\n", icGetSig(buf, pHdr->creator));
printf("Data Color Space: %s\n", Fmt.GetColorSpaceSigName(pHdr->colorSpace));
printf("Flags %s\n", Fmt.GetProfileFlagsName(pHdr->flags));
printf("PCS Color Space: %s\n", Fmt.GetColorSpaceSigName(pHdr->pcs));
printf("Platform: %s\n", Fmt.GetPlatformSigName(pHdr->platform));
printf("Rendering Intent: %s\n", Fmt.GetRenderingIntentName((icRenderingIntent)(pHdr->renderingIntent)));
printf("Type: %s\n", Fmt.GetProfileClassSigName(pHdr->deviceClass));
printf("Version: %s\n", Fmt.GetVersionName(pHdr->version));
printf("Illuminant: X=%.4lf, Y=%.4lf, Z=%.4lf\n",
icFtoD(pHdr->illuminant.X),
icFtoD(pHdr->illuminant.Y),
icFtoD(pHdr->illuminant.Z));
printf("\nProfile Tags\n");
printf( "------------\n");
printf("%25s ID %8s\t%8s\n", "Tag", "Offset", "Size");
printf("%25s ------ %8s\t%8s\n", "----", "------", "----");
TagEntryList::iterator i;
for (i=pIcc->m_Tags->begin(); i!=pIcc->m_Tags->end(); i++) {
printf("%25s %s %8d\t%8d\n", Fmt.GetTagSigName(i->TagInfo.sig),
icGetSig(buf, i->TagInfo.sig, false),
i->TagInfo.offset, i->TagInfo.size);
}
}
