Interface for color space specification information. More...

#include <IColorSpecification.h>

Inheritance diagram for icmm::IColorSpecification:

Public Types
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

Public Member Functions
	I_DECLARE_ENUM (SpecType, Tristimulus, Spectral)

virtual SpecType	GetSpecificationType () const =0
	Gets the logical type of the specification.

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 ()

Additional Inherited Members
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.

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.

Detailed Description

Interface for color space specification information.

Purpose

IColorSpecification provides metadata about how a color space is defined. This includes information about the reference white point, color primaries (for RGB), viewing conditions, and other parameters needed for accurate color reproduction and conversion between color spaces.

Specification Types

Color specifications fall into two categories:

Tristimulus-based (SpecType::Tristimulus):**

RGB spaces (sRGB, Adobe RGB, ProPhoto RGB)
Defined by primaries and white point
Use 3 values to represent any color
Examples: sRGB (Rec. 709), Adobe RGB (1998), DCI-P3

Spectral-based (SpecType::Spectral):**
Full wavelength representation
Defined by spectral power distribution
Use many values across wavelength range
Most accurate but computationally expensive

Usage Examples

// Example 1: Checking specification type
void InspectSpecification(const icmm::IColorSpecification* spec)
{
       IColorSpecification::SpecType type = spec->GetSpecificationType();
       
       switch (type) {
       case IColorSpecification::SpecType::Tristimulus:
              qDebug() << "Tristimulus-based (e.g., RGB)";
              // Can cast to ITristimulusSpecification
              break;
              
       case IColorSpecification::SpecType::Spectral:
              qDebug() << "Spectral-based (full spectrum)";
              // Can cast to ISpectralColorSpecification
              break;
       }
}
 
// Example 2: Working with RGB specifications
void HandleRgbSpec(IColorSpecification::ConstColorSpecPtr spec)
{
       if (spec && spec->GetSpecificationType() == 
           IColorSpecification::SpecType::Tristimulus) 
       {
              // Can use tristimulus-specific operations
              const icmm::ITristimulusSpecification* tristim = 
                     dynamic_cast<const icmm::ITristimulusSpecification*>(spec.get());
              
              if (tristim) {
                     // Access primaries, white point, gamma, etc.
                     icmm::CVarColor whitePoint = tristim->GetWhitePoint();
              }
       }
}
 
// Example 3: Comparing specifications
bool SpecificationsMatch(IColorSpecification::ConstColorSpecPtr spec1,
                        IColorSpecification::ConstColorSpecPtr spec2)
{
       if (!spec1 || !spec2) {
              return spec1 == spec2;  // Both null or one null
       }
       
       // Different types don't match
       if (spec1->GetSpecificationType() != spec2->GetSpecificationType()) {
              return false;
       }
       
       // Would need type-specific comparison
       // ...
       
       return false;
}
 
// Example 4: Creating color with specification
icmm::IColorObject* CreateColorWithSpec(
       const icmm::CVarColor& colorValue,
       IColorSpecification::ConstColorSpecPtr spec)
{
       // Create appropriate color object based on specification
       if (spec) {
              switch (spec->GetSpecificationType()) {
              case IColorSpecification::SpecType::Tristimulus:
                     // Create RGB color with specification
                     // return new CRgbColor(colorValue, spec);
                     break;
                     
              case IColorSpecification::SpecType::Spectral:
                     // Create spectral color with specification
                     // return new CSpectralColor(colorValue, spec);
                     break;
              }
       }
       
       return nullptr;
}
 
// Example 5: Specification-aware conversion
bool CanConvertAccurately(IColorSpecification::ConstColorSpecPtr sourceSpec,
                         IColorSpecification::ConstColorSpecPtr destSpec)
{
       // Spectral -> Tristimulus: Always possible, may lose info
       if (sourceSpec && sourceSpec->GetSpecificationType() == 
           IColorSpecification::SpecType::Spectral) {
              return true;
       }
       
       // Tristimulus -> Tristimulus: Depends on gamuts
       if (sourceSpec && destSpec &&
           sourceSpec->GetSpecificationType() == IColorSpecification::SpecType::Tristimulus &&
           destSpec->GetSpecificationType() == IColorSpecification::SpecType::Tristimulus) {
              // Check if gamuts overlap
              return true;  // Simplified
       }
       
       return false;
}

Common Specifications

RGB Specifications:**

sRGB: Standard RGB (Rec. 709 primaries, D65 white, gamma 2.2)
Adobe RGB (1998): Wider gamut for professional work
ProPhoto RGB: Very wide gamut, includes most visible colors
DCI-P3: Digital cinema standard

Purpose:**
Ensures consistent color reproduction
Enables accurate color space conversions
Supports color management workflows
Provides device characterization

Best Practices

Always check specification type before casting
Use specifications for accurate color conversions
Match specifications when comparing colors
Store specification with colors for reproducibility
Use appropriate specification for intended output (display vs. print)

See also: icmm::ITristimulusSpecification, icmm::ISpectralColorSpecification, icmm::IColorModel, icmm::IWhitePointProvider

Definition at line 167 of file IColorSpecification.h.

Member Typedef Documentation

◆ ColorSpecPtr

typedef std::shared_ptr<IColorSpecification> icmm::IColorSpecification::ColorSpecPtr

Definition at line 171 of file IColorSpecification.h.

◆ ConstColorSpecPtr

typedef std::shared_ptr<const IColorSpecification> icmm::IColorSpecification::ConstColorSpecPtr

Definition at line 170 of file IColorSpecification.h.

Member Enumeration Documentation

◆ SpecType

enum icmm::IColorSpecification::SpecType

Enumerator
Tristimulus	Tristimulus-based specification (e.g., RGB with primaries and white point).
Spectral	Spectral-based specification (full wavelength representation).

Definition at line 173 of file IColorSpecification.h.

Member Function Documentation

◆ GetSpecificationType()

virtual SpecType icmm::IColorSpecification::GetSpecificationType ( ) const

pure virtual

Gets the logical type of the specification.

Returns whether this is a tristimulus-based specification (3 values like RGB) or a spectral-based specification (full wavelength distribution).

Returns: SpecType indicating Tristimulus or Spectral

See also: SpecType

Implemented in icmm::ISpectralColorSpecification, and icmm::ITristimulusSpecification.

◆ I_DECLARE_ENUM()

icmm::IColorSpecification::I_DECLARE_ENUM	(	SpecType	,
		Tristimulus	,
		Spectral
	)

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

Acf/Include/icmm/IColorSpecification.h

Public Types

Public Member Functions

Additional Inherited Members