TFulcrumGrid.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/QObject>
#include <QtCore/QtAlgorithms>
#include <QtCore/QVector>
 
// ACF includes
#include <istd/CChangeNotifier.h>
#include <iser/ISerializable.h>
#include <iser/CArchiveTag.h>
 
 
namespace imath
{
 
 
template <class Position, class Fulcrums>
class TFulcrumGrid: virtual public iser::ISerializable
{
public:
       typedef typename Fulcrums::ElementType FulcrumType;
       typedef typename Fulcrums::IndexType FulcrumIndex;
       typedef typename Fulcrums::SizesType FulcrumSizes;
       typedef Position PositionType;
 
       enum ChangeFlags
       {
              CF_SORT_LAYERS = 0x8352707
       };
 
       TFulcrumGrid();
 
       void Reset();
 
       FulcrumSizes GetGridSize() const;
 
       int GetDimensionsCount() const;
 
       virtual bool SetDimensionsCount(int count);
 
       int GetLayersCount(int dimension) const;
 
       virtual void SetLayersCount(int dimension, int count);
 
       double GetLayerPosition(int dimension, int layerIndex) const;
 
       virtual void SetLayerPosition(int dimension, int layerIndex, double position);
 
       void GetFulcrumPosition(const FulcrumIndex& index, PositionType& result) const;
 
       const FulcrumType& GetFulcrumAtIndex(const FulcrumIndex& index) const;
 
       virtual void SetFulcrumAtIndex(const FulcrumIndex& index, const FulcrumType& value);
 
       int InsertLayer(int dimension, double position);
 
       virtual void RemoveLayer(int dimension, int layerIndex);
 
       // reimplemented (iser::ISerializable)
       virtual bool Serialize(iser::IArchive& archive) override;
 
       // operators
       bool operator==(const TFulcrumGrid<Position, Fulcrums>& value) const;
       bool operator!=(const TFulcrumGrid<Position, Fulcrums>& value) const;
 
protected:
       virtual void SortFulcrums();
 
       int FindLayerIndex(int dimension, double value) const;
       typename Fulcrums::IndexType FindIndices(const PositionType& argument) const;
 
protected:
       static const ChangeSet s_fulcrumPositionChange;
 
private:
       Fulcrums m_fulcrums;
 
       typedef QVector<double> LayerPositions;
       typedef QVector<LayerPositions> Layers;
 
