ITK  4.8.0
Insight Segmentation and Registration Toolkit
itkQuadEdgeMeshParamMatrixCoefficients.h
Go to the documentation of this file.
1 /*=========================================================================
2  *
3  * Copyright Insight Software Consortium
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  * http://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 itkQuadEdgeMeshParamMatrixCoefficients_h
19 #define itkQuadEdgeMeshParamMatrixCoefficients_h
20 
21 #include "itkQuadEdgeMesh.h"
22 #include "itkTriangleHelper.h"
23 #include "vnl/vnl_math.h"
24 
25 namespace itk
26 {
32 template< typename TInputMesh >
34 {
35 public:
36  typedef TInputMesh InputMeshType;
37  typedef typename InputMeshType::CoordRepType InputCoordRepType;
38  typedef typename InputMeshType::QEType InputQEType;
39 
41  virtual ~MatrixCoefficients() {}
42 
43  virtual InputCoordRepType operator()
44  (const InputMeshType *iMesh, InputQEType *iEdge) const = 0;
45 };
46 
54 template< typename TInputMesh >
55 class OnesMatrixCoefficients:public MatrixCoefficients< TInputMesh >
56 {
57 public:
59 
60  typedef TInputMesh InputMeshType;
61  typedef typename InputMeshType::CoordRepType InputCoordRepType;
62  typedef typename InputMeshType::QEType InputQEType;
63 
65 
69  InputCoordRepType operator()( const InputMeshType *itkNotUsed(iMesh),
70  InputQEType *itkNotUsed(iEdge) ) const
71  {
72  return 1.0;
73  }
74 };
76 
84 template< typename TInputMesh >
86  public MatrixCoefficients< TInputMesh >
87 {
88 public:
90 
91  typedef TInputMesh InputMeshType;
92  typedef typename InputMeshType::CoordRepType InputCoordRepType;
93  typedef typename InputMeshType::PointType InputPointType;
94  typedef typename InputMeshType::PointIdentifier InputPointIdentifier;
95  typedef typename InputMeshType::QEType InputQEType;
96  typedef typename InputMeshType::VectorType InputVectorType;
97 
99 
106  {
107  InputPointIdentifier id1 = iEdge->GetOrigin();
108  InputPointIdentifier id2 = iEdge->GetDestination();
110 
111  InputPointType pt1 = iMesh->GetPoint(id1);
112  InputPointType pt2 = iMesh->GetPoint(id2);
113 
114  InputCoordRepType oValue = 1.0 / pt1.EuclideanDistanceTo(pt2);
115 
116  return oValue;
117  }
118 };
119 
127 template< typename TInputMesh >
129 {
130 public:
132 
133  typedef TInputMesh InputMeshType;
134  typedef typename InputMeshType::CoordRepType InputCoordRepType;
135  typedef typename InputMeshType::PointType InputPointType;
136  typedef typename InputMeshType::PointIdentifier InputPointIdentifier;
137  typedef typename InputMeshType::QEType InputQEType;
138 
140 
147  {
148  InputPointIdentifier id1 = iEdge->GetOrigin();
149  InputPointIdentifier id2 = iEdge->GetDestination();
150  InputPointType pt1 = iMesh->GetPoint(id1);
151  InputPointType pt2 = iMesh->GetPoint(id2);
153 
154  InputCoordRepType oValue(0.0);
155 
156  if ( iEdge->IsLeftSet() )
157  {
158  InputPointIdentifier idA = iEdge->GetLnext()->GetDestination();
159  InputPointType ptA = iMesh->GetPoint(idA);
160  oValue += TriangleHelper< InputPointType >::Cotangent(pt1, ptA, pt2);
161  }
162  if ( iEdge->IsRightSet() )
163  {
164  InputPointIdentifier idB = iEdge->GetRnext()->GetOrigin();
165  InputPointType ptB = iMesh->GetPoint(idB);
166  oValue += TriangleHelper< InputPointType >::Cotangent(pt1, ptB, pt2);
167  }
168 
169  return vnl_math_max( NumericTraits< InputCoordRepType >::ZeroValue(), oValue);
170  }
171 };
172 
181 template< typename TInputMesh >
183 {
184 public:
186 
187  typedef TInputMesh InputMeshType;
188  typedef typename InputMeshType::CoordRepType InputCoordRepType;
189  typedef typename InputMeshType::PointType InputPointType;
190  typedef typename InputMeshType::PointIdentifier InputPointIdentifier;
191  typedef typename InputMeshType::QEType InputQEType;
192 
194 
202  {
203  InputPointIdentifier id1 = iEdge->GetOrigin();
204  InputPointType pt1 = iMesh->GetPoint(id1);
206 
207  InputPointIdentifier id2 = iEdge->GetDestination();
208  InputPointType pt2 = iMesh->GetPoint(id2);
209 
211 
212  if ( iEdge->IsLeftSet() )
213  {
214  InputPointIdentifier idA = iEdge->GetLnext()->GetDestination();
215  InputPointType ptA = iMesh->GetPoint(idA);
216  oValue +=
218  }
219 
220  if ( iEdge->IsRightSet() )
221  {
222  InputPointIdentifier idB = iEdge->GetRnext()->GetOrigin();
223  InputPointType ptB = iMesh->GetPoint(idB);
224  oValue += TriangleHelper< InputPointType >::Cotangent(pt1, pt2, ptB);
225  }
226 
227  return oValue / pt1.SquaredEuclideanDistanceTo(pt2);
228  }
229 };
230 
238 template< typename TInputMesh >
240 {
241 public:
243 
244  typedef TInputMesh InputMeshType;
245  typedef typename InputMeshType::CoordRepType InputCoordRepType;
246  typedef typename InputMeshType::QEType InputQEType;
247 
249 
251  m_Lambda(iLambda)
252  {}
253 
255  InputQEType *iEdge) const
256  {
259 
260  InputCoordRepType oValue = m_Lambda * conformal(iMesh, iEdge)
261  + ( 1.0 - m_Lambda ) * authalic(iMesh, iEdge);
262 
263  return oValue;
264  }
265 };
266 
274 template< typename TInputMesh >
276 {
277 public:
279 
280  typedef TInputMesh InputMeshType;
281  typedef typename InputMeshType::CoordRepType InputCoordRepType;
282  typedef typename InputMeshType::PointType InputPointType;
283  typedef typename InputPointType::VectorType InputVectorType;
284  typedef typename InputMeshType::PointIdentifier InputPointIdentifier;
285  typedef typename InputMeshType::QEType InputQEType;
286 
287  itkStaticConstMacro(PointDimension, unsigned int,
288  InputPointType::PointDimension);
289 
291 
293  {
294  InputPointIdentifier id1 = iEdge->GetOrigin();
295  InputPointIdentifier id2 = iEdge->GetDestination();
296 
297  InputPointIdentifier idA = iEdge->GetLnext()->GetDestination();
298  InputPointIdentifier idB = iEdge->GetRnext()->GetOrigin();
299 
300  InputPointType pt1 = iMesh->GetPoint(id1);
301  InputPointType pt2 = iMesh->GetPoint(id2);
302  InputPointType ptA = iMesh->GetPoint(idA);
303  InputPointType ptB = iMesh->GetPoint(idB);
304 
305  InputVectorType v1A = ptA - pt1;
306  InputVectorType v1B = ptB - pt1;
307  InputVectorType v12 = pt2 - pt1;
308 
309  InputCoordRepType L1A = v1A * v1A;
310  InputCoordRepType L1B = v1B * v1B;
311  InputCoordRepType L12 = v12 * v12;
312 
313  InputCoordRepType L2A = pt2.SquaredEuclideanDistanceTo(ptA);
314  InputCoordRepType L2B = pt2.SquaredEuclideanDistanceTo(ptB);
315 
317 
318  InputCoordRepType AreaA = 0.5 * ( cross(v1A, v12).GetNorm() );
319  InputCoordRepType AreaB = 0.5 * ( cross(v1B, v12).GetNorm() );
320 
322  oValue = ( L1A + L2A - L12 ) / AreaA + ( L1B + L2B - L12 ) / AreaB;
323 
324  return oValue;
325  }
326 };
327 }
328 #endif
InputCoordRepType operator()(const InputMeshType *iMesh, InputQEType *iEdge) const
Compute a matrix filed with the inverse of the euclidian distance wherever two vertices are connected...
InputCoordRepType operator()(const InputMeshType *iMesh, InputQEType *iEdge) const
InputCoordRepType operator()(const InputMeshType *iMesh, InputQEType *iEdge) const
Compute a matrix filled by 1s wherever two vertices are connected by an edge.
MatrixCoefficients< TInputMesh > Superclass
IntrinsicMatrixCoefficients(const InputCoordRepType &iLambda)
InputCoordRepType operator()(const InputMeshType *, InputQEType *) const
Compute a matrix filed by Conformal Coefficients of the edge wherever two vertices are connected by a...
InputCoordRepType operator()(const InputMeshType *iMesh, InputQEType *iEdge) const
InputCoordRepType operator()(const InputMeshType *iMesh, InputQEType *iEdge) const
static CoordRepType Cotangent(const PointType &iA, const PointType &iB, const PointType &iC)
Compute cotangent(iA,iB,iC)
Compute a matrix filled with Authalic Coefiicients of the edge, wherever two vertices are connected w...
InputMeshType::CoordRepType InputCoordRepType
Compute a matrix filled with Harmonic coefficients, wherever two vertices are connected by an edge...
Compute a mtrix filled by intrinsic Coefficients of the edge, wherever two vertices are connected by ...
Define additional traits for native types such as int or float.
Superclass for all the matrix coefficients computation classes.