forked from Kitware/VTK
-
Notifications
You must be signed in to change notification settings - Fork 0
/
vtkImageEuclideanDistance.h
145 lines (116 loc) · 4.5 KB
/
vtkImageEuclideanDistance.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
/*=========================================================================
Program: Visualization Toolkit
Module: vtkImageEuclideanDistance.h
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
/**
* @class vtkImageEuclideanDistance
* @brief computes 3D Euclidean DT
*
* vtkImageEuclideanDistance implements the Euclidean DT using
* Saito's algorithm. The distance map produced contains the square of the
* Euclidean distance values.
*
* The algorithm has a o(n^(D+1)) complexity over nxnx...xn images in D
* dimensions. It is very efficient on relatively small images. Cuisenaire's
* algorithms should be used instead if n >> 500. These are not implemented
* yet.
*
* For the special case of images where the slice-size is a multiple of
* 2^N with a large N (typically for 256x256 slices), Saito's algorithm
* encounters a lot of cache conflicts during the 3rd iteration which can
* slow it very significantly. In that case, one should use
* ::SetAlgorithmToSaitoCached() instead for better performance.
*
* References:
*
* T. Saito and J.I. Toriwaki. New algorithms for Euclidean distance
* transformations of an n-dimensional digitised picture with applications.
* Pattern Recognition, 27(11). pp. 1551--1565, 1994.
*
* O. Cuisenaire. Distance Transformation: fast algorithms and applications
* to medical image processing. PhD Thesis, Universite catholique de Louvain,
* October 1999. http://ltswww.epfl.ch/~cuisenai/papers/oc_thesis.pdf
*/
#ifndef vtkImageEuclideanDistance_h
#define vtkImageEuclideanDistance_h
#include "vtkImagingGeneralModule.h" // For export macro
#include "vtkImageDecomposeFilter.h"
#define VTK_EDT_SAITO_CACHED 0
#define VTK_EDT_SAITO 1
class VTKIMAGINGGENERAL_EXPORT vtkImageEuclideanDistance : public vtkImageDecomposeFilter
{
public:
static vtkImageEuclideanDistance *New();
vtkTypeMacro(vtkImageEuclideanDistance,vtkImageDecomposeFilter);
void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;
//@{
/**
* Used to set all non-zero voxels to MaximumDistance before starting
* the distance transformation. Setting Initialize off keeps the current
* value in the input image as starting point. This allows to superimpose
* several distance maps.
*/
vtkSetMacro(Initialize, int);
vtkGetMacro(Initialize, int);
vtkBooleanMacro(Initialize, int);
//@}
//@{
/**
* Used to define whether Spacing should be used in the computation of the
* distances
*/
vtkSetMacro(ConsiderAnisotropy, int);
vtkGetMacro(ConsiderAnisotropy, int);
vtkBooleanMacro(ConsiderAnisotropy, int);
//@}
//@{
/**
* Any distance bigger than this->MaximumDistance will not ne computed but
* set to this->MaximumDistance instead.
*/
vtkSetMacro(MaximumDistance, double);
vtkGetMacro(MaximumDistance, double);
//@}
//@{
/**
* Selects a Euclidean DT algorithm.
* 1. Saito
* 2. Saito-cached
* More algorithms will be added later on.
*/
vtkSetMacro(Algorithm, int);
vtkGetMacro(Algorithm, int);
void SetAlgorithmToSaito ()
{ this->SetAlgorithm(VTK_EDT_SAITO); }
void SetAlgorithmToSaitoCached ()
{ this->SetAlgorithm(VTK_EDT_SAITO_CACHED); }
//@}
int IterativeRequestData(vtkInformation*,
vtkInformationVector**,
vtkInformationVector*) VTK_OVERRIDE;
protected:
vtkImageEuclideanDistance();
~vtkImageEuclideanDistance()VTK_OVERRIDE {}
double MaximumDistance;
int Initialize;
int ConsiderAnisotropy;
int Algorithm;
// Replaces "EnlargeOutputUpdateExtent"
virtual void AllocateOutputScalars(vtkImageData *outData,
int outExt[6],
vtkInformation* outInfo);
int IterativeRequestInformation(vtkInformation* in,
vtkInformation* out) VTK_OVERRIDE;
int IterativeRequestUpdateExtent(vtkInformation* in,
vtkInformation* out) VTK_OVERRIDE;
private:
vtkImageEuclideanDistance(const vtkImageEuclideanDistance&) VTK_DELETE_FUNCTION;
void operator=(const vtkImageEuclideanDistance&) VTK_DELETE_FUNCTION;
};
#endif