Mercurial > hg > orthanc-stone
annotate Framework/Volumes/ImageBuffer3D.cpp @ 40:7207a407bcd8
shared copyright with osimis
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Wed, 04 Jan 2017 16:37:42 +0100 |
parents | ff1e935768e7 |
children | 28956ed68280 |
rev | line source |
---|---|
0 | 1 /** |
2 * Stone of Orthanc | |
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics | |
4 * Department, University Hospital of Liege, Belgium | |
40
7207a407bcd8
shared copyright with osimis
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
16
diff
changeset
|
5 * Copyright (C) 2017 Osimis, Belgium |
0 | 6 * |
7 * This program is free software: you can redistribute it and/or | |
8 * modify it under the terms of the GNU General Public License as | |
9 * published by the Free Software Foundation, either version 3 of the | |
10 * License, or (at your option) any later version. | |
11 * | |
12 * In addition, as a special exception, the copyright holders of this | |
13 * program give permission to link the code of its release with the | |
14 * OpenSSL project's "OpenSSL" library (or with modified versions of it | |
15 * that use the same license as the "OpenSSL" library), and distribute | |
16 * the linked executables. You must obey the GNU General Public License | |
17 * in all respects for all of the code used other than "OpenSSL". If you | |
18 * modify file(s) with this exception, you may extend this exception to | |
19 * your version of the file(s), but you are not obligated to do so. If | |
20 * you do not wish to do so, delete this exception statement from your | |
21 * version. If you delete this exception statement from all source files | |
22 * in the program, then also delete it here. | |
23 * | |
24 * This program is distributed in the hope that it will be useful, but | |
25 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
27 * General Public License for more details. | |
28 * | |
29 * You should have received a copy of the GNU General Public License | |
30 * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
31 **/ | |
32 | |
33 | |
34 #include "ImageBuffer3D.h" | |
35 | |
16 | 36 #include "../../Resources/Orthanc/Core/Images/ImageProcessing.h" |
37 #include "../../Resources/Orthanc/Core/OrthancException.h" | |
0 | 38 |
39 namespace OrthancStone | |
40 { | |
41 Orthanc::ImageAccessor ImageBuffer3D::GetAxialSliceAccessor(unsigned int slice, | |
42 bool readOnly) | |
43 { | |
44 if (slice >= depth_) | |
45 { | |
46 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
47 } | |
48 | |
49 Orthanc::ImageAccessor accessor; | |
50 | |
51 if (readOnly) | |
52 { | |
53 accessor.AssignReadOnly(format_, width_, height_, image_.GetPitch(), | |
54 image_.GetConstRow(height_ * (depth_ - 1 - slice))); | |
55 } | |
56 else | |
57 { | |
58 accessor.AssignWritable(format_, width_, height_, image_.GetPitch(), | |
59 image_.GetRow(height_ * (depth_ - 1 - slice))); | |
60 } | |
61 | |
62 return accessor; | |
63 } | |
64 | |
65 | |
66 Orthanc::ImageAccessor ImageBuffer3D::GetCoronalSliceAccessor(unsigned int slice, | |
67 bool readOnly) | |
68 { | |
69 if (slice >= height_) | |
70 { | |
71 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
72 } | |
73 | |
74 Orthanc::ImageAccessor accessor; | |
75 | |
76 if (readOnly) | |
77 { | |
78 accessor.AssignReadOnly(format_, width_, depth_, image_.GetPitch() * height_, | |
79 image_.GetConstRow(slice)); | |
80 } | |
81 else | |
82 { | |
83 accessor.AssignWritable(format_, width_, depth_, image_.GetPitch() * height_, | |
84 image_.GetRow(slice)); | |
85 } | |
86 | |
87 return accessor; | |
88 } | |
89 | |
90 | |
91 Orthanc::Image* ImageBuffer3D::ExtractSagittalSlice(unsigned int slice) const | |
92 { | |
93 if (slice >= width_) | |
94 { | |
95 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
96 } | |
97 | |
11 | 98 std::auto_ptr<Orthanc::Image> result(new Orthanc::Image(format_, height_, depth_, false)); |
0 | 99 |
100 unsigned int bytesPerPixel = Orthanc::GetBytesPerPixel(format_); | |
101 | |
102 for (unsigned int z = 0; z < depth_; z++) | |
103 { | |
104 //uint8_t* target = reinterpret_cast<uint8_t*>(result->GetRow(depth_ - 1 - z)); | |
105 uint8_t* target = reinterpret_cast<uint8_t*>(result->GetRow(z)); | |
106 | |
107 for (unsigned int y = 0; y < height_; y++) | |
108 { | |
109 const void* source = (reinterpret_cast<const uint8_t*>(image_.GetConstRow(y + z * height_)) + | |
110 bytesPerPixel * slice); | |
111 | |
112 memcpy(target, source, bytesPerPixel); | |
113 target += bytesPerPixel; | |
114 } | |
115 } | |
116 | |
117 return result.release(); | |
118 } | |
119 | |
120 | |
121 ImageBuffer3D::ImageBuffer3D(Orthanc::PixelFormat format, | |
122 unsigned int width, | |
123 unsigned int height, | |
124 unsigned int depth) : | |
11 | 125 image_(format, width, height * depth, false), |
0 | 126 format_(format), |
127 width_(width), | |
128 height_(height), | |
129 depth_(depth) | |
130 { | |
131 GeometryToolbox::AssignVector(voxelDimensions_, 1, 1, 1); | |
132 } | |
133 | |
134 | |
135 void ImageBuffer3D::Clear() | |
136 { | |
137 WriteLock lock(mutex_); | |
138 Orthanc::ImageProcessing::Set(image_, 0); | |
139 } | |
140 | |
141 | |
142 void ImageBuffer3D::SetAxialGeometry(const SliceGeometry& geometry) | |
143 { | |
144 WriteLock lock(mutex_); | |
145 axialGeometry_ = geometry; | |
146 } | |
147 | |
148 | |
149 void ImageBuffer3D::SetVoxelDimensions(double x, | |
150 double y, | |
151 double z) | |
152 { | |
153 if (x <= 0 || | |
154 y <= 0 || | |
155 z <= 0) | |
156 { | |
157 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
158 } | |
159 | |
160 { | |
161 WriteLock lock(mutex_); | |
162 GeometryToolbox::AssignVector(voxelDimensions_, x, y, z); | |
163 } | |
164 } | |
165 | |
166 | |
167 Vector ImageBuffer3D::GetVoxelDimensions(VolumeProjection projection) | |
168 { | |
169 ReadLock lock(mutex_); | |
170 | |
171 Vector result; | |
172 switch (projection) | |
173 { | |
174 case VolumeProjection_Axial: | |
175 result = voxelDimensions_; | |
176 break; | |
177 | |
178 case VolumeProjection_Coronal: | |
179 GeometryToolbox::AssignVector(result, voxelDimensions_[0], voxelDimensions_[2], voxelDimensions_[1]); | |
180 break; | |
181 | |
182 case VolumeProjection_Sagittal: | |
183 GeometryToolbox::AssignVector(result, voxelDimensions_[1], voxelDimensions_[2], voxelDimensions_[0]); | |
184 break; | |
185 | |
186 default: | |
187 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
188 } | |
189 | |
190 return result; | |
191 } | |
192 | |
193 | |
194 void ImageBuffer3D::GetSliceSize(unsigned int& width, | |
195 unsigned int& height, | |
196 VolumeProjection projection) | |
197 { | |
198 switch (projection) | |
199 { | |
200 case VolumeProjection_Axial: | |
201 width = width_; | |
202 height = height_; | |
203 break; | |
204 | |
205 case VolumeProjection_Coronal: | |
206 width = width_; | |
207 height = depth_; | |
208 break; | |
209 | |
210 case VolumeProjection_Sagittal: | |
211 width = height_; | |
212 height = depth_; | |
213 break; | |
214 | |
215 default: | |
216 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
217 } | |
218 } | |
219 | |
220 | |
221 ParallelSlices* ImageBuffer3D::GetGeometry(VolumeProjection projection) | |
222 { | |
223 std::auto_ptr<ParallelSlices> result(new ParallelSlices); | |
224 | |
225 switch (projection) | |
226 { | |
227 case VolumeProjection_Axial: | |
228 for (unsigned int z = 0; z < depth_; z++) | |
229 { | |
230 Vector origin = axialGeometry_.GetOrigin(); | |
231 origin += static_cast<double>(z) * voxelDimensions_[2] * axialGeometry_.GetNormal(); | |
232 | |
233 result->AddSlice(origin, | |
234 axialGeometry_.GetAxisX(), | |
235 axialGeometry_.GetAxisY()); | |
236 } | |
237 break; | |
238 | |
239 case VolumeProjection_Coronal: | |
240 for (unsigned int y = 0; y < height_; y++) | |
241 { | |
242 Vector origin = axialGeometry_.GetOrigin(); | |
243 origin += static_cast<double>(y) * voxelDimensions_[1] * axialGeometry_.GetAxisY(); | |
244 origin += static_cast<double>(depth_ - 1) * voxelDimensions_[2] * axialGeometry_.GetNormal(); | |
245 | |
246 result->AddSlice(origin, | |
247 axialGeometry_.GetAxisX(), | |
248 -axialGeometry_.GetNormal()); | |
249 } | |
250 break; | |
251 | |
252 case VolumeProjection_Sagittal: | |
253 for (unsigned int x = 0; x < width_; x++) | |
254 { | |
255 Vector origin = axialGeometry_.GetOrigin(); | |
256 origin += static_cast<double>(x) * voxelDimensions_[0] * axialGeometry_.GetAxisX(); | |
257 origin += static_cast<double>(depth_ - 1) * voxelDimensions_[2] * axialGeometry_.GetNormal(); | |
258 | |
259 result->AddSlice(origin, | |
260 axialGeometry_.GetAxisY(), | |
261 -axialGeometry_.GetNormal()); | |
262 } | |
263 break; | |
264 | |
265 default: | |
266 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
267 } | |
268 | |
269 return result.release(); | |
270 } | |
271 | |
272 | |
273 ImageBuffer3D::SliceReader::SliceReader(ImageBuffer3D& that, | |
274 VolumeProjection projection, | |
275 unsigned int slice) : | |
276 lock_(that.mutex_) | |
277 { | |
278 switch (projection) | |
279 { | |
280 case VolumeProjection_Axial: | |
281 accessor_ = that.GetAxialSliceAccessor(slice, true); | |
282 break; | |
283 | |
284 case VolumeProjection_Coronal: | |
285 accessor_ = that.GetCoronalSliceAccessor(slice, true); | |
286 break; | |
287 | |
288 case VolumeProjection_Sagittal: | |
289 sagittal_.reset(that.ExtractSagittalSlice(slice)); | |
290 accessor_ = *sagittal_; | |
291 break; | |
292 | |
293 default: | |
294 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
295 } | |
296 } | |
297 | |
298 | |
299 void ImageBuffer3D::SliceWriter::Flush() | |
300 { | |
301 if (sagittal_.get() != NULL) | |
302 { | |
303 // TODO | |
304 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | |
305 } | |
306 } | |
307 | |
308 | |
309 ImageBuffer3D::SliceWriter::SliceWriter(ImageBuffer3D& that, | |
310 VolumeProjection projection, | |
311 unsigned int slice) : | |
312 lock_(that.mutex_) | |
313 { | |
314 switch (projection) | |
315 { | |
316 case VolumeProjection_Axial: | |
317 accessor_ = that.GetAxialSliceAccessor(slice, false); | |
318 break; | |
319 | |
320 case VolumeProjection_Coronal: | |
321 accessor_ = that.GetCoronalSliceAccessor(slice, false); | |
322 break; | |
323 | |
324 case VolumeProjection_Sagittal: | |
325 sagittal_.reset(that.ExtractSagittalSlice(slice)); | |
326 accessor_ = *sagittal_; | |
327 break; | |
328 | |
329 default: | |
330 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); | |
331 } | |
332 } | |
333 } |