CVarColor.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
 
 
// ACF includes
#include <iser/ISerializable.h>
#include <imath/IDoubleManip.h>
#include <imath/CVarVector.h>
#include <icmm/icmm.h>
 
 
namespace icmm
{
 
 
class CVarColor: public imath::CVarVector, virtual public iser::ISerializable
{
public:
       typedef imath::CVarVector BaseClass;
 
       CVarColor();
 
       explicit CVarColor(int componentsCount, double value = 0);
 
       CVarColor(const CVarColor& color);
 
       template <int Size>
       CVarColor(const imath::TVector<Size>& vector)
       :      BaseClass(vector)
       {
       }
 
       void GetRounded(const imath::IDoubleManip& manipulator, CVarColor& result);
 
       bool IsRoundedEqual(const CVarColor& color, const imath::IDoubleManip& manipulator) const;
 
       bool IsSimilar(const CVarColor& color, double tolerance = I_BIG_EPSILON) const;
 
       bool IsNormalized() const;
 
       void Normalize();
 
       void GetNormalized(CVarColor& result) const;
 
       CVarColor operator+(const CVarColor& color) const;
       CVarColor operator-(const CVarColor& color) const;
       CVarColor operator*(const CVarColor& color) const;
       CVarColor operator/(const CVarColor& color) const;
 
       CVarColor operator*(double value) const;
       CVarColor operator/(double value) const;
 
       CVarColor& operator=(const CVarColor& color);
 
       const CVarColor& operator+=(const CVarColor& color);
       const CVarColor& operator-=(const CVarColor& color);
       const CVarColor& operator*=(const CVarColor& color);
       const CVarColor& operator/=(const CVarColor& color);
 
       const CVarColor& operator*=(double value);
       const CVarColor& operator/=(double value);
 
       // reimplemented (iser::ISerializable)
       virtual bool Serialize(iser::IArchive& archive) override;
};
 
 
// inline methods
 
inline bool CVarColor::IsSimilar(const CVarColor& color, double tolerance) const
{
       return GetDistance(color) <= tolerance;
}
 
 
inline bool CVarColor::IsNormalized() const
{
       int elementsCount = GetElementsCount();
 
       for (int i = 0; i < elementsCount; ++i){
              double component = GetElement(i);
 
              if ((component < 0) || (component > 1)){
                     return false;
              }
       }
 
       return true;
}
 
 
inline CVarColor CVarColor::operator+(const CVarColor& color) const
{
       CVarColor retVal(*this);
 
       retVal += color;
 
       return retVal;
}
 
 
inline CVarColor CVarColor::operator-(const CVarColor& color) const
{
       CVarColor retVal(*this);
 
       retVal -= color;
 
       return retVal;
}
 
 
inline CVarColor CVarColor::operator*(const CVarColor& color) const
{
       CVarColor retVal(*this);
 
       retVal *= color;
 
       return retVal;
}
 
 
inline CVarColor CVarColor::operator/(const CVarColor& color) const
{
       CVarColor retVal(*this);
 
       retVal /= color;
 
       return retVal;
}
 
 
inline CVarColor CVarColor::operator*(double value) const
{
       int elementsCount = GetElementsCount();
 
       CVarColor retVal(elementsCount);
 
       for (int i = 0; i < elementsCount; ++i){
              retVal.SetElement(i, GetElement(i) * value);
       }
 
       return retVal;
}
 
 
inline CVarColor CVarColor::operator/(double value) const
{
       int elementsCount = GetElementsCount();
 
       CVarColor retVal(elementsCount);
 
       for (int i = 0; i < elementsCount; ++i){
              retVal.SetElement(i, GetElement(i) / value);
       }
 
       return retVal;
}
 
 
inline const CVarColor& CVarColor::operator*=(double value)
{
       BaseClass::operator*=(value);
 
       return *this;
}
 
 
inline const CVarColor& CVarColor::operator/=(double value)
{
       BaseClass::operator/=(value);
 
       return *this;
}
 
 
} // namespace icmm