TRange.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
 
 
// STL includes
#include <algorithm>
#include <cmath>
 
// Qt includes
#include <QtCore/QtGlobal>
 
 
namespace istd
{
 
 
template <typename ValueType>
class TRange
{
public:
       TRange();
       TRange(const TRange& range);
 
       TRange(ValueType minValue, ValueType maxValue);
 
       bool IsValid() const;
 
       bool IsEmpty() const;
 
       bool IsValidNonEmpty() const;
 
       ValueType GetMinValue() const;
 
       ValueType& GetMinValueRef();
 
       void SetMinValue(ValueType minValue);
 
       ValueType GetAbsMinValue() const;
 
       ValueType GetAbsMaxValue() const;
 
       ValueType GetMaxValue() const;
 
       ValueType& GetMaxValueRef();
 
       void SetMaxValue(ValueType maxValue);
 
       void Reset();
 
       ValueType GetLength() const;
 
       TRange GetValidated() const;
 
       void GetValidated(TRange& result) const;
 
       void Validate();
 
       bool Contains(ValueType value) const;
 
       bool Contains(const TRange& range) const;
 
       bool IsIntersectedBy(const TRange& range) const;
 
       bool IsOutsideOf(const TRange& range) const;
 
       TRange GetTranslated(ValueType offset) const;
 
       void Translate(ValueType offset);
 
       TRange GetIntersection(const TRange& range) const;
 
       void Intersection(const TRange& range);
 
       TRange GetUnion(const TRange& range) const;
 
       TRange GetUnion(double value) const;
 
       void Unite(const TRange& range);
 
       void Unite(double value);
 
       TRange GetExpanded(const TRange& range) const;
 
       void Expand(const TRange& range);
 
       ValueType GetDistance(ValueType value) const;
       ValueType GetNearestInside(ValueType value) const;
 
       ValueType GetClipped(ValueType value) const;
 
       TRange GetClipped(const TRange& range) const;
 
       ValueType GetValueFromAlpha(double alpha) const;
 
       double GetAlphaFromValue(ValueType value) const;
 
       ValueType GetMappedTo(ValueType value, const TRange& range) const;
 
       TRange GetApply(const TRange& range) const;
       
       TRange GetInvertApply(const TRange& range) const;
 
       TRange GetInverted() const;
 
       void SetInterpolated(const TRange& first, const TRange& second, double alpha);
 
       TRange& operator=(const TRange& range);
       bool operator==(const TRange& range) const;
       bool operator!=(const TRange& range) const;
       TRange operator*(double value) const;
       TRange operator/(double value) const;
       TRange& operator*=(double value);
       TRange& operator/=(double value);
 
       // static methods
       static const TRange& GetNull();
       static const TRange& GetInvalid();
       static TRange GetValid(ValueType value1, ValueType value2);
 
private:
       ValueType m_minValue;
       ValueType m_maxValue;
};
 
 
// public methods
 
template <typename ValueType>
TRange<ValueType>::TRange()
       :m_minValue(0),
       m_maxValue(0)
{
}
 
 
template <typename ValueType>
TRange<ValueType>::TRange(const TRange& range)
       :m_minValue(range.m_minValue),
       m_maxValue(range.m_maxValue)
{
}
 
 
template <typename ValueType>
TRange<ValueType>::TRange(ValueType minValue, ValueType maxValue)
       :m_minValue(minValue),
       m_maxValue(maxValue)
{
}
 
 
template <typename ValueType>
inline bool TRange<ValueType>::IsValid() const
{
       return (m_minValue <= m_maxValue);
}
 
 
template <typename ValueType>
inline bool TRange<ValueType>::IsEmpty() const
{
       return (m_minValue == m_maxValue);
}
 
 
template <typename ValueType>
inline bool TRange<ValueType>::IsValidNonEmpty() const
{
       return (m_minValue < m_maxValue);
}
 
 
template <typename ValueType>
inline ValueType TRange<ValueType>::GetMinValue() const
{
       return m_minValue;
}
 
 
template <typename ValueType>
inline ValueType& TRange<ValueType>::GetMinValueRef()
{
       return m_minValue;
}
 
 
template <typename ValueType>
inline void TRange<ValueType>::SetMinValue(ValueType minValue)
{
       m_minValue = minValue;
}
 
 
template <typename ValueType>
ValueType TRange<ValueType>::GetAbsMinValue() const
{
       ValueType absMin = std::abs(m_minValue);
       ValueType absMax = std::abs(m_maxValue);
 
       return std::min<ValueType>(absMin , absMax);
}
 
 
template <typename ValueType>
ValueType TRange<ValueType>::GetAbsMaxValue() const
{
       ValueType absMin = std::abs(m_minValue);
       ValueType absMax = std::abs(m_maxValue);
 
       return std::max<ValueType>(absMin, absMax);
}
 
 
template <typename ValueType>
inline ValueType TRange<ValueType>::GetMaxValue() const
{
       return m_maxValue;
}
 
 
template <typename ValueType>
inline ValueType& TRange<ValueType>::GetMaxValueRef()
{
       return m_maxValue;
}
 
 
template <typename ValueType>
inline void TRange<ValueType>::SetMaxValue(ValueType maxValue)
{
       m_maxValue = maxValue;
}
 
 
template <typename ValueType>
void TRange<ValueType>::Reset()
{
       m_minValue = ValueType(0);
       m_maxValue = ValueType(0);
}
 
 
template <typename ValueType>
inline ValueType TRange<ValueType>::GetLength() const
{
       return IsValid() ? m_maxValue - m_minValue: 0;
}
 
 
template <typename ValueType>
inline TRange<ValueType> TRange<ValueType>::GetValidated() const
{
       return TRange(
                            std::min<ValueType>(m_minValue, m_maxValue),
                            std::max<ValueType>(m_minValue, m_maxValue));
}
 
 
template <typename ValueType>
inline void TRange<ValueType>::GetValidated(TRange& result) const
{
       result.SetMinValue(std::min<ValueType>(m_minValue, m_maxValue));
       result.SetMaxValue(std::max<ValueType>(m_minValue, m_maxValue));
}
 
 
template <typename ValueType>
inline void TRange<ValueType>::Validate()
{
       *this = TRange(std::min<ValueType>(m_minValue, m_maxValue), std::max<ValueType>(m_minValue, m_maxValue));
}
 
 
template <typename ValueType>
inline bool TRange<ValueType>::Contains(ValueType value) const
{
       Q_ASSERT(IsValid());
 
       return (value  >= m_minValue) && (value <= m_maxValue);
}
 
 
template <typename ValueType>
inline bool TRange<ValueType>::Contains(const TRange& range) const
{
       Q_ASSERT(IsValid());
       Q_ASSERT(range.IsValid());
 
       return (range.m_minValue >= m_minValue) && (range.m_maxValue <= m_maxValue);
}
 
 
template <typename ValueType>
inline bool TRange<ValueType>::IsIntersectedBy(const TRange& range) const
{
       return (range.m_maxValue > m_minValue) && (range.m_minValue < m_maxValue);
}
 
 
template <typename ValueType>
inline bool TRange<ValueType>::IsOutsideOf(const TRange& range) const
{
       return (range.m_maxValue <= m_minValue) || (range.m_minValue >= m_maxValue);
}
 
 
template <typename ValueType>
inline TRange<ValueType> TRange<ValueType>::GetTranslated(ValueType offset) const
{
       return TRange(m_minValue + offset, m_maxValue + offset);
}
 
 
template <typename ValueType>
inline void TRange<ValueType>::Translate(ValueType offset)
{
       m_minValue += offset;
       m_maxValue += offset;
}
 
 
template <typename ValueType>
inline TRange<ValueType> TRange<ValueType>::GetIntersection(const TRange& range) const
{
       if (IsEmpty()){
              return *this;
       }
       else{
              return TRange(std::max<ValueType>(m_minValue, range.m_minValue), std::min<ValueType>(m_maxValue, range.m_maxValue));
       }
}
 
 
template <typename ValueType>
void TRange<ValueType>::Intersection(const TRange& range)
{
       if (!IsEmpty()){
              if (range.m_minValue > m_minValue){
                     m_minValue = range.m_minValue;
              }
 
              if (range.m_maxValue < m_maxValue){
                     m_maxValue = range.m_maxValue;
              }
       }
}
 
 
template <typename ValueType>
TRange<ValueType> TRange<ValueType>::GetUnion(const TRange& range) const
{
       if (range.IsValid()){
              if (IsValid()){
                     return TRange(std::min<ValueType>(m_minValue, range.m_minValue), std::max<ValueType>(m_maxValue, range.m_maxValue));
              }
              else{
                     return range;
              }
       }
       else{
              return *this;
       }
}
 
 
template <typename ValueType>
TRange<ValueType> TRange<ValueType>::GetUnion(double value) const
{
       if (IsValid()){
              return TRange(std::min<ValueType>(m_minValue, value), std::max<ValueType>(m_maxValue, value));
       }
       else{
              return TRange(value, value);
       }
}
 
 
template <typename ValueType>
void TRange<ValueType>::Unite(const TRange& range)
{
       if (range.IsValid()){
              if (IsValid()){
                     if (range.m_minValue < m_minValue){
                            m_minValue = range.m_minValue;
                     }
 
                     if (range.m_maxValue > m_maxValue){
                            m_maxValue = range.m_maxValue;
                     }
              }
              else{
                     *this = range;
              }
       }
}
 
 
template <typename ValueType>
void TRange<ValueType>::Unite(double value)
{
       if (IsValid()){
              if (value < m_minValue){
                     m_minValue = value;
              }
 
              if (value > m_maxValue){
                     m_maxValue = value;
              }
       }
       else{
              m_minValue = value;
              m_maxValue = value;
       }
}
 
 
template <typename ValueType>
inline TRange<ValueType> TRange<ValueType>::GetExpanded(const TRange& range) const
{
       return TRange(m_minValue + range.m_minValue, m_maxValue + range.m_maxValue);
}
 
 
template <typename ValueType>
inline void TRange<ValueType>::Expand(const TRange& range)
{
       m_minValue += range.m_minValue;
       m_maxValue += range.m_maxValue;
}
 
 
template <typename ValueType>
inline ValueType TRange<ValueType>::GetDistance(ValueType value) const
{
       if (value > m_maxValue){
              return value - m_maxValue;
       }
 
       if (value < m_minValue){
              return m_minValue - value;
       }
 
       return 0;
}
 
 
template <typename ValueType>
inline ValueType TRange<ValueType>::GetNearestInside(ValueType value) const
{
       if (value > m_maxValue){
              value = m_maxValue;
       }
 
       if (value < m_minValue){
              value = m_minValue;
       }
 
       return value;
}
 
 
template <typename ValueType>
ValueType TRange<ValueType>::GetClipped(ValueType value) const
{
       if (!Contains(value)){
              ValueType distanceMin = (ValueType)qAbs(value - m_minValue);
              ValueType distanceMax = (ValueType)qAbs(value - m_maxValue);
 
              return distanceMin < distanceMax ? m_minValue : m_maxValue;
       }
 
       return value;
}
 
       
template <typename ValueType>
TRange<ValueType> TRange<ValueType>::GetClipped(const TRange& range) const
{
       istd::TRange<ValueType> clippedRange = range;
 
       if (!Contains(range.GetMinValue())){
              clippedRange.SetMinValue(m_minValue);
       }
       
       if (!Contains(range.GetMaxValue())){
              clippedRange.SetMaxValue(m_maxValue);
       }
 
       return clippedRange;
}
 
 
template <typename ValueType>
inline ValueType TRange<ValueType>::GetValueFromAlpha(double alpha) const
{
       return GetMinValue() + alpha * GetLength();
}
 
 
template <typename ValueType>
inline double TRange<ValueType>::GetAlphaFromValue(ValueType value) const
{
       auto length = static_cast<double>(GetLength());
       if (length)
              return static_cast<double>(value - GetMinValue()) / length;
       else
              return 0.0;
}
 
 
template <typename ValueType>
inline ValueType TRange<ValueType>::GetMappedTo(ValueType value, const TRange& range) const
{
       ValueType length = GetLength();
       if (length)
              return ValueType(range.GetMinValue() + (value - GetMinValue()) * (range.GetLength() / length));
       else
              return (ValueType) 0.0;
}
 
 
template <typename ValueType>
TRange<ValueType> TRange<ValueType>::GetApply(const TRange& range) const
{
       TRange result;
       result.m_minValue = GetValueFromAlpha(range.m_minValue);
       result.m_maxValue = GetValueFromAlpha(range.m_maxValue);
 
       return result;
}
 
 
template <typename ValueType>
TRange<ValueType> TRange<ValueType>::GetInvertApply(const TRange& range) const
{
       TRange result;
 
       double length = GetLength();
       if (length)
       {
              result.m_minValue = ValueType((range.m_minValue - m_minValue) / length);
              result.m_maxValue = ValueType((range.m_maxValue - m_minValue) / length);
       }
       else
       {
              result.m_minValue = result.m_maxValue = 0.0;
       }
 
       return result;
}
 
 
template <typename ValueType>
TRange<ValueType> TRange<ValueType>::GetInverted() const
{
       TRange result;
 
       ValueType minusWidth = m_minValue - m_maxValue;
       if (minusWidth)
       {
              result.m_minValue = ValueType(m_minValue / (double)minusWidth);
              result.m_maxValue = ValueType((m_minValue - 1) / (double)minusWidth);
       }
       else
       {
              result.m_minValue = result.m_maxValue = 0.0;
       }
 
       return result;
}
 
 
template <typename ValueType>
void TRange<ValueType>::SetInterpolated(const TRange& first, const TRange& second, double alpha)
{
       double beta = 1 - alpha;
 
       m_minValue = ValueType(first.m_minValue * beta + second.m_minValue * alpha);
       m_maxValue = ValueType(first.m_maxValue * beta + second.m_maxValue * alpha);
}
 
 
template <typename ValueType>
inline bool TRange<ValueType>::operator==(const TRange& range) const
{
       return (m_maxValue == range.m_maxValue) && (m_minValue == range.m_minValue);
}
 
 
template <typename ValueType>
inline bool TRange<ValueType>::operator!=(const TRange& range) const
{
       return (m_maxValue != range.m_maxValue) || (m_minValue != range.m_minValue);
}
 
 
 
template <typename ValueType>
inline TRange<ValueType>& TRange<ValueType>::operator=(const TRange& range)
{
       m_maxValue = range.m_maxValue;
       m_minValue = range.m_minValue;
 
       return *this;
}
 
 
template <typename ValueType>
inline TRange<ValueType> TRange<ValueType>::operator*(double value) const
{
       TRange result = *this;
 
       result.m_minValue *= value;
       result.m_maxValue *= value;
 
       return result;
}
 
 
template <typename ValueType>
inline TRange<ValueType> TRange<ValueType>::operator/(double value) const
{
       TRange result = *this;
 
       if (value)
       {
              result.m_minValue /= value;
              result.m_maxValue /= value;
       }
       else
       {
              result.m_minValue = result.m_maxValue = 0.0;
       }
 
       return result;
}
 
 
template <typename ValueType>
inline TRange<ValueType>& TRange<ValueType>::operator*=(double value)
{
       m_minValue *= value;
       m_maxValue *= value;
 
       return *this;
}
 
 
template <typename ValueType>
inline TRange<ValueType>& TRange<ValueType>::operator/=(double value)
{
       if (value)
       {
              m_minValue /= value;
              m_maxValue /= value;
       }
       else
       {
              m_minValue = m_maxValue = 0.0;
       }
 
       return *this;
}
 
 
// static methods
 
template <typename ValueType>
inline TRange<ValueType> TRange<ValueType>::GetValid(ValueType value1, ValueType value2)
{
       return TRange(std::min<ValueType>(value1, value2), std::max<ValueType>(value1, value2));
}
 
 
// static methods
 
template <typename ValueType>
inline const TRange<ValueType>& TRange<ValueType>::GetNull()
{
       static const TRange<ValueType> s_null(0, 0);
       return s_null;
}
 
 
template <typename ValueType>
inline const TRange<ValueType>& TRange<ValueType>::GetInvalid()
{
       static const TRange<ValueType> s_invalid(0, -1);
       return s_invalid;
}
 
 
// typedefs
 
typedef istd::TRange<double> CRange;
typedef istd::TRange<int> CIntRange;
 
 
} // namespace istd