itkVariableLengthVector.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkVariableLengthVector_h
#define itkVariableLengthVector_h
 
#include <cassert>
#include <algorithm>
#include "itkNumericTraits.h"
#include "itkStaticAssert.h"
#include "itkMetaProgrammingLibrary.h"
#include "itkEnableIf.h"
#include "itkIsBaseOf.h"
#include "itkIsNumber.h"
#include "itkPromoteType.h"
#include "itkBinaryOperationConcept.h"
 
namespace itk
{
 
template <typename TExpr1, typename TExpr2, typename TBinaryOp>
struct VariableLengthVectorExpression;
 
template <typename TValue>
class ITK_TEMPLATE_EXPORT VariableLengthVector
{
public:
 
  struct AllocateRootPolicy
  {};
 
  struct AlwaysReallocate : AllocateRootPolicy
  {
    bool
    operator()(unsigned int itkNotUsed(newSize), unsigned int itkNotUsed(oldSize)) const
    {
      return true;
    }
  };
 
  struct NeverReallocate : AllocateRootPolicy
  {
    bool
    operator()(unsigned int newSize, unsigned int oldSize) const
    {
      (void)newSize;
      (void)oldSize;
      itkAssertInDebugAndIgnoreInReleaseMacro(newSize == oldSize &&
                                              "SetSize is expected to never change the VariableLengthVector size...");
      return true;
    }
  };
 
  struct ShrinkToFit : AllocateRootPolicy
  {
    bool
    operator()(unsigned int newSize, unsigned int oldSize) const
    {
      return newSize != oldSize;
    }
  };
 
  struct DontShrinkToFit : AllocateRootPolicy
  {
    bool
    operator()(unsigned int newSize, unsigned int oldSize) const
    {
      return newSize > oldSize;
    }
  };
 
  struct KeepValuesRootPolicy
  {};
 
  struct KeepOldValues : KeepValuesRootPolicy
  {
    template <typename TValue2>
    void
    operator()(unsigned int newSize, unsigned int oldSize, TValue2 * oldBuffer, TValue2 * newBuffer) const
    {
      itkAssertInDebugAndIgnoreInReleaseMacro(newBuffer);
      const std::size_t nb = std::min(newSize, oldSize);
      itkAssertInDebugAndIgnoreInReleaseMacro(nb == 0 || (nb > 0 && oldBuffer != nullptr));
      std::copy_n(oldBuffer, nb, newBuffer);
    }
  };
 
  struct DumpOldValues : KeepValuesRootPolicy
  {
    template <typename TValue2>
    void
    operator()(unsigned int itkNotUsed(newSize),
               unsigned int itkNotUsed(oldSize),
               TValue2 *    itkNotUsed(oldBuffer),
               TValue2 *    itkNotUsed(newBuffer)) const
    {}
  };
 
 
 
  using ValueType = TValue;
  using ComponentType = TValue;
  using RealValueType = typename NumericTraits<ValueType>::RealType;
  using Self = VariableLengthVector;
 
  using ElementIdentifier = unsigned int;
 
  VariableLengthVector();
 
  explicit VariableLengthVector(unsigned int length);
 
  VariableLengthVector(ValueType * datain, unsigned int sz, bool LetArrayManageMemory = false);
 
  VariableLengthVector(const ValueType * datain, unsigned int sz, bool LetArrayManageMemory = false);
 
  template <typename T>
  VariableLengthVector(const VariableLengthVector<T> & v)
  {
    m_NumElements = v.Size();
    m_LetArrayManageMemory = true;
    if (m_NumElements != 0)
    {
      m_Data = this->AllocateElements(m_NumElements);
      itkAssertInDebugAndIgnoreInReleaseMacro(m_Data != nullptr);
      for (ElementIdentifier i = 0; i < m_NumElements; ++i)
      {
        this->m_Data[i] = static_cast<ValueType>(v[i]);
      }
    }
    else
    {
      m_Data = nullptr;
    }
  }
 
  VariableLengthVector(const VariableLengthVector<TValue> & v);
 
