forked from Kitware/VTK
-
Notifications
You must be signed in to change notification settings - Fork 0
/
vtkImageEuclideanDistance.h
127 lines (108 loc) · 4.33 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
/*=========================================================================
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
* vtkImageEuclideanDistance::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 "vtkImageDecomposeFilter.h"
#include "vtkImagingGeneralModule.h" // For export macro
#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) 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, vtkTypeBool);
vtkGetMacro(Initialize, vtkTypeBool);
vtkBooleanMacro(Initialize, vtkTypeBool);
///@}
///@{
/**
* Used to define whether Spacing should be used in the computation of the
* distances
*/
vtkSetMacro(ConsiderAnisotropy, vtkTypeBool);
vtkGetMacro(ConsiderAnisotropy, vtkTypeBool);
vtkBooleanMacro(ConsiderAnisotropy, vtkTypeBool);
///@}
///@{
/**
* 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*) override;
protected:
vtkImageEuclideanDistance();
~vtkImageEuclideanDistance() override = default;
double MaximumDistance;
vtkTypeBool Initialize;
vtkTypeBool ConsiderAnisotropy;
int Algorithm;
// Replaces "EnlargeOutputUpdateExtent"
virtual void AllocateOutputScalars(vtkImageData* outData, int outExt[6], vtkInformation* outInfo);
int IterativeRequestInformation(vtkInformation* in, vtkInformation* out) override;
int IterativeRequestUpdateExtent(vtkInformation* in, vtkInformation* out) override;
private:
vtkImageEuclideanDistance(const vtkImageEuclideanDistance&) = delete;
void operator=(const vtkImageEuclideanDistance&) = delete;
};
#endif