CFastColor.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ACF-Commercial
#pragma once
 
 
// Qt includes
#include <QtCore/QtGlobal>
#if QT_VERSION >= 0x050000
#include <QtCore/QtMath>
#else
#include <QtCore/qmath.h>
#endif
 
// ACF includes
#include <iser/ISerializable.h>
#include <imath/IDoubleManip.h>
#include <imath/TFastVector.h>
#include <icmm/CVarColor.h>
#include <icmm/CLab.h>
 
 
namespace icmm
{
 
 
enum{
#ifdef COLOR_COMPONENTS_COUNT
       MAX_COLOR_COMPONENTS_COUNT=COLOR_COMPONENTS_COUNT
#else
       MAX_COLOR_COMPONENTS_COUNT=16
#endif // COLOR_COMPONENTS_COUNT
};
 
 
class CFastColor: public imath::TFastVector<MAX_COLOR_COMPONENTS_COUNT>
{
public:
       typedef imath::TFastVector<MAX_COLOR_COMPONENTS_COUNT> BaseClass;
 
       CFastColor();
 
       explicit CFastColor(int componentsCount, double value = 0);
 
       CFastColor(const CFastColor& color);
 
       CFastColor(std::initializer_list<double> values);
 
       template <int Size>
       CFastColor(const imath::TVector<Size>& vector)
       :      BaseClass(vector)
       {
       }
 
       #if __cplusplus >= 202002L
       template <typename Iterator>
       requires std::input_iterator<Iterator>  // Require C++20 iterator concept to disambiguate from other constructors
       CFastColor(Iterator first, Iterator last);
       #endif // __cplusplus >= 202002L
 
       CFastColor(const icmm::CVarColor& color);
 
       icmm::CLab GetAsLab() const;
       void SetAsLab(const icmm::CLab& lab);
 
       bool EnsureElementsCount(int count, double value = 0);
 
       void GetRounded(const imath::IDoubleManip& manipulator, CFastColor& result);
 
       bool IsRoundedEqual(const CFastColor& color, const imath::IDoubleManip& manipulator) const;
 
       bool IsSimilar(const CFastColor& color, double tolerance = I_BIG_EPSILON) const;
 
       bool IsNormalized() const;
 
       void Normalize();
 
       void GetNormalized(CFastColor& result) const;
 
       operator icmm::CVarColor() const;
 
       bool operator==(const CFastColor& vector) const;
       bool operator!=(const CFastColor& vector) const;
       bool operator<(const CFastColor& vector) const;
       bool operator>(const CFastColor& vector) const;
       bool operator<=(const CFastColor& vector) const;
       bool operator>=(const CFastColor& vector) const;
 
       CFastColor operator+(const CFastColor& color) const;
       CFastColor operator-(const CFastColor& color) const;
       CFastColor operator*(const CFastColor& color) const;
       CFastColor operator/(const CFastColor& color) const;
 
       CFastColor operator*(double value) const;
       CFastColor operator/(double value) const;
 
       CFastColor& operator=(const CFastColor& color);
 
       const CFastColor& operator+=(const CFastColor& color);
       const CFastColor& operator-=(const CFastColor& color);
       const CFastColor& operator*=(const CFastColor& color);
       const CFastColor& operator/=(const CFastColor& color);
 
       const CFastColor& operator*=(double value);
       const CFastColor& operator/=(double value);
 
