- // When no LUT or LUT conversion fails, return the decompressed
- return PixelConverter->GetDecompressed();
- }
-}
-
-/**
- * \brief
- * Read the pixels from disk (uncompress if necessary),
- * Transforms YBR pixels, if any, into RGB pixels
- * Transforms 3 planes R, G, B, if any, into a single RGB Plane
- * Transforms single Grey plane + 3 Palettes into a RGB Plane
- * Copies at most MaxSize bytes of pixel data to caller allocated
- * memory space.
- * \warning This function allows people that want to build a volume
- * from an image stack *not to* have, first to get the image pixels,
- * and then move them to the volume area.
- * It's absolutely useless for any VTK user since vtk chooses
- * to invert the lines of an image, that is the last line comes first
- * (for some axis related reasons?). Hence he will have
- * to load the image line by line, starting from the end.
- * VTK users have to call GetImageData
- *
- * @param destination Address (in caller's memory space) at which the
- * pixel data should be copied
- * @param maxSize Maximum number of bytes to be copied. When MaxSize
- * is not sufficient to hold the pixel data the copy is not
- * executed (i.e. no partial copy).
- * @return On success, the number of bytes actually copied. Zero on
- * failure e.g. MaxSize is lower than necessary.
- */
-size_t File::GetImageDataIntoVector (void* destination, size_t maxSize)
-{
- if ( ! GetDecompressed() )
- {
- // If the decompression failed nothing can be done.
- return 0;
+ // if no values, xspacing is set to 1.0
+ if( nbValues == 0 )
+ xspacing = 1.0;
+ // if single value is found, xspacing is defaulted to yspacing
+ if( nbValues == 1 )
+ xspacing = yspacing;
+
+ if ( xspacing == 0.0 )
+ xspacing = 1.0;
+
+ return xspacing;
+
+ }
+
+ // to avoid troubles with David Clunie's-like images
+ if ( xspacing == 0. && yspacing == 0.)
+ return 1.;
+
+ if ( xspacing == 0.)
+ {
+ gdcmWarningMacro("gdcmData/CT-MONO2-8-abdo.dcm-like problem");
+ // seems to be a bug in the header ...
+ nbValues = sscanf( strSpacing.c_str(), "%f \\0\\%f ", &yspacing, &xspacing);
+ gdcmAssertMacro( nbValues == 2 );
+ }
+
+ return xspacing;
+}
+
+/**
+ * \brief gets the info from 0028,0030 : Pixel Spacing
+ * (first in 0018,1164 : ImagerPixelSpacing)
+ * else 1.0
+ * @return Y dimension of a pixel
+ */
+float File::GetYSpacing()
+{
+ float yspacing = 1.;
+ int nbValues;
+ // To follow David Clunie's advice, we first check ImagerPixelSpacing
+ // (never saw any image with that field :-(
+
+ const std::string &strImagerPixelSpacing = GetEntryValue(0x0018,0x1164);
+ if( strImagerPixelSpacing != GDCM_UNFOUND )
+ {
+ nbValues = sscanf( strImagerPixelSpacing.c_str(), "%f", &yspacing);
+
+ // if sscanf cannot read any float value, it won't affect yspacing
+ if( nbValues == 0 )
+ yspacing = 1.0;
+
+ if ( yspacing == 0.0 )
+ yspacing = 1.0;
+
+ return yspacing;
+ }
+
+ std::string strSpacing = GetEntryValue(0x0028,0x0030);
+ if ( strSpacing == GDCM_UNFOUND )
+ {
+ gdcmWarningMacro("Unfound Pixel Spacing (0028,0030)");
+ return 1.;
+ }
+
+ // if sscanf cannot read any float value, it won't affect yspacing
+ nbValues = sscanf( strSpacing.c_str(), "%f", &yspacing);
+
+ // if no values, yspacing is set to 1.0
+ if( nbValues == 0 )
+ yspacing = 1.0;
+
+ if ( yspacing == 0.0 )
+ yspacing = 1.0;
+
+ return yspacing;
+}
+
+/**
+ * \brief gets the info from 0018,0088 : Space Between Slices
+ * else from 0018,0050 : Slice Thickness
+ * else 1.0
+ * @return Z dimension of a voxel-to be
+ */
+float File::GetZSpacing()
+{
+ // Spacing Between Slices : distance between the middle of 2 slices
+ // Slices may be :
+ // jointives (Spacing between Slices = Slice Thickness)
+ // overlapping (Spacing between Slices < Slice Thickness)
+ // disjointes (Spacing between Slices > Slice Thickness)
+ // Slice Thickness : epaisseur de tissus sur laquelle est acquis le signal
+ // It only concerns the MRI guys, not people wanting to visualize volmues
+ // If Spacing Between Slices is Missing,
+ // we suppose slices joint together
+
+ const std::string &strSpacingBSlices = GetEntryValue(0x0018,0x0088);
+
+ if ( strSpacingBSlices == GDCM_UNFOUND )
+ {
+ gdcmWarningMacro("Unfound Spacing Between Slices (0018,0088)");
+ const std::string &strSliceThickness = GetEntryValue(0x0018,0x0050);
+ if ( strSliceThickness == GDCM_UNFOUND )
+ {
+ gdcmWarningMacro("Unfound Slice Thickness (0018,0050)");
+ return 1.;
+ }
+ else
+ {
+ // if no 'Spacing Between Slices' is found,
+ // we assume slices join together
+ // (no overlapping, no interslice gap)
+ // if they don't, we're fucked up
+ return (float)atof( strSliceThickness.c_str() );
+ }