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"

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

  // 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 /* MITKVECTOR_H_ */