       // not reimplemented (iser::ISerializable)
       bool Serialize(iser::IArchive& archive);
};
 
 
// inline methods
 
inline CFastColor::CFastColor()
{
#ifdef COLOR_COMPONENTS_COUNT
       for (int i = 0; i < COLOR_COMPONENTS_COUNT; ++i){
              m_elements[i] = 0;
       }
#endif // COLOR_COMPONENTS_COUNT
}
 
 
inline CFastColor::CFastColor(int componentsCount, double value)
#ifndef COLOR_COMPONENTS_COUNT
:      BaseClass(componentsCount, value)
#endif // !COLOR_COMPONENTS_COUNT
{
#ifdef COLOR_COMPONENTS_COUNT
       m_elementsCount = componentsCount;
 
       for (int i = 0; i < COLOR_COMPONENTS_COUNT; ++i){
              m_elements[i] = value;
       }
#endif // COLOR_COMPONENTS_COUNT
}
 
 
inline CFastColor::CFastColor(const CFastColor& color)
#ifndef COLOR_COMPONENTS_COUNT
:      BaseClass(color)
#endif // !COLOR_COMPONENTS_COUNT
{
#ifdef COLOR_COMPONENTS_COUNT
       m_elementsCount = color.m_elementsCount;
 
       for (int i = 0; i < COLOR_COMPONENTS_COUNT; ++i){
              m_elements[i] = color.m_elements[i];
       }
#endif // COLOR_COMPONENTS_COUNT
}
 
 
inline CFastColor::CFastColor(std::initializer_list<double> values)
#ifndef COLOR_COMPONENTS_COUNT
:      BaseClass(values)
#endif // !COLOR_COMPONENTS_COUNT
{
#ifdef COLOR_COMPONENTS_COUNT
       m_elementsCount = qMin(COLOR_COMPONENTS_COUNT, static_cast<int>(values.size()));
       Q_ASSERT(values.size() <= COLOR_COMPONENTS_COUNT);
 
       for (int i = 0; i < m_elementsCount; ++i){
              m_elements[i] = *(values.begin() + i);
       }
 
       for (int i = m_elementsCount; i < COLOR_COMPONENTS_COUNT; ++i){
              m_elements[i] = 0.0;
       }
#endif // COLOR_COMPONENTS_COUNT
}
 
 
#if __cplusplus >= 202002L
template <typename Iterator>
requires std::input_iterator<Iterator>  // Require C++20 iterator concept to disambiguate from other constructors
inline CFastColor::CFastColor(Iterator first, Iterator last)
{
       const size_t size = last - first;
       if (EnsureElementsCount(size)) {
              for (size_t i = 0; i < size; ++i, ++first) {
                     operator[](i) = *first;
              }
       }
}
#endif // __cplusplus >= 202002L
 
 
inline bool CFastColor::EnsureElementsCount(int count, double value)
{
       if (count > GetElementsCount()){
              return SetElementsCount(count, value);
       }
 
       return true;
}
 
 
inline bool CFastColor::IsSimilar(const CFastColor& color, double tolerance) const
{
       return GetDistance(color) <= tolerance;
}
 
 
inline bool CFastColor::IsNormalized() const
{
       int elementsCount = GetElementsCount();
 
       for (int i = 0; i < elementsCount; ++i){
              double component = m_elements[i];
 
              if ((component < 0) || (component > 1)){
                     return false;
              }
       }
 
       return true;
}
 
 
inline CFastColor::operator icmm::CVarColor() const
{
       int elementsCount = GetElementsCount();
 
       icmm::CVarColor retVal(elementsCount);
 
       for (int i = 0; i < elementsCount; ++i){
              retVal[i] = GetElement(i);
       }
 
       return retVal;
}
 
 
inline bool CFastColor::operator==(const CFastColor& vector) const
{
       int elementsCount = GetElementsCount();
 
       if (elementsCount != vector.GetElementsCount()){
              return false;
       }
 
       for (int i = 0; i < elementsCount; ++i){
              if (          (operator[](i) > vector[i] + I_BIG_EPSILON) ||
                                   (operator[](i) < vector[i] - I_BIG_EPSILON)){
                     return false;
              }
       }
 
       return true;
}
 
 
inline bool CFastColor::operator!=(const CFastColor& vector) const
{
       return !operator==(vector);
}
 
 
inline bool CFastColor::operator<(const CFastColor& vector) const
{
       int commonSize = qMin(GetElementsCount(), vector.GetElementsCount());
 
       for (int i = 0; i < commonSize; ++i){
              if (operator[](i) > vector[i] + I_BIG_EPSILON){
                     return false;
              }
              else if (operator[](i) < vector[i] - I_BIG_EPSILON){
                     return true;
              }
       }
 
       return GetElementsCount() < vector.GetElementsCount();
}
 
 
inline bool CFastColor::operator>(const CFastColor& vector) const
{
       int commonSize = qMin(GetElementsCount(), vector.GetElementsCount());
       for (int i = 0; i < commonSize; ++i){
              if (operator[](i) > vector[i] + I_BIG_EPSILON){
                     return true;
              }
              else if (operator[](i) < vector[i] - I_BIG_EPSILON){
                     return false;
              }
       }
 
       return GetElementsCount() > vector.GetElementsCount();
}
 
 
inline bool CFastColor::operator<=(const CFastColor& vector) const
{
       int commonSize = qMin(GetElementsCount(), vector.GetElementsCount());
       for (int i = 0; i < commonSize; ++i){
              if (operator[](i) > vector[i] + I_BIG_EPSILON){
                     return false;
              }
              else if (operator[](i) < vector[i] - I_BIG_EPSILON){
                     return true;
              }
       }
 
       return GetElementsCount() <= vector.GetElementsCount();
}
 
 
inline bool CFastColor::operator>=(const CFastColor& vector) const
{
       int commonSize = qMin(GetElementsCount(), vector.GetElementsCount());
       for (int i = 0; i < commonSize; ++i){
              if (operator[](i) > vector[i] + I_BIG_EPSILON){
                     return true;
              }
              else if (operator[](i) < vector[i] - I_BIG_EPSILON){
                     return false;
              }
       }
 
       return GetElementsCount() >= vector.GetElementsCount();
}
 
 
inline CFastColor CFastColor::operator+(const CFastColor& color) const
{
       CFastColor retVal(*this);
 
       retVal += color;
 
       return retVal;
}
 
 
inline CFastColor CFastColor::operator-(const CFastColor& color) const
{
       CFastColor retVal(*this);
 
       retVal -= color;
 
       return retVal;
}
 
 
inline CFastColor CFastColor::operator*(const CFastColor& color) const
{
       CFastColor retVal(*this);
 
       retVal *= color;
 
       return retVal;
}
 
 
inline CFastColor CFastColor::operator/(const CFastColor& color) const
{
       CFastColor retVal(*this);
 
       retVal /= color;
 
       return retVal;
}
 
 
inline CFastColor CFastColor::operator*(double value) const
{
       int elementsCount = GetElementsCount();
 
       CFastColor retVal(elementsCount);
 
#ifdef COLOR_COMPONENTS_COUNT
       for (int i = 0; i < COLOR_COMPONENTS_COUNT; ++i){
#else
       for (int i = 0; i < elementsCount; ++i){
#endif // COLOR_COMPONENTS_COUNT
              retVal.m_elements[i] = m_elements[i] * value;
       }
 
       return retVal;
}
 
 
inline CFastColor CFastColor::operator/(double value) const
{
       int elementsCount = GetElementsCount();
 
       CFastColor retVal(elementsCount);
 
#ifdef COLOR_COMPONENTS_COUNT
       for (int i = 0; i < COLOR_COMPONENTS_COUNT; ++i){
#else
       for (int i = 0; i < elementsCount; ++i){
#endif // COLOR_COMPONENTS_COUNT
              retVal.m_elements[i] = m_elements[i] / value;
       }
 
       return retVal;
}
 
 
inline CFastColor& CFastColor::operator=(const CFastColor& color)
{
#ifdef COLOR_COMPONENTS_COUNT
       m_elementsCount = color.m_elementsCount;
       Q_ASSERT(m_elementsCount <= COLOR_COMPONENTS_COUNT);
 
       for (int i = 0; i < COLOR_COMPONENTS_COUNT; ++i){
              m_elements[i] = color.m_elements[i];
       }
#else
       BaseClass::operator=(color);
#endif // COLOR_COMPONENTS_COUNT
 
       return *this;
}
 
 
inline const CFastColor& CFastColor::operator+=(const CFastColor& color)
{
#ifdef COLOR_COMPONENTS_COUNT
       m_elementsCount = qMax(m_elementsCount, color.m_elementsCount);
       Q_ASSERT(m_elementsCount <= COLOR_COMPONENTS_COUNT);
 
       for (int i = 0; i < COLOR_COMPONENTS_COUNT; ++i){
              m_elements[i] += color.m_elements[i];
       }
#else
       BaseClass::operator+=(color);
#endif // COLOR_COMPONENTS_COUNT
 
       return *this;
}
 
 
inline const CFastColor& CFastColor::operator-=(const CFastColor& color)
{
#ifdef COLOR_COMPONENTS_COUNT
       m_elementsCount = qMax(m_elementsCount, color.m_elementsCount);
       Q_ASSERT(m_elementsCount <= COLOR_COMPONENTS_COUNT);
 
       for (int i = 0; i < COLOR_COMPONENTS_COUNT; ++i){
              m_elements[i] -= color.m_elements[i];
       }
#else
       BaseClass::operator-=(color);
#endif // COLOR_COMPONENTS_COUNT
 
       return *this;
}
 
 
inline const CFastColor& CFastColor::operator*=(const CFastColor& color)
{
#ifdef COLOR_COMPONENTS_COUNT
       for (int i = 0; i < COLOR_COMPONENTS_COUNT; ++i){
#else
       int elementsCount = qMin(GetElementsCount(), color.GetElementsCount());
       for (int i = 0; i < elementsCount; ++i){
#endif // COLOR_COMPONENTS_COUNT
              m_elements[i] *= color.m_elements[i];
       }
 
       return *this;
}
 
 
inline const CFastColor& CFastColor::operator/=(const CFastColor& color)
{
#ifdef COLOR_COMPONENTS_COUNT
       for (int i = 0; i < COLOR_COMPONENTS_COUNT; ++i){
#else
       int elementsCount = qMin(GetElementsCount(), color.GetElementsCount());
       for (int i = 0; i < elementsCount; ++i){
#endif // COLOR_COMPONENTS_COUNT
              m_elements[i] /= color.m_elements[i];
       }
 
       return *this;
}
 
 
inline const CFastColor& CFastColor::operator*=(double value)
{
#ifdef COLOR_COMPONENTS_COUNT
       for (int i = 0; i < COLOR_COMPONENTS_COUNT; ++i){
              m_elements[i] *= value;
       }
#else
       BaseClass::operator*=(value);
#endif // COLOR_COMPONENTS_COUNT
 
       return *this;
}
 
 
inline const CFastColor& CFastColor::operator/=(double value)
{
#ifdef COLOR_COMPONENTS_COUNT
       for (int i = 0; i < COLOR_COMPONENTS_COUNT; ++i){
              m_elements[i] /= value;
       }
#else
       BaseClass::operator/=(value);
#endif // COLOR_COMPONENTS_COUNT
 
       return *this;
}
 
 
// related global functions
 
uint qHash(const CFastColor& color, uint seed = 0);
 
 
} // namespace icmm