diff --git a/Core/Code/DataManagement/mitkVector.h b/Core/Code/DataManagement/mitkVector.h index 621c06435f..7337330b63 100644 --- a/Core/Code/DataManagement/mitkVector.h +++ b/Core/Code/DataManagement/mitkVector.h @@ -1,145 +1,156 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef MITKVECTOR_H_ #define MITKVECTOR_H_ #include #include #include #include "mitkTypeBasics.h" #include "mitkExceptionMacro.h" namespace mitk { template class Vector : public itk::Vector { public: /** * @brief Default constructor has nothing to do. */ Vector() : itk::Vector() {} /** * @brief Copy constructor. */ Vector(const Vector& r) : itk::Vector(r) {} /** * @brief Constructor to convert from itk::Vector to mitk::Vector. */ Vector(const itk::Vector& r) : itk::Vector(r) {} /** * @brief Constructor to convert an array to mitk::Vector * @param r the array. * @attention must have NVectorDimension valid arguments! */ Vector(const TCoordRep r[NVectorDimension]) : itk::Vector(r) {} /** * Constructor to initialize entire vector to one value. */ Vector(const TCoordRep & v) : itk::Vector(v) {} /** * @brief Constructor for vnl_vectors. * @throws mitk::Exception if vnl_vector.size() != NVectorDimension. */ Vector(const vnl_vector& vnlVector) : itk::Vector() { if (vnlVector.size() != NVectorDimension) mitkThrow() << "when constructing mitk::Vector from vnl_vector: sizes didn't match: mitk::Vector " << NVectorDimension << "; vnl_vector " << vnlVector.size(); for (int var = 0; (var < NVectorDimension) && (var < vnlVector.size()); ++var) { this->SetElement(var, vnlVector.get(var)); } } /** * @brief Constructor for vnl_vector_fixed. */ Vector(const vnl_vector_fixed vnlVectorFixed) : itk::Vector() { for (int var = 0; var < 3; ++var) { this->SetElement(var, vnlVectorFixed[var]); } }; /** * @brief User defined conversion of mitk::Vector to vnl_vector. * Note: the conversion to mitk::Vector to vnl_vector_fixed has not been implemented since this * would collide with the conversion vnl_vector to vnl_vector_fixed provided by vnl. */ operator vnl_vector () const { vnl_vector vnlVector(this->GetVnlVector()); return vnlVector; } - /** - * @brief Copies the elements of this into an ArrayType T - * @param[out] array the array which will hold the elements. Must be of a type which overrides the [] operator. - * @attention array must be of dimension NVectorDimension! - * @attention this method implicitly converts between data types. - */ - template - void ToArray(ArrayType& array) const - { - for (int i = 0; i < NVectorDimension; i++) - { - array[i] = this->GetElement(i); - } - } - - /** - * @brief Copies elements of an ArrayType T to this Vector - * @param array the array whose values will be copied into the Vector. Must be of a type which overrides the [] operator - * @attention array must be of dimension NVectorDimension! - * @attention this method implicitly converts between data types. - */ - template - void FromArray(const ArrayType& array) - { - for (unsigned short int var = 0; var < NVectorDimension; ++var) { - this->SetElement(var, array[var]); - } - } - }; // end mitk::Vector // convenience typedefs for often used mitk::Vector representations. typedef Vector Vector2D; typedef Vector Vector3D; typedef Vector Vector4D; + /** + * Now methods to copy from and into ArrayTypes. + * ArrayTypes here are all types who implement operator[]. + * The two methods were made free floating so you may template specifications for you concrete type. + */ + + + /** + * @brief Copies elements of an array to this Vector + * @param[in] array the array whose values will be copied into the Vector. Must be of a type which overrides the [] operator + * @param[out] vectorOrPoint the FixedArrray (e.g., mitk::Vector or mitk::Point) which should hold the elements of array. + * @attention array must be of dimension NVectorDimension! + * @attention this method implicitly converts between data types. + */ + template + void FromArray(itk::FixedArray& vectorOrPoint, const ArrayType& array) + { + for (unsigned short int var = 0; var < NVectorDimension; ++var) + { + vectorOrPoint[var] = array[var]; + } + } + + + /** + * @brief Copies the elements of this into an array + * @param[in] vectorOrPoint the itk::FixedArray which shall be copied into the array. Can e.g. be of type mitk::Vector or mitk::Point + * @param[out] array the array which will hold the elements. Must be of a type which overrides the [] operator. + * @attention array must be of dimension NVectorDimension! + * @attention this method implicitly converts between data types. + */ + template + void ToArray(ArrayType& array, const itk::FixedArray& vectorOrPoint) + { + for (unsigned short int var = 0; var < NVectorDimension; ++var) + { + array[var] = vectorOrPoint[var]; + } + } + } // end namespace mitk #endif /* MITKVECTOR_H_ */ diff --git a/Core/Code/Testing/mitkTypeVectorConversionTest.cpp b/Core/Code/Testing/mitkTypeVectorConversionTest.cpp index 15c7ee2f6f..58f88d5ffe 100644 --- a/Core/Code/Testing/mitkTypeVectorConversionTest.cpp +++ b/Core/Code/Testing/mitkTypeVectorConversionTest.cpp @@ -1,272 +1,272 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include #include "itkVector.h" #include #include #include "vnl/vnl_math.h" #include "mitkTestingMacros.h" #include "mitkTypeBasics.h" #include "mitkVector.h" #include "mitkTypes.h" // for Equals // TODO SW: here we will need a guard in case opencv is not activated in a build. #include using namespace mitk; /** * these private variables are used in the test functions * * The variable which should be copied into is set to its original value. * The value which should be copied is set to valuesToCopy. * * Then the copying takes place. The test is successful, if the variable which * should be copied into holds the valuesToCopy afterwards and is equal to the * vector which should be copied. */ static const ScalarType originalValues[] = {1.123456789987, 2.789456321456, 3.123654789987456}; static const ScalarType valuesToCopy[] = {4.654789123321, 5.987456789321, 6.321654987789546}; /** * @brief Convenience method to test if one vector has been assigned successfully to the other. * * More specifically, tests if v1 = v2 was performed correctly. The method therefore assures that * 1. v1 equals v2 and * 2. both hold the values of v2. * * @param v1 The vector v1 of the assignment v1 = v2 * @param v2 The vector v2 of the assignment v1 = v2 * @param v1Name The type name of v1 (e.g.: mitk::Vector3D). Necessary for the correct test output. * @param v2Name The type name of v2 (e.g.: mitk::Vector3D). Necessary for the correct test output. * @param eps defines the allowed tolerance when testing for equality. */ template static void TestForEquality(T1 v1, T2 v2, std::string v1Name, std::string v2Name, ScalarType eps = mitk::eps) { MITK_TEST_CONDITION( EqualArray(v1, v2, 3, eps), "\nAssigning " << v2Name << " to " << v1Name << ":\n1. both are equal") MITK_TEST_CONDITION( EqualArray(v1, v2, 3, eps), "2. both hold values of " << v2Name) } const float epsDouble2Float = vnl_math::float_eps * 10.0; static void Test_pod2mitk(void) { mitk::Vector3D vector3D = valuesToCopy; TestForEquality(vector3D, valuesToCopy, "mitk::Vector3D", "double POD"); } static void Test_mitk2pod(void) { ScalarType podArray[3]; mitk::Vector3D vector3D = valuesToCopy; - vector3D.ToArray(podArray); + ToArray(podArray, vector3D); TestForEquality(podArray, vector3D, "double POD", "mitk::Vector3D"); } static void Test_oneElement2mitk(void) { double twos[] = {2.0, 2.0, 2.0}; mitk::Vector vector3D(2.0); MITK_TEST_CONDITION(EqualArray(vector3D, twos, 3), "\none values initializes all elements to this value") } static void Test_itk2mitk(void) { Vector3D vector3D = originalValues; itk::Vector itkVector = valuesToCopy; vector3D = itkVector; TestForEquality(vector3D, itkVector, "mitk::Vector3D", "itk::Vector"); } static void Test_mitk2itk(void) { Vector3D vector3D = valuesToCopy; itk::Vector itkVector = originalValues; itkVector = vector3D; TestForEquality(itkVector, vector3D, "itk::Vector", "mitk::Vector3D"); } static void Test_vnlfixed2mitk(void) { mitk::Vector3D vector3D = originalValues; vnl_vector_fixed vnlVectorFixed(valuesToCopy); vector3D = vnlVectorFixed; TestForEquality(vector3D, vnlVectorFixed, "mitk::Vector3D", "vnl_vector_fixed"); } static void Test_mitk2vnlfixed(void) { vnl_vector_fixed vnlVectorFixed(originalValues); mitk::Vector3D vector3D = valuesToCopy; vnlVectorFixed = vector3D; TestForEquality(vnlVectorFixed, vector3D, "vnl_vector_fixed", "mitk::Vector3D"); } static void Test_vnl2mitk(void) { mitk::Vector3D vector3D = originalValues; vnl_vector vnlVector(3); vnlVector.set(valuesToCopy); vector3D = vnlVector; TestForEquality(vector3D, vnlVector, "mitk::Vector3D", "vnl_vector"); } static void Test_mitk2vnl(void) { vnl_vector vnlVector(3); vnlVector.set(originalValues); mitk::Vector3D vector3D = valuesToCopy; vnlVector = vector3D; TestForEquality(vnlVector, vector3D, "vnl_vector", "mitk::Vector3D"); } /** * @brief Tests if an exception is thrown when constructing an mitk::Vector form a vnl_vector of not suited size. */ static void Test_vnl2mitk_WrongVnlVectorSize() { ScalarType largerValuesToCopy[] = {4.12345678910, 5.10987654321, 6.123456789132456, 7.123456987789456}; mitk::Vector3D vector3D = originalValues; vnl_vector vnlVector(4); vnlVector.set(largerValuesToCopy); MITK_TEST_FOR_EXCEPTION(mitk::Exception&, vector3D = vnlVector;) } static void Test_mitk2opencv() { cv::Vec3d opencvVector(originalValues[0], originalValues[1], originalValues[2]); mitk::Vector3D vector3D = valuesToCopy; - vector3D.ToArray(opencvVector); + ToArray(opencvVector, vector3D); TestForEquality(opencvVector, vector3D, "cv::Vec3d", "mitk::Vector3D"); } static void Test_opencv2mitk() { mitk::Vector3D vector3D = originalValues; cv::Vec3d opencvVector(valuesToCopy[0], valuesToCopy[1], valuesToCopy[2]); - vector3D.FromArray(opencvVector); + FromArray(vector3D, opencvVector); TestForEquality(vector3D, opencvVector, "mitk::Vector3D", "cv::Vec3d"); } static void Test_ToArray_DifferentType(void) { float podArray[3]; for (int var = 0; var < 3; ++var) { podArray[var] = originalValues[var]; } mitk::Vector3D vector3D = valuesToCopy; - vector3D.ToArray(podArray); + ToArray(podArray, vector3D); TestForEquality(podArray, vector3D, "float POD", "mitk::Vector3D", epsDouble2Float); } static void Test_FromArray_DifferentType(void) { mitk::Vector3D vector3D = originalValues; float podArray[3]; for (int var = 0; var < 3; ++var) { podArray[var] = valuesToCopy[var]; } - vector3D.FromArray(podArray); + FromArray(vector3D, podArray); TestForEquality(vector3D, podArray, "mitk::Vector3D", "float POD", epsDouble2Float); } /** * @brief Test the conversions from and to the mitk::Vector type. * * Tests for every conversion, if it can be done and in a second test, if the assignment of a * different type succeeds. E.g., assign a double vnl_vector to a float mitk::Vector * In cases where the size can not be determined during compile time it is checked if the assignment of * a differently sized vector yields an error. */ int mitkTypeVectorConversionTest(int /*argc*/ , char* /*argv*/[]) { // always start with this! MITK_TEST_BEGIN("VectorConversionTest") Test_pod2mitk(); Test_mitk2pod(); Test_oneElement2mitk(); Test_itk2mitk(); Test_mitk2itk(); Test_vnlfixed2mitk(); Test_mitk2vnlfixed(); Test_vnl2mitk(); Test_mitk2vnl(); Test_vnl2mitk_WrongVnlVectorSize(); Test_mitk2opencv(); Test_opencv2mitk(); /** * The ToArray and FromArray can assign non equal types by implicit primitive type conversion. * The next two tests show this behavior */ Test_ToArray_DifferentType(); Test_FromArray_DifferentType(); MITK_TEST_END() }