  void
  Swap(Self & v) noexcept
  {
    itkAssertInDebugAndIgnoreInReleaseMacro(m_LetArrayManageMemory == v.m_LetArrayManageMemory);
    using std::swap;
    swap(v.m_Data, m_Data);
    swap(v.m_NumElements, m_NumElements);
  }
 
  VariableLengthVector(Self && v) noexcept;
 
  Self &
  operator=(Self && v) noexcept;
 
  template <typename TExpr1, typename TExpr2, typename TBinaryOp>
  VariableLengthVector(VariableLengthVectorExpression<TExpr1, TExpr2, TBinaryOp> const & rhs);
 
  template <typename TExpr1, typename TExpr2, typename TBinaryOp>
  Self &
  operator=(VariableLengthVectorExpression<TExpr1, TExpr2, TBinaryOp> const & rhs);
 
  void
  Fill(TValue const & v);
 
  template <typename T>
  Self &
  operator=(const VariableLengthVector<T> & v)
  {
    // No self assignment test is done. Indeed:
    // - the operator already resists self assignment through a strong exception
    // guarantee
    // - the test becomes a pessimization as we never write
    //    VLV<const TValue> vcref(v.GetDataPointer(), v.GetSize());
    //    ...;
    //    v = vcref;
    ElementIdentifier const N = v.Size();
    this->SetSize(N, DontShrinkToFit(), DumpOldValues());
    for (ElementIdentifier i = 0; i < N; ++i)
    {
      this->m_Data[i] = static_cast<ValueType>(v[i]);
    }
    return *this;
  }
 
  Self &
  operator=(const Self & v);
 
  Self &
  FastAssign(const Self & v);
 
  Self &
  operator=(TValue const & v);
 
  unsigned int
  Size() const
  {
    return m_NumElements;
  }
  unsigned int
  GetSize() const
  {
    return m_NumElements;
  }
  unsigned int
  GetNumberOfElements() const
  {
    return m_NumElements;
  }
 
  TValue & operator[](unsigned int i) { return this->m_Data[i]; }
 
  TValue const & operator[](unsigned int i) const { return this->m_Data[i]; }
 
  const TValue &
  GetElement(unsigned int i) const
  {
    return m_Data[i];
  }
 
  void
  SetElement(unsigned int i, const TValue & value)
  {
    m_Data[i] = value;
  }
 
  template <typename TReallocatePolicy, typename TKeepValuesPolicy>
  void
  SetSize(unsigned int sz, TReallocatePolicy reallocatePolicy, TKeepValuesPolicy keepValues);
 
  void
  SetSize(unsigned int sz, bool destroyExistingData = true)
  {
    // Stays compatible with previous code version
    // And works around the fact C++03 template functions can't have default
    // arguments on template types.
    if (destroyExistingData)
    {
      SetSize(sz, AlwaysReallocate(), KeepOldValues());
    }
    else
    {
      SetSize(sz, ShrinkToFit(), KeepOldValues());
    }
  }
 
  void
  DestroyExistingData();
 
  void
  SetData(TValue * datain, bool LetArrayManageMemory = false);
 
  void
  SetData(TValue * datain, unsigned int sz, bool LetArrayManageMemory = false);
 
  ~VariableLengthVector();
 
  void
  Reserve(ElementIdentifier size);
 
  TValue *
  AllocateElements(ElementIdentifier size) const;
 
  const TValue *
  GetDataPointer() const
  {
    return m_Data;
  }
 
  Self &
  operator--()
  {
    for (ElementIdentifier i = 0; i < m_NumElements; i++)
    {
      this->m_Data[i] -= static_cast<ValueType>(1.0);
    }
    return *this;
  }
 
  Self &
  operator++() // prefix operator ++v;
  {
    for (ElementIdentifier i = 0; i < m_NumElements; i++)
    {
      this->m_Data[i] += static_cast<ValueType>(1.0);
    }
    return *this;
  }
 
  Self
  operator--(int) // postfix operator v--;
  {
    Self tmp(*this);
 
    --tmp;
    return tmp;
  }
 
  Self
  operator++(int) // postfix operator v++;
  {
    Self tmp(*this);
 
    ++tmp;
    return tmp;
  }
 
