Program: gdcm
Module: $RCSfile: gdcmPixelReadConvert.cxx,v $
Language: C++
- Date: $Date: 2005/02/16 10:19:19 $
- Version: $Revision: 1.51 $
+ Date: $Date: 2005/05/30 01:30:39 $
+ Version: $Revision: 1.63 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
=========================================================================*/
+#include "gdcmPixelReadConvert.h"
#include "gdcmDebug.h"
#include "gdcmFile.h"
#include "gdcmGlobal.h"
#include "gdcmTS.h"
-#include "gdcmPixelReadConvert.h"
#include "gdcmDocEntry.h"
#include "gdcmRLEFramesInfo.h"
#include "gdcmJPEGFragmentsInfo.h"
namespace gdcm
{
+
+//bool ReadMPEGFile (std::ifstream *fp, void *image_buffer, size_t lenght);
+bool gdcm_read_JPEG2000_file (void* raw,
+ char *inputdata, size_t inputlength);
//-----------------------------------------------------------------------------
#define str2num(str, typeNum) *((typeNum *)(str))
|| Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ExplicitVRBigEndian
|| Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::DeflatedExplicitVRLittleEndian;
+ IsMPEG = Global::GetTS()->IsMPEG(ts);
IsJPEG2000 = Global::GetTS()->IsJPEG2000(ts);
IsJPEGLS = Global::GetTS()->IsJPEGLS(ts);
IsJPEGLossy = Global::GetTS()->IsJPEGLossy(ts);
return false;
}
}
+ else if ( IsMPEG )
+ {
+ //gdcmWarningMacro( "Sorry, MPEG not yet taken into account" );
+ //return false;
+// ReadMPEGFile(fp, Raw, PixelDataLength); // fp has already been seek to start of mpeg
+ return true;
+ }
else
{
// Default case concerns JPEG family
{
if ( IsJPEG2000 )
{
- 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;
+ // FIXME this is really ugly but it seems I have to load the complete
+ // jpeg2000 stream to use jasper:
+ // I don't think we'll ever be able to deal with multiple fragments properly
+
+ unsigned long inputlength = 0;
+ JPEGFragment *jpegfrag = JPEGInfo->GetFirstFragment();
+ while( jpegfrag )
+ {
+ inputlength += jpegfrag->GetLength();
+ jpegfrag = JPEGInfo->GetNextFragment();
+ }
+ gdcmAssertMacro( inputlength != 0);
+ uint8_t *inputdata = new uint8_t[inputlength];
+ char *pinputdata = (char*)inputdata;
+ jpegfrag = JPEGInfo->GetFirstFragment();
+ while( jpegfrag )
+ {
+ fp->seekg( jpegfrag->GetOffset(), std::ios::beg);
+ fp->read(pinputdata, jpegfrag->GetLength());
+ pinputdata += jpegfrag->GetLength();
+ jpegfrag = JPEGInfo->GetNextFragment();
+ }
+ // Warning the inputdata buffer is delete in the function
+ if ( ! gdcm_read_JPEG2000_file( Raw,
+ (char*)inputdata, inputlength ) )
+ {
+ return true;
+ }
}
if ( IsJPEGLS )
{
+ // WARNING : JPEG-LS is NOT the 'classical' Jpeg Lossless :
+ // [JPEG-LS is the basis for new lossless/near-lossless compression
+ // standard for continuous-tone images intended for JPEG2000. The standard
+ // is based on the LOCO-I algorithm (LOw COmplexity LOssless COmpression
+ // for Images) developed at Hewlett-Packard Laboratories]
+ //
+ // see http://datacompression.info/JPEGLS.shtml
+ //
+
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;
}
-
- // else ??
- // Precompute the offset localRaw will be shifted with
- int length = XSize * YSize * SamplesPerPixel;
- int numberBytes = BitsAllocated / 8;
-
- JPEGInfo->DecompressFromFile(fp, Raw, BitsStored, numberBytes, length );
- return true;
+ else
+ {
+ // Precompute the offset localRaw will be shifted with
+ int length = XSize * YSize * SamplesPerPixel;
+ int numberBytes = BitsAllocated / 8;
+
+ JPEGInfo->DecompressFromFile(fp, Raw, BitsStored, numberBytes, length );
+ return true;
+ }
}
/**
}
}
-
-
/**
* \brief Deal with Grey levels i.e. re-arange them
* to have low values = dark, high values = bright
if (!IsMonochrome1)
return;
- int i; // to please M$VC6
+ uint32_t i; // to please M$VC6
+ int16_t j;
if (!PixelSign)
{
if ( BitsAllocated == 16 )
{
uint16_t mask =1;
- int bitStored = 12;
- for (i=0; i<BitsStored-1; i++)
+ for (j=0; j<BitsStored-1; j++)
{
mask = (mask << 1) +1; // will be fff when BitsStored=12
}
{
if ( BitsAllocated == 8 )
{
- int8_t smask8 = 255;
- int8_t *deb = (int8_t *)Raw;
+ uint8_t smask8 = 255;
+ uint8_t *deb = (uint8_t *)Raw;
for (i=0; i<RawSize; i++)
{
*deb = smask8 - *deb;
}
if ( BitsAllocated == 16 )
{
- int16_t smask16 = 65535;
- int16_t *deb = (int16_t *)Raw;
+ uint16_t smask16 = 65535;
+ uint16_t *deb = (uint16_t *)Raw;
for (i=0; i<RawSize/2; i++)
{
*deb = smask16 - *deb;
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;
-
- 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;
+ 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) 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;
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff