mitkVector.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef mitkVector_h
#define mitkVector_h
 
#include <itkVector.h>
#include <vnl/vnl_vector.h>
#include <vnl/vnl_vector_fixed.h>
 
#include <mitkArray.h>
#include <mitkEqual.h>
#include <mitkExceptionMacro.h>
#include <mitkNumericConstants.h>
 
#include <nlohmann/json.hpp>
 
namespace mitk
{
  template <class TCoordRep, unsigned int NVectorDimension = 3>
  class Vector : public itk::Vector<TCoordRep, NVectorDimension>
  {
  public:
    explicit Vector<TCoordRep, NVectorDimension>() : itk::Vector<TCoordRep, NVectorDimension>() {}
    explicit Vector<TCoordRep, NVectorDimension>(const mitk::Vector<TCoordRep, NVectorDimension> &r)
      : itk::Vector<TCoordRep, NVectorDimension>(r)
    {
    }
 
    Vector<TCoordRep, NVectorDimension> & operator=(const Vector<TCoordRep, NVectorDimension> & r)
    {
      itk::Vector<TCoordRep, NVectorDimension>::operator=(r);
      return *this;
    }
 
    Vector<TCoordRep, NVectorDimension>(const itk::Vector<TCoordRep, NVectorDimension> &r)
      : itk::Vector<TCoordRep, NVectorDimension>(r)
    {
    }
 
    Vector<TCoordRep, NVectorDimension>(const TCoordRep r[NVectorDimension])
      : itk::Vector<TCoordRep, NVectorDimension>(r)
    {
    }
 
    Vector<TCoordRep, NVectorDimension>(const TCoordRep &v) : itk::Vector<TCoordRep, NVectorDimension>(v) {}
    Vector<TCoordRep, NVectorDimension>(const vnl_vector<TCoordRep> &vnlVector)
      : itk::Vector<TCoordRep, NVectorDimension>()
    {
      if (vnlVector.size() != NVectorDimension)
        mitkThrow() << "when constructing mitk::Vector from vnl_vector: sizes didn't match: mitk::Vector "
                    << NVectorDimension << "; vnl_vector " << vnlVector.size();
 
      for (unsigned int var = 0; (var < NVectorDimension) && (var < vnlVector.size()); ++var)
      {
        this->SetElement(var, vnlVector.get(var));
      }
    }
 
    Vector<TCoordRep, NVectorDimension>(const vnl_vector_fixed<TCoordRep, NVectorDimension> &vnlVectorFixed)
      : itk::Vector<TCoordRep, NVectorDimension>()
    {
      for (unsigned int var = 0; var < NVectorDimension; ++var)
      {
        this->SetElement(var, vnlVectorFixed[var]);
      }
    };
 
    template <typename ArrayType>
    void FillVector(const ArrayType &array)
    {
      itk::FixedArray<TCoordRep, NVectorDimension> *thisP =
        dynamic_cast<itk::FixedArray<TCoordRep, NVectorDimension> *>(this);
      mitk::FillArray<ArrayType, TCoordRep, NVectorDimension>(*thisP, array);
    }
 
    template <typename ArrayType>
    void ToArray(ArrayType array) const
    {
      mitk::ToArray<ArrayType, TCoordRep, NVectorDimension>(array, *this);
    }
 
    operator vnl_vector<TCoordRep>() const { return this->GetVnlVector(); }
  }; // end mitk::Vector
 
  template <class TCoordRep, unsigned int NVectorDimension>
  void to_json(nlohmann::json &j, const Vector<TCoordRep, NVectorDimension> &v)
  {
    j = nlohmann::json::array();
 
    for (size_t i = 0; i < NVectorDimension; ++i)
      j.push_back(v[i]);
  }
 
  template <class TCoordRep, unsigned int NVectorDimension>
  void from_json(const nlohmann::json &j, Vector<TCoordRep, NVectorDimension> &v)
  {
    for (size_t i = 0; i < NVectorDimension; ++i)
      j.at(i).get_to(v[i]);
  }
 
  // convenience typedefs for often used mitk::Vector representations.
 
  typedef Vector<ScalarType, 2> Vector2D;
  typedef Vector<ScalarType, 3> Vector3D;
  typedef Vector<ScalarType, 4> Vector4D;
 
  // other vector types used in MITK
  typedef vnl_vector<ScalarType> VnlVector;
 
  // The equal methods to compare vectors for equality are below:
 
  template <typename TCoordRep, unsigned int NPointDimension>
  inline bool Equal(const itk::Vector<TCoordRep, NPointDimension> &vector1,
                    const itk::Vector<TCoordRep, NPointDimension> &vector2,
                    TCoordRep eps = mitk::eps,
                    bool verbose = false)
  {
    bool isEqual = true;
    typename itk::Vector<TCoordRep, NPointDimension>::VectorType diff = vector1 - vector2;
    for (unsigned int i = 0; i < NPointDimension; i++)
    {
      if (DifferenceBiggerOrEqualEps(diff[i], eps))
      {
        isEqual = false;
        break;
      }
    }
 
    ConditionalOutputOfDifference(vector1, vector2, eps, verbose, isEqual);
 
    return isEqual;
  }
 
  inline bool Equal(const mitk::VnlVector &vector1,
                    const mitk::VnlVector &vector2,
                    ScalarType eps = mitk::eps,
                    bool verbose = false)
  {
    bool isEqual = true;
    mitk::VnlVector diff = vector1 - vector2;
    for (unsigned int i = 0; i < diff.size(); i++)
    {
      if (DifferenceBiggerOrEqualEps(diff[i], eps))
      {
        isEqual = false;
        break;
      }
    }
 
    ConditionalOutputOfDifference(vector1, vector2, eps, verbose, isEqual);
 
    return isEqual;
  }
 
  template <typename TCoordRep, unsigned int NPointDimension>
  inline bool Equal(const vnl_vector_fixed<TCoordRep, NPointDimension> &vector1,
                    const vnl_vector_fixed<TCoordRep, NPointDimension> &vector2,
                    TCoordRep eps = mitk::eps,
                    bool verbose = false)
  {
    vnl_vector_fixed<TCoordRep, NPointDimension> diff = vector1 - vector2;
    bool isEqual = true;
    for (unsigned int i = 0; i < diff.size(); i++)
    {
      if (DifferenceBiggerOrEqualEps(diff[i], eps))
      {
        isEqual = false;
        break;
      }
    }
 
    ConditionalOutputOfDifference(vector1, vector2, eps, verbose, isEqual);
 
    return isEqual;
  }
 
} // end namespace mitk
 
#endif