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