00001
00012
00013
00014 #include "four_byte_volume_pixel_dataset.h"
00015 #include "four_byte_image_pixel_dataset.h"
00016
00017 #include <limits>
00018
00019 namespace imedgine
00020 {
00021
00022
00023 FourByteVolumePixelDataset::FourByteVolumePixelDataset(
00024 dataset_key_type dataset_key, volume_pointer_type volume)
00025 : VolumePixelDataset(FOUR_BYTE_VOLUME_PIXEL_DATASET, dataset_key, 4),
00026 resampling_filter_(resampling_filter_type::New()),
00027 slice_extractor_(slice_extractor_type::New()),
00028 image_extractor_(image_extractor_type::New()),
00029 volume_intensity_filter_(volume_intensity_filter_type::New()),
00030 image_intensity_filter_(image_intensity_filter_type::New())
00031 {
00032 resampling_filter_->SetTransform(transform_);
00033 resampling_filter_->SetDefaultPixelValue(std::numeric_limits<pixel_type>::min());
00034
00035 if (volume.IsNull() == false)
00036 {
00037 this->setDatasetInternal(volume);
00038 }
00039 }
00040
00041
00042
00043 FourByteVolumePixelDataset::FourByteVolumePixelDataset(FourByteVolumePixelDataset const& src)
00044 : VolumePixelDataset(src),
00045 resampling_filter_(resampling_filter_type::New()),
00046 slice_extractor_(slice_extractor_type::New()),
00047 image_extractor_(image_extractor_type::New()),
00048 volume_intensity_filter_(volume_intensity_filter_type::New()),
00049 image_intensity_filter_(image_intensity_filter_type::New())
00050 {
00051 resampling_filter_->SetTransform(transform_);
00052 resampling_filter_->SetDefaultPixelValue(std::numeric_limits<pixel_type>::min());
00053 }
00054
00055
00056
00057 FourByteVolumePixelDataset::~FourByteVolumePixelDataset()
00058 {
00059 }
00060
00061
00062
00063 external_data_pointer_type FourByteVolumePixelDataset::getData() const
00064 throw(NullPointerException)
00065 {
00066 if (dataset_.IsNull())
00067 {
00068 throw(NullPointerException("FourByteVolumePixelDataset::getData()"));
00069 }
00070
00071 volume_intensity_filter_->UpdateLargestPossibleRegion();
00072
00073 external_volume_pointer_type volume = volume_intensity_filter_->GetOutput();
00074 volume->DisconnectPipeline();
00075 volume->GetPixelContainer()->ContainerManageMemoryOff();
00076
00077 return(volume->GetBufferPointer());
00078 }
00079
00080
00081
00082 void FourByteVolumePixelDataset::setDataset(volume_pointer_type dataset)
00083 {
00084 setDatasetInternal(dataset);
00085 is_dirty_ = true;
00086 }
00087
00088
00089
00090 void FourByteVolumePixelDataset::setDatasetInternal(volume_pointer_type dataset)
00091 {
00092 dataset_ = dataset;
00093 is_data_set_ = true;
00094
00095 min_pixel_value_ = std::numeric_limits<pixel_type>::max();
00096 max_pixel_value_ = 0;
00097
00098 const_volume_iterator_type vol_iter(
00099 dataset_, dataset_->GetLargestPossibleRegion());
00100 for (vol_iter.GoToBegin(); !vol_iter.IsAtEnd(); ++vol_iter)
00101 {
00102 if (vol_iter.Value() > max_pixel_value_)
00103 {
00104 max_pixel_value_ = vol_iter.Value();
00105 }
00106 if (vol_iter.Value() < min_pixel_value_)
00107 {
00108 min_pixel_value_ = vol_iter.Value();
00109 }
00110 }
00111
00112 std::cout << "Minimum pixel value: " << min_pixel_value_ << std::endl;
00113 std::cout << "Maximum pixel value: " << max_pixel_value_ << std::endl;
00114
00115 region_type volume_region = dataset_->GetLargestPossibleRegion();
00116 region_size_type volume_size = volume_region.GetSize();
00117 dataset_size_[X_DIMENSION] = volume_size[X_DIMENSION];
00118 dataset_size_[Y_DIMENSION] = volume_size[Y_DIMENSION];
00119 dataset_size_[Z_DIMENSION] = volume_size[Z_DIMENSION];
00120
00121 region_size_type region_size = volume_size;
00122 region_size[Z_DIMENSION] = 0;
00123 xy_region_to_extract_.SetSize(region_size);
00124
00125 region_size = volume_size;
00126 region_size[Y_DIMENSION] = 0;
00127 xz_region_to_extract_.SetSize(region_size);
00128
00129 region_size = volume_size;
00130 region_size[X_DIMENSION] = 0;
00131 yz_region_to_extract_.SetSize(region_size);
00132
00133 xy_region_to_extract_.SetIndex(volume_region.GetIndex());
00134 xz_region_to_extract_.SetIndex(volume_region.GetIndex());
00135 yz_region_to_extract_.SetIndex(volume_region.GetIndex());
00136
00137 transform_->SetIdentity();
00138 resampling_filter_->SetOutputSpacing(dataset_->GetSpacing());
00139 resampling_filter_->SetOutputOrigin(dataset_->GetOrigin());
00140 resampling_filter_->SetSize(dataset_->GetLargestPossibleRegion().GetSize());
00141
00142 image_extractor_->SetInput(dataset_);
00143
00144 resampling_filter_->SetInput(dataset_);
00145 slice_extractor_->SetInput(resampling_filter_->GetOutput());
00146 image_intensity_filter_->SetInput(slice_extractor_->GetOutput());
00147
00148 image_intensity_filter_->SetWindowMinimum(static_cast<pixel_type>(min_pixel_value_));
00149 image_intensity_filter_->SetWindowMaximum(static_cast<pixel_type>(max_pixel_value_));
00150 image_intensity_filter_->SetOutputMinimum(0);
00151 image_intensity_filter_->SetOutputMaximum(
00152 std::numeric_limits<external_pixel_type>::max());
00153
00154 volume_intensity_filter_->SetInput(dataset_);
00155 volume_intensity_filter_->SetWindowMinimum(static_cast<pixel_type>(min_pixel_value_));
00156 volume_intensity_filter_->SetWindowMaximum(static_cast<pixel_type>(max_pixel_value_));
00157 volume_intensity_filter_->SetOutputMinimum(0);
00158 volume_intensity_filter_->SetOutputMaximum(
00159 std::numeric_limits<external_pixel_type>::max());
00160
00161 xy_slice_rois_.resize(dataset_size_[Z_DIMENSION]);
00162 xz_slice_rois_.resize(dataset_size_[Y_DIMENSION]);
00163 yz_slice_rois_.resize(dataset_size_[X_DIMENSION]);
00164 }
00165
00166
00167
00168 FourByteVolumePixelDataset::const_volume_pointer_type
00169 FourByteVolumePixelDataset::getDataset() const
00170 {
00171 return(dataset_);
00172 }
00173
00174
00175
00176 FourByteVolumePixelDataset::volume_pointer_type
00177 FourByteVolumePixelDataset::getDataset()
00178 {
00179 return(dataset_);
00180 }
00181
00182
00183
00184
00185 void FourByteVolumePixelDataset::setIntensity(double window, double level)
00186 {
00187 if (level > max_pixel_value_)
00188 {
00189 level = max_pixel_value_;
00190 }
00191 else if (level < min_pixel_value_)
00192 {
00193 level = min_pixel_value_;
00194 }
00195
00196 double new_window_min = level - static_cast<int>(window / 2.0);
00197 double new_window_max = level + static_cast<int>(window / 2.0);
00198
00199
00200 if (new_window_min < std::numeric_limits<pixel_type>::min())
00201 {
00202 new_window_min = std::numeric_limits<pixel_type>::min();
00203 }
00204 else if (new_window_max > std::numeric_limits<pixel_type>::max())
00205 {
00206 new_window_max = std::numeric_limits<pixel_type>::max();
00207 }
00208
00209 image_intensity_filter_->SetWindowMinimum(
00210 static_cast<pixel_type>(new_window_min));
00211
00212 image_intensity_filter_->SetWindowMaximum(
00213 static_cast<pixel_type>(new_window_max));
00214
00215 volume_intensity_filter_->SetWindowMinimum(
00216 static_cast<pixel_type>(new_window_min));
00217
00218 volume_intensity_filter_->SetWindowMaximum(
00219 static_cast<pixel_type>(new_window_max));
00220 }
00221
00222
00223
00224 double FourByteVolumePixelDataset::getIntensityWindow() const
00225 throw(NullPointerException)
00226 {
00227 if (image_intensity_filter_.IsNull())
00228 {
00229 throw(NullPointerException("FourByteVolumePixelDataset::getIntensityWindow()"));
00230 }
00231 return(static_cast<double>(image_intensity_filter_->GetWindow()));
00232 }
00233
00234
00235
00236 double FourByteVolumePixelDataset::getIntensityLevel() const
00237 throw(NullPointerException)
00238 {
00239 if (image_intensity_filter_.IsNull())
00240 {
00241 throw(NullPointerException("FourByteVolumePixelDataset::getIntensityLevel()"));
00242 }
00243 return(static_cast<double>(image_intensity_filter_->GetLevel()));
00244 }
00245
00246
00247
00248 external_data_pointer_type FourByteVolumePixelDataset::getSliceXY(
00249 index_type z_index)
00250 throw(NullPointerException, IndexOutOfBoundsException)
00251 {
00252 if (dataset_.IsNull() || slice_extractor_.IsNull())
00253 {
00254 throw(NullPointerException("FourByteVolumePixelDataset::getSliceXY"));
00255 }
00256 if (z_index >= dataset_size_[Z_DIMENSION])
00257 {
00258 throw(IndexOutOfBoundsException("FourByteVolumePixelDataset::getSliceXY"));
00259 }
00260
00261 xy_region_to_extract_.SetIndex(Z_DIMENSION, z_index);
00262 slice_extractor_->SetExtractionRegion(xy_region_to_extract_);
00263
00264 image_intensity_filter_->UpdateLargestPossibleRegion();
00265
00266 external_image_type::Pointer slice = image_intensity_filter_->GetOutput();
00267 slice->DisconnectPipeline();
00268 slice->GetPixelContainer()->ContainerManageMemoryOff();
00269
00270 return(slice->GetBufferPointer());
00271 }
00272
00273
00274
00275 external_data_pointer_type FourByteVolumePixelDataset::getSliceXZ(
00276 index_type y_index)
00277 throw(NullPointerException, IndexOutOfBoundsException)
00278 {
00279 if (dataset_.IsNull() || slice_extractor_.IsNull())
00280 {
00281 throw(NullPointerException("FourByteVolumePixelDataset::getSliceXZ"));
00282 }
00283 if (y_index >= dataset_size_[Y_DIMENSION])
00284 {
00285 throw(IndexOutOfBoundsException("FourByteVolumePixelDataset::getSliceXZ"));
00286 }
00287
00288 xz_region_to_extract_.SetIndex(Y_DIMENSION, y_index);
00289 slice_extractor_->SetExtractionRegion(xz_region_to_extract_);
00290 image_intensity_filter_->UpdateLargestPossibleRegion();
00291
00292 external_image_type::Pointer slice = image_intensity_filter_->GetOutput();
00293 slice->DisconnectPipeline();
00294 slice->GetPixelContainer()->ContainerManageMemoryOff();
00295
00296 return(slice->GetBufferPointer());
00297 }
00298
00299
00300
00301 external_data_pointer_type FourByteVolumePixelDataset::getSliceYZ(
00302 index_type x_index)
00303 throw(NullPointerException, IndexOutOfBoundsException)
00304 {
00305 if (dataset_.IsNull() || slice_extractor_.IsNull())
00306 {
00307 throw(NullPointerException("FourByteVolumePixelDataset::getSliceYZ"));
00308 }
00309 if (x_index >= dataset_size_[X_DIMENSION])
00310 {
00311 throw(IndexOutOfBoundsException("FourByteVolumePixelDataset::getSliceYZ"));
00312 }
00313
00314 yz_region_to_extract_.SetIndex(X_DIMENSION, x_index);
00315 slice_extractor_->SetExtractionRegion(yz_region_to_extract_);
00316 image_intensity_filter_->UpdateLargestPossibleRegion();
00317
00318 external_image_type::Pointer slice = image_intensity_filter_->GetOutput();
00319 slice->DisconnectPipeline();
00320 slice->GetPixelContainer()->ContainerManageMemoryOff();
00321
00322 return(slice->GetBufferPointer());
00323 }
00324
00325
00326
00327 dataset_pointer_type FourByteVolumePixelDataset::getImageXY(
00328 index_type z_index, dataset_key_type image_key)
00329 throw(NullPointerException, IndexOutOfBoundsException)
00330 {
00331 if (dataset_.IsNull() || image_extractor_.IsNull())
00332 {
00333 throw(NullPointerException("OneByteVolumePixelDataset::getSliceXY"));
00334 }
00335 if (z_index >= dataset_size_[Z_DIMENSION])
00336 {
00337 throw(IndexOutOfBoundsException("OneByteVolumePixelDataset::getSliceXY"));
00338 }
00339
00340 xy_region_to_extract_.SetIndex(Z_DIMENSION, z_index);
00341 image_extractor_->SetExtractionRegion(xy_region_to_extract_);
00342
00343 image_extractor_->UpdateLargestPossibleRegion();
00344
00345 image_type::Pointer image = image_extractor_->GetOutput();
00346 image->DisconnectPipeline();
00347 image->GetPixelContainer()->ContainerManageMemoryOff();
00348
00349 FourByteImagePixelDataset* image_dataset(new FourByteImagePixelDataset(image_key, image));
00350
00351 image_dataset->setRegionsOfInterest(this->getRegionsOfInterestForSliceXY(z_index));
00352 image_dataset->setIntensity(this->getIntensityWindow(), this->getIntensityLevel());
00353
00354 return(dataset_pointer_type(image_dataset));
00355 }
00356
00357
00358
00359 dataset_pointer_type FourByteVolumePixelDataset::getImageXZ(
00360 index_type y_index, dataset_key_type image_key)
00361 throw(NullPointerException, IndexOutOfBoundsException)
00362 {
00363 if (dataset_.IsNull() || image_extractor_.IsNull())
00364 {
00365 throw(NullPointerException("OneByteVolumePixelDataset::getSliceXZ"));
00366 }
00367 if (y_index >= dataset_size_[Y_DIMENSION])
00368 {
00369 throw(IndexOutOfBoundsException("OneByteVolumePixelDataset::getSliceXZ"));
00370 }
00371
00372 xz_region_to_extract_.SetIndex(Y_DIMENSION, y_index);
00373 image_extractor_->SetExtractionRegion(xz_region_to_extract_);
00374
00375 image_extractor_->UpdateLargestPossibleRegion();
00376
00377 image_type::Pointer image = image_extractor_->GetOutput();
00378 image->DisconnectPipeline();
00379 image->GetPixelContainer()->ContainerManageMemoryOff();
00380
00381 FourByteImagePixelDataset* image_dataset(new FourByteImagePixelDataset(image_key, image));
00382
00383 image_dataset->setRegionsOfInterest(this->getRegionsOfInterestForSliceXZ(y_index));
00384 image_dataset->setIntensity(this->getIntensityWindow(), this->getIntensityLevel());
00385
00386 return(dataset_pointer_type(image_dataset));
00387 }
00388
00389
00390
00391 dataset_pointer_type FourByteVolumePixelDataset::getImageYZ(
00392 index_type x_index, dataset_key_type image_key)
00393 throw(NullPointerException, IndexOutOfBoundsException)
00394 {
00395 if (dataset_.IsNull() || image_extractor_.IsNull())
00396 {
00397 throw(NullPointerException("OneByteVolumePixelDataset::getSliceYZ"));
00398 }
00399 if (x_index >= dataset_size_[X_DIMENSION])
00400 {
00401 throw(IndexOutOfBoundsException("OneByteVolumePixelDataset::getSliceYZ"));
00402 }
00403
00404 yz_region_to_extract_.SetIndex(X_DIMENSION, x_index);
00405 image_extractor_->SetExtractionRegion(yz_region_to_extract_);
00406
00407 image_extractor_->UpdateLargestPossibleRegion();
00408
00409 image_type::Pointer image = image_extractor_->GetOutput();
00410 image->DisconnectPipeline();
00411 image->GetPixelContainer()->ContainerManageMemoryOff();
00412
00413 FourByteImagePixelDataset* image_dataset(new FourByteImagePixelDataset(image_key, image));
00414
00415 image_dataset->setRegionsOfInterest(this->getRegionsOfInterestForSliceYZ(x_index));
00416 image_dataset->setIntensity(this->getIntensityWindow(), this->getIntensityLevel());
00417
00418 return(dataset_pointer_type(image_dataset));
00419 }
00420
00421 }
