Mercurial > hg > orthanc-stone

comparison Framework/Volumes/ImageBuffer3D.cpp @ 0:351ab0da0150

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