Interface for tristimulus-based color specifications. More...

#include <ITristimulusSpecification.h>

Inheritance diagram for icmm::ITristimulusSpecification:

Public Member Functions
virtual std::shared_ptr< IIlluminant >	GetIlluminant () const =0
	Gets the illuminant (light source) used by this specification.

virtual ObserverType	GetObserverType () const =0
	Gets the standard observer type used for color calculations.

virtual AstmTableType	GetMethod () const =0
	Gets the ASTM table type used for spectral calculations.

virtual std::shared_ptr< ISpectralColorSpecification >	GetBaseSpecification () const =0
	Gets the base spectral specification, if one exists.

Public Member Functions inherited from icmm::IColorSpecification
	I_DECLARE_ENUM (SpecType, Tristimulus, Spectral)

Public Member Functions inherited from iser::IObject
virtual QByteArray	GetFactoryId () const

Public Member Functions inherited from iser::ISerializable
virtual bool	Serialize (IArchive &archive)=0
	Load or store state of this object as a archive stream.

virtual quint32	GetMinimalVersion (int versionId) const
	Get minimal needed version to correct storing of this data.

Public Member Functions inherited from istd::IChangeable
virtual int	GetSupportedOperations () const
	Get set of flags for supported operations.

virtual bool	CopyFrom (const IChangeable &object, CompatibilityMode mode=CM_WITHOUT_REFS)
	Copy this object from another one.

virtual bool	IsEqual (const IChangeable &object) const
	Compare this object with another object.

virtual istd::TUniqueInterfacePtr< istd::IChangeable >	CloneMe (CompatibilityMode mode=CM_WITHOUT_REFS) const
	Make a copy of this object.

virtual bool	ResetData (CompatibilityMode mode=CM_WITHOUT_REFS)
	Reset data to its default state.

virtual void	BeginChanges (const ChangeSet &changeSet)
	Starts the change transaction.

virtual void	EndChanges (const ChangeSet &changeSet)
	Ends the change transaction.

virtual void	BeginChangeGroup (const ChangeSet &changeSet)
	Starts group of changes.

virtual void	EndChangeGroup (const ChangeSet &changeSet)
	Ends group of changes.

Public Member Functions inherited from istd::IPolymorphic
virtual	~IPolymorphic ()

Protected Member Functions
virtual SpecType	GetSpecificationType () const final
	Gets the logical type of the specification.

Protected Member Functions inherited from istd::IChangeable
virtual void	OnBeginChanges ()
	Callback function for begin change event.

virtual void	OnEndChanges (const ChangeSet &changeSet)
	Callback function for end change event.

Additional Inherited Members
Public Types inherited from icmm::IColorSpecification
enum	SpecType { Tristimulus , Spectral }

typedef std::shared_ptr< const IColorSpecification >	ConstColorSpecPtr

typedef std::shared_ptr< IColorSpecification >	ColorSpecPtr

Public Types inherited from istd::IChangeable
enum	ChangeFlags { CF_ACF_INTERNAL = 0 , CF_ALL_DATA , CF_ANY , CF_DESTROYING , CF_DELEGATED , CF_NO_UNDO }
	Data model change notification flags. More...

enum	SupportedOperations { SO_NONE = 0 , SO_OBSERVE = 1 << 0 , SO_COPY = 1 << 1 , SO_CLONE = 1 << 2 , SO_COMPARE = 1 << 3 , SO_RESET = 1 << 4 }
	Flags for supported operations. More...

enum	CompatibilityMode { CM_STRICT , CM_WITHOUT_REFS , CM_WITH_REFS , CM_CONVERT }
	Control how relationship betweeen objects are interpreted. More...

typedef QMultiMap< QByteArray, QVariant >	ChangeInfoMap

Static Public Member Functions inherited from istd::IChangeable
static const ChangeSet &	GetNoChanges ()
	Get empty set of changes.

static const ChangeSet &	GetAnyChange ()
	Get anonymous change set.

static const ChangeSet &	GetAllChanges ()
	Get anonymous change set.

static const ChangeSet &	GetDelegatedChanges ()
	Get delegated change set.

Detailed Description

Interface for tristimulus-based color specifications.

Purpose

ITristimulusSpecification extends IColorSpecification for color spaces based on tristimulus values (three-component color representation like XYZ or RGB). It provides access to the illuminant (light source), observer type (standard observer), and calculation method used for color conversions.

Tristimulus Values Concept

Tristimulus values are based on the trichromatic theory of human color vision:

Three receptors: Human eyes have three types of color receptors (cones)
Three values: Any color can be matched with three primary stimuli
XYZ space: CIE XYZ is the fundamental tristimulus color space
RGB spaces: Monitor colors are tristimulus-based (derived from XYZ)

Components

Illuminant:**

Light source specification (D65, D50, A, etc.)
Defines the reference white point
Critical for chromatic adaptation

Observer Type:**
Standard observer (2 degrees or 10 degrees field of view)
CIE 1931 (2 degrees) for small color patches
CIE 1964 (10 degrees) for larger fields

