Program: gdcm
Module: $RCSfile: gdcmPixelReadConvert.cxx,v $
Language: C++
- Date: $Date: 2005/02/04 16:51:36 $
- Version: $Revision: 1.48 $
+ Date: $Date: 2005/03/31 09:46:51 $
+ Version: $Revision: 1.54 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
PixelOffset = file->GetPixelOffset();
PixelDataLength = file->GetPixelAreaLength();
- RLEInfo = file->GetRLEInfo();
- JPEGInfo = file->GetJPEGInfo();
+ RLEInfo = file->GetRLEInfo();
+ JPEGInfo = file->GetJPEGInfo();
+
+ IsMonochrome = file->IsMonochrome();
+ IsMonochrome1 = file->IsMonochrome1();
+ IsPaletteColor = file->IsPaletteColor();
+ IsYBRFull = file->IsYBRFull();
PlanarConfiguration = file->GetPlanarConfiguration();
- IsMonochrome = file->IsMonochrome();
- IsPaletteColor = file->IsPaletteColor();
- IsYBRFull = file->IsYBRFull();
/////////////////////////////////////////////////////////////////
// LUT section:
LutRedData = (uint8_t*)file->GetEntryBinArea( 0x0028, 0x1201 );
if ( ! LutRedData )
{
- gdcmVerboseMacro( "Unable to read Red LUT data" );
+ gdcmWarningMacro( "Unable to read Red LUT data" );
}
// //// Green round:
LutGreenData = (uint8_t*)file->GetEntryBinArea(0x0028, 0x1202 );
if ( ! LutGreenData)
{
- gdcmVerboseMacro( "Unable to read Green LUT data" );
+ gdcmWarningMacro( "Unable to read Green LUT data" );
}
// //// Blue round:
LutBlueData = (uint8_t*)file->GetEntryBinArea( 0x0028, 0x1203 );
if ( ! LutBlueData )
{
- gdcmVerboseMacro( "Unable to read Blue LUT data" );
+ gdcmWarningMacro( "Unable to read Blue LUT data" );
}
}
//// First stage: get our hands on the Pixel Data.
if ( !fp )
{
- gdcmVerboseMacro( "Unavailable file pointer." );
+ gdcmWarningMacro( "Unavailable file pointer." );
return false;
}
fp->seekg( PixelOffset, std::ios::beg );
if( fp->fail() || fp->eof())
{
- gdcmVerboseMacro( "Unable to find PixelOffset in file." );
+ gdcmWarningMacro( "Unable to find PixelOffset in file." );
return false;
}
// variable). But RawSize is the right size of the image !
if( PixelDataLength != RawSize)
{
- gdcmVerboseMacro( "Mismatch between PixelReadConvert : "
+ gdcmWarningMacro( "Mismatch between PixelReadConvert : "
<< PixelDataLength << " and RawSize : " << RawSize );
}
if( PixelDataLength > RawSize)
if ( fp->fail() || fp->eof())
{
- gdcmVerboseMacro( "Reading of Raw pixel data failed." );
+ gdcmWarningMacro( "Reading of Raw pixel data failed." );
return false;
}
}
{
if ( ! RLEInfo->DecompressRLEFile( fp, Raw, XSize, YSize, ZSize, BitsAllocated ) )
{
- gdcmVerboseMacro( "RLE decompressor failed." );
+ gdcmWarningMacro( "RLE decompressor failed." );
return false;
}
}
// Default case concerns JPEG family
if ( ! ReadAndDecompressJPEGFile( fp ) )
{
- gdcmVerboseMacro( "JPEG decompressor failed." );
+ gdcmWarningMacro( "JPEG decompressor failed." );
return false;
}
}
//// Third stage: twigle the bytes and bits.
ConvertReorderEndianity();
ConvertReArrangeBits();
+ ConvertFixGreyLevels();
ConvertHandleColor();
return true;
{
if ( IsJPEG2000 )
{
- gdcmVerboseMacro( "Sorry, JPEG2000 not yet taken into account" );
+ gdcmWarningMacro( "Sorry, JPEG2000 not yet taken into account" );
fp->seekg( JPEGInfo->GetFirstFragment()->GetOffset(), std::ios::beg);
// if ( ! gdcm_read_JPEG2000_file( fp,Raw ) )
return false;
if ( IsJPEGLS )
{
- gdcmVerboseMacro( "Sorry, JPEG-LS not yet taken into account" );
+ gdcmWarningMacro( "Sorry, JPEG-LS not yet taken into account" );
fp->seekg( JPEGInfo->GetFirstFragment()->GetOffset(), std::ios::beg);
// if ( ! gdcm_read_JPEGLS_file( fp,Raw ) )
return false;
&lengthR, &debR, &nbitsR );
if( nbRead != 3 )
{
- gdcmVerboseMacro( "Wrong Red LUT descriptor" );
+ gdcmWarningMacro( "Wrong Red LUT descriptor" );
}
int lengthG; // Green LUT length in Bytes
&lengthG, &debG, &nbitsG );
if( nbRead != 3 )
{
- gdcmVerboseMacro( "Wrong Green LUT descriptor" );
+ gdcmWarningMacro( "Wrong Green LUT descriptor" );
}
int lengthB; // Blue LUT length in Bytes
&lengthB, &debB, &nbitsB );
if( nbRead != 3 )
{
- gdcmVerboseMacro( "Wrong Blue LUT descriptor" );
+ gdcmWarningMacro( "Wrong Blue LUT descriptor" );
}
////////////////////////////////////////////////////////
}
break;
default:
- gdcmVerboseMacro("SwapCode value (16 bits) not allowed.");
+ gdcmWarningMacro("SwapCode value (16 bits) not allowed.");
}
}
else if( BitsAllocated == 32 )
}
break;
default:
- gdcmVerboseMacro("SwapCode value (32 bits) not allowed." );
+ gdcmWarningMacro("SwapCode value (32 bits) not allowed." );
}
}
}
}
}
+/**
+ * \brief Deal with Grey levels i.e. re-arange them
+ * to have low values = dark, high values = bright
+ */
+void PixelReadConvert::ConvertFixGreyLevels()
+{
+ if (!IsMonochrome1)
+ return;
+
+ uint32_t i; // to please M$VC6
+ int16_t j;
+
+ if (!PixelSign)
+ {
+ if ( BitsAllocated == 8 )
+ {
+ uint8_t *deb = (uint8_t *)Raw;
+ for (i=0; i<RawSize; i++)
+ {
+ *deb = 255 - *deb;
+ deb++;
+ }
+ return;
+ }
+
+ if ( BitsAllocated == 16 )
+ {
+ uint16_t mask =1;
+ for (j=0; j<BitsStored-1; j++)
+ {
+ mask = (mask << 1) +1; // will be fff when BitsStored=12
+ }
+
+ uint16_t *deb = (uint16_t *)Raw;
+ for (i=0; i<RawSize/2; i++)
+ {
+ *deb = mask - *deb;
+ deb++;
+ }
+ return;
+ }
+ }
+ else
+ {
+ if ( BitsAllocated == 8 )
+ {
+ uint8_t smask8 = 255;
+ uint8_t *deb = (uint8_t *)Raw;
+ for (i=0; i<RawSize; i++)
+ {
+ *deb = smask8 - *deb;
+ deb++;
+ }
+ return;
+ }
+ if ( BitsAllocated == 16 )
+ {
+ uint16_t smask16 = 65535;
+ uint16_t *deb = (uint16_t *)Raw;
+ for (i=0; i<RawSize/2; i++)
+ {
+ *deb = smask16 - *deb;
+ deb++;
+ }
+ return;
+ }
+ }
+}
+
/**
* \brief Re-arrange the bits within the bytes.
- * @return Boolean
+ * @return Boolean always true
*/
bool PixelReadConvert::ConvertReArrangeBits() throw ( FormatError )
{
}
else
{
- gdcmVerboseMacro("Weird image");
+ gdcmWarningMacro("Weird image");
throw FormatError( "Weird image !?" );
}
}
int l = XSize * YSize;
int nbFrames = ZSize;
- uint8_t *a = copyRaw;
+ uint8_t *a = copyRaw + 0;
uint8_t *b = copyRaw + l;
- uint8_t *c = copyRaw + l + l;
- double R, G, B;
+ uint8_t *c = copyRaw + l+ l;
+ int32_t R, G, B;
/// \todo : Replace by the 'well known' integer computation
/// counterpart. Refer to
{
for ( int j = 0; j < l; j++ )
{
- R = 1.164 *(*a-16) + 1.596 *(*c -128) + 0.5;
- G = 1.164 *(*a-16) - 0.813 *(*c -128) - 0.392 *(*b -128) + 0.5;
- B = 1.164 *(*a-16) + 2.017 *(*b -128) + 0.5;
+ R = 38142 *(*a-16) + 52298 *(*c -128);
+ G = 38142 *(*a-16) - 26640 *(*c -128) - 12845 *(*b -128);
+ B = 38142 *(*a-16) + 66093 *(*b -128);
+
+ R = (R+16384)>>15;
+ G = (G+16384)>>15;
+ B = (B+16384)>>15;
- if (R < 0.0) R = 0.0;
- if (G < 0.0) G = 0.0;
- if (B < 0.0) B = 0.0;
- if (R > 255.0) R = 255.0;
- if (G > 255.0) G = 255.0;
- if (B > 255.0) B = 255.0;
+ if (R < 0) R = 0;
+ if (G < 0) G = 0;
+ if (B < 0) B = 0;
+ if (R > 255) R = 255;
+ if (G > 255) G = 255;
+ if (B > 255) B = 255;
*(localRaw++) = (uint8_t)R;
*(localRaw++) = (uint8_t)G;
}
else
{
- gdcmVerboseMacro("Set as RLE file but NO RLEinfo present.");
+ gdcmWarningMacro("Set as RLE file but NO RLEinfo present.");
}
}
}
else
{
- gdcmVerboseMacro("Set as JPEG file but NO JPEGinfo present.");
+ gdcmWarningMacro("Set as JPEG file but NO JPEGinfo present.");
}
}
}
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff