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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
|
/*=========================================================================
*
* Copyright NumFOCUS
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0.txt
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*=========================================================================*/
#ifndef itkDCMTKSeriesFileNames_h
#define itkDCMTKSeriesFileNames_h
#include "ITKIODCMTKExport.h"
#include "itkProcessObject.h"
#include "itkObjectFactory.h"
#include "itkMacro.h"
#include <vector>
namespace itk
{
/**
* \class DCMTKSeriesFileNames
* \brief Generate a sequence of filenames from a DICOM series.
*
* This class generate a sequence of files whose filenames points to
* a DICOM file. The ordering is based on the following strategy:
* Read all images in the directory (assuming there is only one study/series)
*
* 1. Extract Image Orientation & Image Position from DICOM images, and then
* calculate the ordering based on the 3D coordinate of the slice
* 2. If for some reason this information is not found or failed, another
* strategy is used: the ordering is based on 'Image Number'
* 3. If this strategy also failed, then the filenames are ordered by
* lexicographical order.
*
* If multiple volumes are being grouped as a single series for your
* dicom objects, you may want to try calling ->SetUseSeriesDetails(true)
* prior to calling SetDirectory().
*
* \ingroup IOFilters
*
* \ingroup ITKIODCMTK
*/
class ITKIODCMTK_EXPORT DCMTKSeriesFileNames : public ProcessObject
{
public:
ITK_DISALLOW_COPY_AND_MOVE(DCMTKSeriesFileNames);
/** Standard class type aliases. */
using Self = DCMTKSeriesFileNames;
using Superclass = ProcessObject;
using Pointer = SmartPointer<Self>;
/** Type of the container that holds the UID's for the series. */
using SeriesUIDContainerType = std::vector<std::string>;
/** For backwards compatibility. */
using SeriesUIDContainer = SeriesUIDContainerType;
/** Type of the container that holds the file names in the series. */
using FileNamesContainerType = std::vector<std::string>;
/** For backwards compatibility */
using FilenamesContainer = FileNamesContainerType;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** \see LightObject::GetNameOfClass() */
itkOverrideGetNameOfClassMacro(DCMTKSeriesFileNames);
/* -------- Define the API for DCMTKSeriesFileNames ----------- */
/** Set the directory that contains the DICOM series. */
void
SetInputDirectory(const char * name);
/** Set the directory that contains the DICOM series. */
void
SetInputDirectory(std::string const & name);
/** Set the directory that contains the DICOM series. */
void
SetDirectory(std::string const & name)
{
SetInputDirectory(name);
}
/** Returns a vector containing the series' file names. The file
* names are ordered by the strategy define in header.
* No sorting is done based on UID */
const FileNamesContainerType &
GetInputFileNames();
/** Set the directory where the output DICOM series should be written. */
void
SetOutputDirectory(std::string const & name)
{
m_OutputDirectory = name;
this->Modified();
}
/** Returns a vector containing the series' file names. The file
* names are ordered in the same exact order as the input one.
* This could be dangerous if the writing has changed 3rd position
* or some other DICOM tag in the header
*/
const FileNamesContainerType &
GetOutputFileNames();
/** Returns a vector containing the series' file names. The file
* names are ordered by the strategy define in header.
* All DICOM files have the same exact UID equal to the one user's
* specified. An extended UID may be returned/used if
* SetUseSeriesDetails(true) has been called.
*/
const FileNamesContainerType &
GetFileNames(const std::string serie);
/** Returns a vector containing all the UIDs found when parsing the
* directory specified via SetDirectory. If no directory is specified
* return an empty vector. An extended UID may be returned/used if
* SetUseSeriesDetails(true) has been called.
*/
const SeriesUIDContainerType &
GetSeriesUIDs();
/** Recursively parse the input directory */
itkSetMacro(Recursive, bool);
itkGetConstMacro(Recursive, bool);
itkBooleanMacro(Recursive);
/** Use additional series information such as ProtocolName
* and SeriesName to identify when a single SeriesUID contains
* multiple 3D volumes - as can occur with perfusion and DTI imaging
*/
void
SetUseSeriesDetails(bool useSeriesDetails);
/** Returns true if using additional series information such as ProtocolName
* and SeriesName to identify when a single SeriesUID contains
* multiple 3D volumes - as can occur with perfusion and DTI imaging
*/
bool
GetUseSeriesDetails() const
{
return m_UseSeriesDetails;
}
/** Add more restriction on the selection of a Series. This follows the same
* approach as SetUseSeriesDetails, but allows a user to add even more DICOM
* tags to take into account for subrefining a set of DICOM files into multiple
* series. The tag format is "group|element" of a DICOM tag.
* \warning UseSeriesDetails needs to be set to true.
*/
void
AddSeriesRestriction(const std::string & /* tag */)
{
// m_SeriesHelper->AddRestriction(tag);
}
/** Parse any sequences in the DICOM file. Defaults to false
* to skip sequences. This makes loading DICOM files faster when
* sequences are not needed.
*/
itkSetMacro(LoadSequences, bool);
itkGetConstMacro(LoadSequences, bool);
itkBooleanMacro(LoadSequences);
/** Parse any private tags in the DICOM file. Defaults to false
* to skip private tags. This makes loading DICOM files faster when
* private tags are not needed.
*/
itkSetMacro(LoadPrivateTags, bool);
itkGetConstMacro(LoadPrivateTags, bool);
itkBooleanMacro(LoadPrivateTags);
protected:
DCMTKSeriesFileNames();
~DCMTKSeriesFileNames() override;
void
PrintSelf(std::ostream & os, Indent indent) const override;
private:
/** internal method for reading out filenames and UID lists */
void
GetDicomData(const std::string & series, bool saveFileNames);
/** Contains the input directory where the DICOM series is found */
std::string m_InputDirectory{};
/** Contains the output directory where the DICOM series should be written */
std::string m_OutputDirectory{};
/** Internal structure to keep the list of input/output filenames */
FileNamesContainerType m_InputFileNames{};
FileNamesContainerType m_OutputFileNames{};
/** Internal structure to order series from one directory */
/** Internal structure to keep the list of series UIDs */
SeriesUIDContainerType m_SeriesUIDs{};
bool m_UseSeriesDetails{};
bool m_Recursive{};
bool m_LoadSequences{};
bool m_LoadPrivateTags{};
};
} // namespace itk
#endif // itkDCMTKSeriesFileNames_h
|