  template <typename T>
  Self &
  operator-=(const VariableLengthVector<T> & v)
  {
    itkAssertInDebugAndIgnoreInReleaseMacro(m_NumElements == v.GetSize());
    for (ElementIdentifier i = 0; i < m_NumElements; i++)
    {
      m_Data[i] -= static_cast<ValueType>(v[i]);
    }
    return *this;
  }
 
  Self &
  operator-=(TValue s)
  {
    for (ElementIdentifier i = 0; i < m_NumElements; i++)
    {
      m_Data[i] -= s;
    }
    return *this;
  }
 
  template <typename T>
  Self &
  operator+=(const VariableLengthVector<T> & v)
  {
    itkAssertInDebugAndIgnoreInReleaseMacro(m_NumElements == v.GetSize());
    for (ElementIdentifier i = 0; i < m_NumElements; i++)
    {
      m_Data[i] += static_cast<ValueType>(v[i]);
    }
    return *this;
  }
 
  Self &
  operator+=(TValue s)
  {
    for (ElementIdentifier i = 0; i < m_NumElements; i++)
    {
      m_Data[i] += s;
    }
    return *this;
  }
 
  template <typename TExpr1, typename TExpr2, typename TBinaryOp>
  Self &
  operator+=(VariableLengthVectorExpression<TExpr1, TExpr2, TBinaryOp> const & rhs)
  {
    itkAssertInDebugAndIgnoreInReleaseMacro(rhs.Size() == Size());
    for (ElementIdentifier i = 0; i < m_NumElements; ++i)
    {
      m_Data[i] += static_cast<ValueType>(rhs[i]);
    }
    return *this;
  }
 
  template <typename TExpr1, typename TExpr2, typename TBinaryOp>
  Self &
  operator-=(VariableLengthVectorExpression<TExpr1, TExpr2, TBinaryOp> const & rhs)
  {
    itkAssertInDebugAndIgnoreInReleaseMacro(rhs.Size() == Size());
    for (ElementIdentifier i = 0; i < m_NumElements; ++i)
    {
      m_Data[i] -= static_cast<ValueType>(rhs[i]);
    }
    return *this;
  }
 
  template <typename T>
  Self &
  operator*=(T s)
  {
    const ValueType & sc = static_cast<ValueType>(s);
    for (ElementIdentifier i = 0; i < m_NumElements; i++)
    {
      m_Data[i] *= sc;
    }
    return *this;
  }
 
  Self &
  operator*=(TValue s)
  {
    for (ElementIdentifier i = 0; i < m_NumElements; i++)
    {
      m_Data[i] *= s;
    }
    return *this;
  }
 
  template <typename T>
  Self &
  operator/=(T s)
  {
    const RealValueType sc = s;
    for (ElementIdentifier i = 0; i < m_NumElements; i++)
    {
      m_Data[i] = static_cast<ValueType>(static_cast<RealValueType>(m_Data[i]) / sc);
    }
    return *this;
  }
 
  Self &
  operator-(); // negation operator
 
  bool
  operator==(const Self & v) const;
 
  bool
  operator!=(const Self & v) const;
 
  RealValueType
  GetNorm() const;
 
  RealValueType
  GetSquaredNorm() const;
 
  bool
  IsAProxy() const
  {
    return !m_LetArrayManageMemory;
  }
 
private:
  bool m_LetArrayManageMemory{ true }; // if true, the array is responsible
                                       // for memory of data
  TValue *          m_Data;            // Array to hold data
  ElementIdentifier m_NumElements{ 0 };
};
 
namespace mpl
{
template <typename T>
struct IsArray : FalseType
{};
 
template <typename T>
struct IsArray<itk::VariableLengthVector<T>> : TrueType
{};
 
template <typename TExpr1, typename TExpr2, typename TBinaryOp>
struct IsArray<VariableLengthVectorExpression<TExpr1, TExpr2, TBinaryOp>> : TrueType
{};
} // namespace mpl
 
namespace Details
{
 
template <typename TExpr>
struct GetType
{
  using Type = TExpr;
 