Calculation Method:**
ASTM table type for spectral calculations
Different resolutions/wavelength ranges
Affects accuracy of conversions

Usage Examples

// Example 1: Accessing tristimulus specification
void InspectTristimulusSpec(const icmm::ITristimulusSpecification* spec)
{
       // Get illuminant
       std::shared_ptr<icmm::IIlluminant> illuminant = spec->GetIlluminant();
       if (illuminant) {
              QString name = illuminant->GetIlluminantName();  // "D65", "D50", etc.
              icmm::CVarColor whitePoint = illuminant->GetWhitePoint();
              qDebug() << "Illuminant:" << name;
       }
       
       // Get observer type
       icmm::ObserverType observer = spec->GetObserverType();
       // observer == OT_CIE_1931_2_DEGREE or OT_CIE_1964_10_DEGREE
       
       // Get calculation method
       icmm::AstmTableType method = spec->GetMethod();
}
 
// Example 2: Creating sRGB specification
icmm::TristimulusPtr CreateSRgbSpec()
{
       // sRGB uses:
       // - D65 illuminant
       // - 2 degrees standard observer
       // - Rec. 709 primaries
       
       // Implementation would create appropriate specification
       // icmm::CTristimulusSpecification* spec = new ...
       // spec->SetIlluminant(d65);
       // spec->SetObserverType(OT_CIE_1931_2_DEGREE);
       // return TristimulusPtr(spec);
       
       return nullptr;  // Simplified
}
 
// Example 3: Comparing specifications
bool SpecificationsMatch(const icmm::ITristimulusSpecification* spec1,
                        const icmm::ITristimulusSpecification* spec2)
{
       if (!spec1 || !spec2) return false;
       
       // Compare illuminants
       auto illum1 = spec1->GetIlluminant();
       auto illum2 = spec2->GetIlluminant();
       
       if (illum1 && illum2) {
              if (illum1->GetIlluminantType() != illum2->GetIlluminantType()) {
                     return false;
              }
       }
       
       // Compare observer types
       if (spec1->GetObserverType() != spec2->GetObserverType()) {
              return false;
       }
       
       return true;
}
 
// Example 4: Converting spectral to tristimulus
void ConvertSpectralToXyz(const icmm::ITristimulusSpecification* spec)
{
       // Get base spectral specification if available
       auto spectralSpec = spec->GetBaseSpecification();
       
       if (spectralSpec) {
              // Has underlying spectral data
              // Can use for high-accuracy conversions
              qDebug() << "Has spectral base - high accuracy";
       } else {
              // Direct tristimulus specification
              qDebug() << "Direct tristimulus - standard accuracy";
       }
}
 
// Example 5: Working with RGB color models
void SetupRgbModel(const icmm::ITristimulusSpecification* spec)
{
       // RGB models use tristimulus specifications
       icmm::CRgbColorModel rgbModel(*spec);
       
       // The model now uses the specified:
       // - Illuminant (white point)
       // - Observer (color matching functions)
       // - Method (calculation precision)
       
       // Enables accurate color conversions
       IColorSpecification::ConstColorSpecPtr modelSpec = 
              rgbModel.GetSpecification();
}
 
// Example 6: Checking specification type
void ProcessColorSpec(const icmm::IColorSpecification* spec)
{
       if (spec->GetSpecificationType() == 
           IColorSpecification::SpecType::Tristimulus) 
       {
              // Cast to tristimulus specification
              const icmm::ITristimulusSpecification* tristimSpec = 
                     dynamic_cast<const icmm::ITristimulusSpecification*>(spec);
              
              if (tristimSpec) {
                     // Access tristimulus-specific properties
                     auto illuminant = tristimSpec->GetIlluminant();
                     auto observer = tristimSpec->GetObserverType();
              }
       }
}

Standard Configurations

sRGB (web/display standard):**

Illuminant: D65
Observer: CIE 1931 2 degrees
Primaries: Rec. 709

Adobe RGB (photography):**
Illuminant: D65
Observer: CIE 1931 2 degrees
Wider gamut than sRGB

Print workflows:**
Illuminant: D50 (standard for printing)
Observer: CIE 1931 2 degrees
ICC profile-based

Best Practices

Match illuminant to viewing conditions (D65 for displays, D50 for print)
Use 2 degrees observer for most applications
Use 10 degrees observer for large color patches or critical matching
Check for spectral base when accuracy is critical
Cache specifications for repeated conversions

See also: icmm::IColorSpecification, icmm::IIlluminant, icmm::IWhitePointProvider, icmm::ISpectralColorSpecification, icmm::CTristimulusSpecification

Definition at line 187 of file ITristimulusSpecification.h.

Member Function Documentation

◆ GetBaseSpecification()

virtual std::shared_ptr< ISpectralColorSpecification > icmm::ITristimulusSpecification::GetBaseSpecification ( ) const

pure virtual

Gets the base spectral specification, if one exists.

Some tristimulus specifications are derived from spectral data, which provides higher accuracy for certain conversions. If available, the base spectral specification can be used for improved accuracy.