ITK  5.4.0
Insight Toolkit
itkPoint.h
Go to the documentation of this file.
1 /*=========================================================================
2  *
3  * Copyright NumFOCUS
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * https://www.apache.org/licenses/LICENSE-2.0.txt
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  *
17  *=========================================================================*/
18 #ifndef itkPoint_h
19 #define itkPoint_h
20 
21 
22 #include "itkNumericTraits.h"
23 #include "itkVector.h"
24 
25 #include "vnl/vnl_vector_ref.h"
26 #include "itkMath.h"
27 
28 namespace itk
29 {
52 template <typename TCoordRep, unsigned int VPointDimension = 3>
53 class ITK_TEMPLATE_EXPORT Point : public FixedArray<TCoordRep, VPointDimension>
54 {
55 public:
56 
58  using Self = Point;
60 
63  using ValueType = TCoordRep;
64  using CoordRepType = TCoordRep;
65 
67 
69  static constexpr unsigned int PointDimension = VPointDimension;
70 
73  using Iterator = typename BaseArray::Iterator;
75 
77  static unsigned int
79  {
80  return VPointDimension;
81  }
82 
85 
88  Point() = default;
89 
91  template <typename TPointValueType>
93  : BaseArray(r)
94  {}
95 
97  template <typename TPointValueType>
98  Point(const TPointValueType r[VPointDimension])
99  : BaseArray(r)
100  {}
101  Point(const ValueType r[VPointDimension])
102  : BaseArray(r)
103  {}
106 #if defined(ITK_LEGACY_REMOVE)
107 
108  Point(std::nullptr_t) = delete;
109 
111  template <typename TPointValueType>
112  explicit Point(const TPointValueType & v)
113  : BaseArray(v)
114  {}
115  explicit Point(const ValueType & v)
116  : BaseArray(v)
117  {}
118 #else
119 
122  template <typename TPointValueType>
123  Point(const TPointValueType & v)
124  : BaseArray(v)
125  {}
126  Point(const ValueType & v)
127  : BaseArray(v)
128  {}
129 #endif
130 
133  explicit Point(const std::array<ValueType, VPointDimension> & stdArray)
134  : BaseArray(stdArray)
135  {}
136 
138  Point &
139  operator=(const ValueType r[VPointDimension]);
140 
142  bool
143  operator==(const Self & pt) const
144  {
145  bool same = true;
146 
147  for (unsigned int i = 0; i < VPointDimension && same; ++i)
148  {
149  same = (Math::ExactlyEquals((*this)[i], pt[i]));
150  }
151  return same;
152  }
153 
154  ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(Self);
155 
157  const Self &
158  operator+=(const VectorType & vec);
159 
161  const Self &
162  operator-=(const VectorType & vec);
163 
165  VectorType
166  operator-(const Self & pnt) const;
167 
169  Self
170  operator+(const VectorType & vec) const;
171 
173  Self
174  operator-(const VectorType & vec) const;
175 
177  VectorType
178  GetVectorFromOrigin() const;
179 
181  vnl_vector_ref<TCoordRep>
182  GetVnlVector();
183 
185  vnl_vector<TCoordRep>
186  GetVnlVector() const;
187 
199  void
200  SetToMidPoint(const Self &, const Self &);
201 
228  void
229  SetToBarycentricCombination(const Self & A, const Self & B, double alpha);
247  void
248  SetToBarycentricCombination(const Self & A, const Self & B, const Self & C, double weightForA, double weightForB);
263  void
264  SetToBarycentricCombination(const Self * P, const double * weights, unsigned int N);
269  template <typename TCoordRepB>
270  void
272  {
273  for (unsigned int i = 0; i < VPointDimension; ++i)
274  {
275  (*this)[i] = static_cast<TCoordRep>(pa[i]);
276  }
277  }
284  template <typename TCoordRepB>
285  RealType
287  {
289 
290  for (unsigned int i = 0; i < VPointDimension; ++i)
291  {
292  const auto component = static_cast<RealType>(pa[i]);
293  const RealType difference = static_cast<RealType>((*this)[i]) - component;
294  sum += difference * difference;
295  }
296  return sum;
297  }
298 
302  template <typename TCoordRepB>
303  RealType
305  {
306  const double distance = std::sqrt(static_cast<double>(this->SquaredEuclideanDistanceTo(pa)));
307 
308  return static_cast<RealType>(distance);
309  }
310 };
311 
312 template <typename T, unsigned int VPointDimension>
313 std::ostream &
314 operator<<(std::ostream & os, const Point<T, VPointDimension> & vct);
315 
316 template <typename T, unsigned int VPointDimension>
317 std::istream &
318 operator>>(std::istream & is, Point<T, VPointDimension> & vct);
319 
346 template <typename TPointContainer, typename TWeightContainer>
347 class ITK_TEMPLATE_EXPORT BarycentricCombination
348 {
349 public:
350 
352  using PointContainerType = TPointContainer;
354  using PointType = typename PointContainerType::Element;
355  using WeightContainerType = TWeightContainer;
356 
357  BarycentricCombination() = default;
358  ~BarycentricCombination() = default;
359 
360  static PointType
361  Evaluate(const PointContainerPointer & points, const WeightContainerType & weights);
362 };
363 
364 
365 template <typename TCoordRep, unsigned int VPointDimension>
366 inline void
368 {
369  a.swap(b);
370 }
371 
372 
374 template <typename TValue, typename... TVariadic>
375 auto
376 MakePoint(const TValue firstValue, const TVariadic... otherValues)
377 {
378  // Assert that the other values have the same type as the first value.
379  const auto assertSameType = [](const auto value) {
380  static_assert(std::is_same<decltype(value), const TValue>::value, "Each value must have the same type!");
381  return true;
382  };
383  const bool assertions[] = { true, assertSameType(otherValues)... };
384  (void)assertions;
385  (void)assertSameType;
388  constexpr unsigned int dimension{ 1 + sizeof...(TVariadic) };
389  const std::array<TValue, dimension> stdArray{ { firstValue, otherValues... } };
390  return Point<TValue, dimension>{ stdArray };
391 }
392 
393 } // end namespace itk
394 
395 #ifndef ITK_MANUAL_INSTANTIATION
396 # include "itkPoint.hxx"
397 #endif
398 
399 #endif
Pointer
SmartPointer< Self > Pointer
Definition: itkAddImageFilter.h:92
itk::MakePoint
auto MakePoint(const TValue firstValue, const TVariadic... otherValues)
Definition: itkPoint.h:376
itk::Point< double, Self::ImageDimension >::RealType
typename NumericTraits< ValueType >::RealType RealType
Definition: itkPoint.h:66
itk::Point::Point
Point(const TPointValueType r[VPointDimension])
Definition: itkPoint.h:98
itk::BarycentricCombination
Computes the barycentric combination of an array of N points.
Definition: itkPoint.h:347
itk::Point::Point
Point(const TPointValueType &v)
Definition: itkPoint.h:112
itk::BarycentricCombination::WeightContainerType
TWeightContainer WeightContainerType
Definition: itkPoint.h:355
itk::operator<<
std::ostream & operator<<(std::ostream &os, const Array< TValue > &arr)
Definition: itkArray.h:216
itk::GTest::TypedefsAndConstructors::Dimension2::VectorType
ImageBaseType::SpacingType VectorType
Definition: itkGTestTypedefsAndConstructors.h:53
itk::Math::ExactlyEquals
bool ExactlyEquals(const TInput1 &x1, const TInput2 &x2)
Return the result of an exact comparison between two scalar values of potentially different types.
Definition: itkMath.h:723
itk::Point::operator==
bool operator==(const Self &pt) const
Definition: itkPoint.h:143
itk::swap
void swap(Array< T > &a, Array< T > &b)
Definition: itkArray.h:242
itk::Vector
A templated class holding a n-Dimensional vector.
Definition: itkVector.h:62
itk::operator-
ConstNeighborhoodIterator< TImage > operator-(const ConstNeighborhoodIterator< TImage > &it, const typename ConstNeighborhoodIterator< TImage >::OffsetType &ind)
Definition: itkConstNeighborhoodIterator.h:672
itk::Point::GetPointDimension
static unsigned int GetPointDimension()
Definition: itkPoint.h:78
itk::FixedArray< double, VPointDimension >::ConstIterator
const ValueType * ConstIterator
Definition: itkFixedArray.h:72
itk::Point::CastFrom
void CastFrom(const Point< TCoordRepB, VPointDimension > &pa)
Definition: itkPoint.h:271
itk::Point::Point
Point(const ValueType r[VPointDimension])
Definition: itkPoint.h:101
itk::Point::EuclideanDistanceTo
RealType EuclideanDistanceTo(const Point< TCoordRepB, VPointDimension > &pa) const
Definition: itkPoint.h:304
itk::BarycentricCombination::PointType
typename PointContainerType::Element PointType
Definition: itkPoint.h:354
itk::Point::SquaredEuclideanDistanceTo
RealType SquaredEuclideanDistanceTo(const Point< TCoordRepB, VPointDimension > &pa) const
Definition: itkPoint.h:286
itk::FixedArray
Simulate a standard C array with copy semantics.
Definition: itkFixedArray.h:53
itk::Point::Point
Point(const ValueType &v)
Definition: itkPoint.h:115
itk::Point::Point
Point(const std::array< ValueType, VPointDimension > &stdArray)
Definition: itkPoint.h:133
itk::NumericTraits::ZeroValue
static T ZeroValue()
Definition: itkNumericTraits.h:149
itk
The "itk" namespace contains all Insight Segmentation and Registration Toolkit (ITK) classes....
Definition: itkAnnulusOperator.h:24
itk::BarycentricCombination::PointContainerPointer
typename PointContainerType::Pointer PointContainerPointer
Definition: itkPoint.h:353
itk::Point< double, Self::ImageDimension >::CoordRepType
double CoordRepType
Definition: itkPoint.h:64
itkVector.h
itk::FixedArray< TCoordRep, VPointDimension >::swap
void swap(FixedArray &other)
Definition: itkFixedArray.h:416
itk::operator+
ConstNeighborhoodIterator< TImage > operator+(const ConstNeighborhoodIterator< TImage > &it, const typename ConstNeighborhoodIterator< TImage >::OffsetType &ind)
Definition: itkConstNeighborhoodIterator.h:654
itkNumericTraits.h
itk::Point
A templated class holding a geometric point in n-Dimensional space.
Definition: itkPoint.h:53
itk::NumericTraits::RealType
double RealType
Definition: itkNumericTraits.h:85
AddImageFilter
Definition: itkAddImageFilter.h:80
itk::BarycentricCombination::PointContainerType
TPointContainer PointContainerType
Definition: itkPoint.h:352
itkMath.h
itk::operator>>
std::istream & operator>>(std::istream &is, Point< T, VPointDimension > &vct)
itk::Point::Point
Point(const Point< TPointValueType, VPointDimension > &r)
Definition: itkPoint.h:92
itk::FixedArray< double, VPointDimension >::Iterator
ValueType * Iterator
Definition: itkFixedArray.h:69
itk::FixedArray< double, VPointDimension >::ValueType
double ValueType
Definition: itkFixedArray.h:63