  static Type
  Load(Type const & v, unsigned int idx)
  {
    (void)idx;
    return v;
  }
};
 
template <typename TExpr1, typename TExpr2>
inline typename mpl::EnableIf<mpl::And<mpl::IsArray<TExpr1>, mpl::IsArray<TExpr2>>, unsigned int>::Type
GetSize(TExpr1 const & lhs, TExpr2 const & rhs)
{
  (void)rhs;
  itkAssertInDebugAndIgnoreInReleaseMacro(lhs.Size() == rhs.Size());
  return lhs.Size();
}
 
 
template <typename TExpr1, typename TExpr2>
inline typename mpl::EnableIf<mpl::And<mpl::IsArray<TExpr1>, mpl::Not<mpl::IsArray<TExpr2>>>, unsigned int>::Type
GetSize(TExpr1 const & lhs, TExpr2 const & itkNotUsed(rhs))
{
  return lhs.Size();
}
 
template <typename TExpr1, typename TExpr2>
inline typename mpl::EnableIf<mpl::And<mpl::IsArray<TExpr2>, mpl::Not<mpl::IsArray<TExpr1>>>, unsigned int>::Type
GetSize(TExpr1 const & itkNotUsed(lhs), TExpr2 const & rhs)
{
  return rhs.Size();
}
 
template <typename T>
struct GetType<VariableLengthVector<T>>
{
  using Type = T;
  static Type
  Load(VariableLengthVector<T> const & v, unsigned int idx)
  {
    return v[idx];
  }
};
template <typename TExpr1, typename TExpr2, typename TBinaryOp>
struct GetType<VariableLengthVectorExpression<TExpr1, TExpr2, TBinaryOp>>
{
  using Type = typename VariableLengthVectorExpression<TExpr1, TExpr2, TBinaryOp>::ResType;
  static Type
  Load(VariableLengthVectorExpression<TExpr1, TExpr2, TBinaryOp> const & v, unsigned int idx)
  {
    return v[idx];
  }
};
 
namespace op
{
template <typename TExpr1, typename TExpr2>
struct CanBeAddedOrSubtracted
  : mpl::Or<mpl::And<mpl::IsArray<TExpr1>, mpl::IsArray<TExpr2>>,
            mpl::And<mpl::IsArray<TExpr1>, mpl::IsNumber<TExpr2>>,
            mpl::And<mpl::IsNumber<TExpr1>, mpl::IsArray<TExpr2>>>
{};
 
template <typename TExpr1, typename TExpr2>
struct CanBeMultiplied
  : mpl::Or<mpl::And<mpl::IsArray<TExpr1>, mpl::IsNumber<TExpr2>>,
            mpl::And<mpl::IsNumber<TExpr1>, mpl::IsArray<TExpr2>>>
{};
 
template <typename TExpr1, typename TExpr2>
struct CanBeDivided : mpl::And<mpl::IsArray<TExpr1>, mpl::IsNumber<TExpr2>>
{};
 
} // namespace op
} // namespace Details
 
template <typename TExpr1, typename TExpr2, typename TBinaryOp>
struct VariableLengthVectorExpression
{
  VariableLengthVectorExpression(TExpr1 const & lhs, TExpr2 const & rhs)
    : m_lhs(lhs)
    , m_rhs(rhs)
  {
    // Not neccessary actually as end-user/developer is not expected to
    // provide new BinaryOperations
    itkStaticAssert((itk::mpl::IsBaseOf<Details::op::BinaryOperationConcept, TBinaryOp>::Value),
                    "The Binary Operation shall inherit from BinaryOperationConcept");
  }
 
  unsigned int
  Size() const
  {
    return Details::GetSize(m_lhs, m_rhs);
  }
 
  using ResType =
    typename mpl::PromoteType<typename Details::GetType<TExpr1>::Type, typename Details::GetType<TExpr2>::Type>::Type;
  using RealValueType = typename NumericTraits<ResType>::RealType;
 
  ResType operator[](unsigned int idx) const
  {
    itkAssertInDebugAndIgnoreInReleaseMacro(idx < Size());
    return TBinaryOp::Apply(Details::GetType<TExpr1>::Load(m_lhs, idx), Details::GetType<TExpr2>::Load(m_rhs, idx));
  }
 