       Layers m_layers;
};
 
 
 
// inline methods
 
template <class Position, class Fulcrums>
inline typename TFulcrumGrid<Position, Fulcrums>::FulcrumSizes
                     TFulcrumGrid<Position, Fulcrums>::GetGridSize() const
{
       return m_fulcrums.GetSizes();
}
 
 
template <class Position, class Fulcrums>
inline int TFulcrumGrid<Position, Fulcrums>::GetDimensionsCount() const
{
       return m_fulcrums.GetDimensionsCount();
}
 
 
template <class Position, class Fulcrums>
inline int TFulcrumGrid<Position, Fulcrums>::GetLayersCount(int dimension) const
{
       Q_ASSERT(dimension >= 0);
       Q_ASSERT(dimension < int(m_layers.size()));
 
       return m_layers[dimension].size();
}
 
 
template <class Position, class Fulcrums>
inline double TFulcrumGrid<Position, Fulcrums>::GetLayerPosition(int dimension, int layerIndex) const
{
       Q_ASSERT(dimension >= 0);
       Q_ASSERT(dimension < int(m_layers.size()));
 
       const LayerPositions& positions = m_layers[dimension];
 
       Q_ASSERT(layerIndex >= 0);
       Q_ASSERT(layerIndex < int(positions.size()));
 
       return positions[layerIndex];
}
 
 
// public methods
 
template <class Position, class Fulcrums>
TFulcrumGrid<Position, Fulcrums>::TFulcrumGrid()
{
       m_layers.resize(m_fulcrums.GetDimensionsCount());
}
 
 
template <class Position, class Fulcrums>
void TFulcrumGrid<Position, Fulcrums>::Reset()
{
       m_fulcrums.Reset();
 
       for (Layers::iterator iter = m_layers.begin(); iter != m_layers.end(); ++iter){
              iter->clear();
       }
 
       m_layers.resize(m_fulcrums.GetDimensionsCount());
}
 
 
template <class Position, class Fulcrums>
bool TFulcrumGrid<Position, Fulcrums>::SetDimensionsCount(int count)
{
       if (m_fulcrums.SetDimensionsCount(count)){
              m_layers.resize(count);
 
              return true;
       }
 
       return false;
}
 
 
template <class Position, class Fulcrums>
void TFulcrumGrid<Position, Fulcrums>::SetLayersCount(int dimension, int count)
{
       Q_ASSERT(dimension >= 0);
       Q_ASSERT(dimension < int(m_layers.size()));
 
       m_layers[dimension].resize(count);
       m_fulcrums.SetSize(dimension, count);
}
 
 
template <class Position, class Fulcrums>
void TFulcrumGrid<Position, Fulcrums>::SetLayerPosition(int dimension, int layerIndex, double position)
{
       Q_ASSERT(dimension >= 0);
       Q_ASSERT(dimension < int(m_layers.size()));
 
       LayerPositions& positions = m_layers[dimension];
 
       Q_ASSERT(layerIndex >= 0);
       Q_ASSERT(layerIndex < int(positions.size()));
 
       istd::CChangeNotifier notifier(this, &s_fulcrumPositionChange);
       Q_UNUSED(notifier);
 
       positions[layerIndex] = position;
}
 
 
template <class Position, class Fulcrums>
void TFulcrumGrid<Position, Fulcrums>::GetFulcrumPosition(const FulcrumIndex& index, PositionType& result) const
{
       int layersCount = int(m_layers.size());
       Q_ASSERT(layersCount <= index.GetDimensionsCount());
 
       result.SetElementsCount(layersCount);
 
       for (int i = 0; i < layersCount; ++i){
              const LayerPositions& positions = m_layers[i];
 
              Q_ASSERT(index[i] >= 0);
              Q_ASSERT(index[i] < int(positions.size()));
 
              result[i] = positions[index[i]];
       }
}
 
 
template <class Position, class Fulcrums>
const typename TFulcrumGrid<Position, Fulcrums>::FulcrumType&
                     TFulcrumGrid<Position, Fulcrums>::GetFulcrumAtIndex(const FulcrumIndex& index) const
{
       return m_fulcrums.GetAt(index);
}
 
 
template <class Position, class Fulcrums>
void TFulcrumGrid<Position, Fulcrums>::SetFulcrumAtIndex(const FulcrumIndex& index, const FulcrumType& value)
{
       istd::CChangeNotifier notifier(this);
 
       m_fulcrums.SetAt(index, value);
}
 
 
template <class Position, class Fulcrums>
int TFulcrumGrid<Position, Fulcrums>::InsertLayer(int dimension, double position)
{
       Q_ASSERT(dimension >= 0);
       Q_ASSERT(dimension < m_fulcrums.GetDimensionsCount());
 
       Fulcrums newFulcrums = m_fulcrums;
 
       newFulcrums.SetSize(dimension, m_fulcrums.GetSize(dimension) + 1);
 
       int layerIndex = FindLayerIndex(dimension, position);
 
       LayerPositions& positions = m_layers[dimension];
 
       double prevPosition = position;
       double nextPosition = position;
       if (!positions.isEmpty()){
              if (layerIndex >= 0){
                     prevPosition = positions[layerIndex];
              }
              if (layerIndex < GetLayersCount(dimension) - 1){
                     nextPosition = positions[layerIndex + 1];
              }
       }
       Q_ASSERT(position >= prevPosition);
       Q_ASSERT(position <= nextPosition);
 
       double prevFactor = 0.5;
       if (nextPosition - prevPosition > I_BIG_EPSILON){
              prevFactor = (position - prevPosition) / (nextPosition - prevPosition);
 
              Q_ASSERT(prevFactor >= 0);
              Q_ASSERT(prevFactor - I_EPSILON <= 1.0);
       }
       double nextFactor = 1 - prevFactor;
 
       int oldLayersCount = int(positions.size());
       Q_ASSERT(oldLayersCount == m_fulcrums.GetSize(dimension));
 
       for (         typename Fulcrums::Iterator destIter = newFulcrums.Begin();
                            destIter != newFulcrums.End();
                            ++destIter){
              PositionType sourceIndex = destIter;
              if ((destIter[dimension] >= layerIndex) && (sourceIndex[dimension] > 0)){
                     sourceIndex[dimension]--;
 
                     if ((destIter[dimension] == layerIndex) && (layerIndex < oldLayersCount)){
                            PositionType prevFulcrumPosition;
                            GetFulcrumPosition(sourceIndex, prevFulcrumPosition);
 
                            PositionType nextFulcrumPosition;
                            GetFulcrumPosition(destIter, nextFulcrumPosition);
 
                            PositionType position = prevFactor * prevFulcrumPosition + nextFactor * nextFulcrumPosition;
 
                            newFulcrums[destIter] = GetValueAt(position);
 
                            continue;
                     }
              }
 
              *destIter = m_fulcrums[sourceIndex];
       }
 
       positions.insert(positions.begin() + layerIndex + 1, position);
       m_fulcrums = newFulcrums;
       
       return layerIndex;
}
 
 
template <class Position, class Fulcrums>
void TFulcrumGrid<Position, Fulcrums>::RemoveLayer(int dimension, int layerIndex)
{
       Q_ASSERT(dimension >= 0);
       Q_ASSERT(dimension < GetDimensionsCount());
       Q_ASSERT(m_fulcrums.GetSize(dimension) > 0);
 
       Fulcrums newFulcrums = m_fulcrums;
 
       newFulcrums.SetSize(dimension, m_fulcrums.GetSize(dimension) + 1);
 
       LayerPositions& positions = m_layers[dimension];
 
       for (         typename Fulcrums::Iterator destIter = newFulcrums.Begin();
                            destIter != newFulcrums.End();
                            ++destIter){
              FulcrumIndex sourceIndex = destIter;
              if (destIter[dimension] >= layerIndex){
                     sourceIndex.IncreaseAt(dimension);
              }
 
              *destIter = m_fulcrums[sourceIndex];
       }
 
       positions.erase(positions.begin() + layerIndex);
       m_fulcrums = newFulcrums;
}
 
 
// reimplemented (iser::ISerializable)
 
template <class Position, class Fulcrums>
bool TFulcrumGrid<Position, Fulcrums>::Serialize(iser::IArchive& archive)
{
       bool retVal = true;
 
       iser::CArchiveTag gridTag("Grid", "Description of fulcrums grid", iser::CArchiveTag::TT_MULTIPLE);
       iser::CArchiveTag positionsTag("Positions", "List of positions at single axis of fulcrum grid", iser::CArchiveTag::TT_MULTIPLE, &gridTag);
       iser::CArchiveTag positionTag("Position", "Single layer position", iser::CArchiveTag::TT_LEAF, &positionsTag);
       iser::CArchiveTag fulcrumsTag("Fulcrums", "List of fulcrums", iser::CArchiveTag::TT_GROUP);
       iser::CArchiveTag fulcrumTag("Fulcrum", "Single fulcrum", iser::CArchiveTag::TT_GROUP, &fulcrumsTag);
 
       bool isStoring = archive.IsStoring();
 
       istd::CChangeNotifier notifier(isStoring? NULL: this);
 
       int dimensionsCount = m_fulcrums.GetDimensionsCount();
       Q_ASSERT(dimensionsCount == int(m_layers.size()));
 
       retVal = retVal && archive.BeginMultiTag(gridTag, positionsTag, dimensionsCount);
 
       if (!isStoring && (dimensionsCount != m_fulcrums.GetDimensionsCount())){
              if (!SetDimensionsCount(dimensionsCount)){
                     return false;
              }
       }
 
       FulcrumSizes sizes = m_fulcrums.GetSizes();
       Q_ASSERT(sizes.GetDimensionsCount() >= dimensionsCount);
 
       for (int dimensionIndex = 0; dimensionIndex < dimensionsCount; ++dimensionIndex){
              LayerPositions& positions = m_layers[dimensionIndex];
 
              int& positionsCount = sizes[dimensionIndex];
              Q_ASSERT(positionsCount == int(positions.size()));
 
              retVal = retVal && archive.BeginMultiTag(positionsTag, positionTag, positionsCount);
 
              if (!isStoring){
                     if (!retVal){
                            Reset();
 
                            return false;
                     }
 
                     SetLayersCount(dimensionIndex, positionsCount);
              }
 
              for (int positionIndex = 0; positionIndex < positionsCount; ++positionIndex){
                     retVal = retVal && archive.BeginTag(positionTag);
                     retVal = retVal && archive.Process(positions[positionIndex]);
                     retVal = retVal && archive.EndTag(positionTag);
              }
 
              retVal = retVal && archive.EndTag(positionsTag);
       }
 
       retVal = retVal && archive.EndTag(gridTag);
 
       retVal = retVal && archive.BeginTag(fulcrumsTag);
 
       for (         typename Fulcrums::Iterator iter = m_fulcrums.Begin();
                            iter != m_fulcrums.End();
                            ++iter){
              FulcrumType& point = *iter;
 
              retVal = retVal && archive.BeginTag(fulcrumTag);
              retVal = retVal && point.Serialize(archive);
              retVal = retVal && archive.EndTag(fulcrumTag);
       }
 
       retVal = retVal && archive.EndTag(fulcrumsTag);
 
       return retVal;
}
 
 
// operators
 
template <class Position, class Fulcrums>
bool TFulcrumGrid<Position, Fulcrums>::operator==(const TFulcrumGrid<Position, Fulcrums>& value) const
{
       return (m_fulcrums == value.m_fulcrums) && (m_layers == value.m_layers);
}
 
 
template <class Position, class Fulcrums>
bool TFulcrumGrid<Position, Fulcrums>::operator!=(const TFulcrumGrid<Position, Fulcrums>& value) const
{
       return (m_fulcrums != value.m_fulcrums) || (m_layers != value.m_layers);
}
 
 
// protected methods
 
template <class Position, class Fulcrums>
void TFulcrumGrid<Position, Fulcrums>::SortFulcrums()
{
       for (Layers::iterator iter = m_layers.begin(); iter != m_layers.end(); ++iter){
              LayerPositions& positions = *iter;
 
              qSort(positions.begin(), positions.end());
       }
}
 
 
template <class Position, class Fulcrums>
int TFulcrumGrid<Position, Fulcrums>::FindLayerIndex(int dimension, double value) const
{
       Q_ASSERT(dimension >= 0);
       Q_ASSERT(dimension < GetDimensionsCount());
 
       const LayerPositions& positions = m_layers[dimension];
 
       int left = 0;
       int right = int(positions.size());
 
       while (left != right){
              int center = (left + right) / 2;
 
              if (value >= positions[center]){
                     left = center + 1;
              }
              else{
                     right = center;
              }
       }
 
       return left - 1;
}
 
 
template <class Position, class Fulcrums>
typename Fulcrums::IndexType
                     TFulcrumGrid<Position, Fulcrums>::FindIndices(const PositionType& argument) const
{
       int dimensionsCount = GetDimensionsCount();
 
       FulcrumIndex retVal(dimensionsCount);
 
       for (int i = 0; i < dimensionsCount; ++i){
              retVal[i] = FindLayerIndex(i, argument[i]);
       }
 
       return retVal;
}
 
 
// protected static members
 
template <class Position, class Fulcrums>
const istd::IChangeable::ChangeSet TFulcrumGrid<Position, Fulcrums>::s_fulcrumPositionChange(CF_SORT_LAYERS, QObject::tr("Change fulcrum position"));
 
 
} // namespace imath