  RealValueType
  GetNorm() const;
 
  RealValueType
  GetSquaredNorm() const;
 
private:
  TExpr1 const & m_lhs;
  TExpr2 const & m_rhs;
};
 
template <typename TExpr1, typename TExpr2>
inline typename mpl::EnableIf<Details::op::CanBeAddedOrSubtracted<TExpr1, TExpr2>,
                              VariableLengthVectorExpression<TExpr1, TExpr2, Details::op::Plus>>::Type
operator+(TExpr1 const & lhs, TExpr2 const & rhs)
{
  return VariableLengthVectorExpression<TExpr1, TExpr2, Details::op::Plus>(lhs, rhs);
}
 
template <typename TExpr1, typename TExpr2>
inline typename mpl::EnableIf<Details::op::CanBeAddedOrSubtracted<TExpr1, TExpr2>,
                              VariableLengthVectorExpression<TExpr1, TExpr2, Details::op::Sub>>::Type
operator-(TExpr1 const & lhs, TExpr2 const & rhs)
{
  return VariableLengthVectorExpression<TExpr1, TExpr2, Details::op::Sub>(lhs, rhs);
}
 
template <typename TExpr1, typename TExpr2>
inline typename mpl::EnableIf<Details::op::CanBeMultiplied<TExpr1, TExpr2>,
                              VariableLengthVectorExpression<TExpr1, TExpr2, Details::op::Mult>>::Type
operator*(TExpr1 const & lhs, TExpr2 const & rhs)
{
  return VariableLengthVectorExpression<TExpr1, TExpr2, Details::op::Mult>(lhs, rhs);
}
 
template <typename TExpr1, typename TExpr2>
inline typename mpl::EnableIf<Details::op::CanBeDivided<TExpr1, TExpr2>,
                              VariableLengthVectorExpression<TExpr1, TExpr2, Details::op::Div>>::Type
operator/(TExpr1 const & lhs, TExpr2 const & rhs)
{
  return VariableLengthVectorExpression<TExpr1, TExpr2, Details::op::Div>(lhs, rhs);
}
 
template <typename TExpr1, typename TExpr2, typename TBinaryOp>
std::ostream &
operator<<(std::ostream & os, VariableLengthVectorExpression<TExpr1, TExpr2, TBinaryOp> const & v)
{
  os << "[";
  if (v.Size() != 0)
  {
    os << v[0];
    for (unsigned int i = 1, N = v.Size(); i != N; ++i)
    {
      os << ", " << v[i];
    }
  }
  return os << "]";
}
 
template <typename TExpr>
inline typename mpl::EnableIf<mpl::IsArray<TExpr>, typename TExpr::RealValueType>::Type
GetNorm(TExpr const & v)
{
  return static_cast<typename TExpr::RealValueType>(std::sqrt(static_cast<double>(GetSquaredNorm(v))));
}
 
template <typename TExpr>
inline typename mpl::EnableIf<mpl::IsArray<TExpr>, typename TExpr::RealValueType>::Type
GetSquaredNorm(TExpr const & v)
{
  using RealValueType = typename TExpr::RealValueType;
  RealValueType sum = 0.0;
  for (unsigned int i = 0, N = v.Size(); i < N; ++i)
  {
    const RealValueType value = v[i];
    sum += value * value;
  }
  return sum;
}
 
 
template <typename TValue>
std::ostream &
operator<<(std::ostream & os, const VariableLengthVector<TValue> & arr)
{
  const unsigned int length = arr.Size();
  const signed int   last = (unsigned int)length - 1;
 
  os << "[";
  for (signed int i = 0; i < last; ++i)
  {
    os << arr[i] << ", ";
  }
  if (length >= 1)
  {
    os << arr[last];
  }
  os << "]";
  return os;
}
 
 
template <typename T>
inline void
swap(VariableLengthVector<T> & l_, VariableLengthVector<T> & r_) noexcept
{
  l_.Swap(r_);
}
 
 
} // namespace itk
 
#include "itkNumericTraitsVariableLengthVectorPixel.h"
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkVariableLengthVector.hxx"
#endif
 
#endif