#include <gdcmHeaderHelper.h>
Inheritance diagram for gdcmHeaderHelper:
Public Member Functions | |
| gdcmHeaderHelper () | |
| constructor | |
| gdcmHeaderHelper (const char *filename, bool exception_on_error=false, bool enable_sequences=false, bool ignore_shadow=false) | |
| constructor | |
| int | GetPixelSize () |
| Returns the size (in bytes) of a single pixel of data. | |
| std::string | GetPixelType () |
| Build the Pixel Type of the image. Possible values are: -8U unsigned 8 bit, -8S signed 8 bit, -16U unsigned 16 bit, -16S signed 16 bit, -32U unsigned 32 bit, -32S signed 32 bit, -FD Double,. | |
| float | GetXSpacing () |
| gets the info from 0028,0030 : Pixel Spacing else 1. | |
| float | GetYSpacing () |
| gets the info from 0028,0030 : Pixel Spacing else 1. | |
| float | GetZSpacing () |
| gets the info from 0018,0088 : Space Between Slices else from 0018,0050 : Slice Thickness else 1. | |
| float | GetRescaleIntercept () |
| gets the info from 0028,1052 : Rescale Intercept | |
| float | GetRescaleSlope () |
| gets the info from 0028,1053 : Rescale Slope | |
| int | GetNumberOfScalarComponents () |
| This function is intended to user who doesn't want to have to manage a LUT and expects to get an RBG Pixel image (or a monochrome one ...). | |
| int | GetNumberOfScalarComponentsRaw () |
| This function is intended to user that DOESN'T want get RGB pixels image when it's stored as a PALETTE COLOR image \ - the (vtk) user is supposed to know how deal with LUTs -. | |
| std::string | GetStudyUID () |
| gets the info from 0020,000d : Study Instance UID | |
| std::string | GetSeriesUID () |
| gets the info from 0020,000e : Series Instance UID | |
| std::string | GetClassUID () |
| gets the info from 0008,0016 : SOP Class UID | |
| std::string | GetInstanceUID () |
| gets the info from 0008,0018 : SOP Instance UID | |
| float | GetXOrigin () |
| gets the info from 0020,0032 : Image Position Patient else from 0020,0030 : Image Position (RET) else 0. | |
| float | GetYOrigin () |
| gets the info from 0020,0032 : Image Position Patient else from 0020,0030 : Image Position (RET) else 0. | |
| float | GetZOrigin () |
| gets the info from 0020,0032 : Image Position Patient \ else from 0020,0030 : Image Position (RET) \ else from 0020,1041 : Slice Location \ else from 0020,0050 : Location \ else 0. | |
| int | GetImageNumber () |
| gets the info from 0020,0013 : Image Number \ else 0. | |
| ModalityType | GetModality () |
| gets the info from 0008,0060 : Modality | |
| void | GetImageOrientationPatient (float *iop) |
| gets the info from 0020,0037 : Image Orientation Patient | |
| virtual bool | IsReadable (void) |
| This predicate, based on hopefully reasonable heuristics, decides whether or not the current gdcmParser was properly parsed and contains the mandatory information for being considered as a well formed and usable Dicom/Acr File. | |
| bool | IsJPEGBaseLineProcess1TransferSyntax (void) |
| Determines if the Transfer Syntax was already encountered and if it corresponds to a JPEGBaseLineProcess1 one. | |
| bool | IsJPEGExtendedProcess2_4TransferSyntax (void) |
| Determines if the Transfer Syntax was already encountered and if it corresponds to a JPEGExtendedProcess2-4 one. | |
| bool | IsJPEGExtendedProcess3_5TransferSyntax (void) |
| Determines if the Transfer Syntax was already encountered and if it corresponds to a JPEGExtendeProcess3-5 one. | |
| bool | IsJPEGSpectralSelectionProcess6_8TransferSyntax (void) |
| Determines if the Transfer Syntax was already encountered and if it corresponds to a JPEGSpectralSelectionProcess6-8 one. | |
| bool | IsRLELossLessTransferSyntax (void) |
| Determines if the Transfer Syntax was already encountered and if it corresponds to a RLE Lossless one. | |
| bool | IsJPEGLossless (void) |
| Determines if Transfer Syntax was already encountered and if it corresponds to a JPEG Lossless one. | |
| bool | IsJPEG2000 (void) |
| Determines if the Transfer Syntax was already encountered and if it corresponds to a JPEG2000 one. | |
| bool | IsDicomV3 (void) |
| Predicate for dicom version 3 file. | |
| int | GetXSize (void) |
| Retrieve the number of columns of image. | |
| int | GetYSize (void) |
| Retrieve the number of lines of image. | |
| int | GetZSize (void) |
| Retrieve the number of planes of volume or the number of frames of a multiframe. | |
| int | GetBitsStored (void) |
| Retrieve the number of Bits Stored (actually used) (as opposite to number of Bits Allocated). | |
| int | GetBitsAllocated (void) |
| Retrieve the number of Bits Allocated (8, 12 -compacted ACR-NEMA files, 16, ...). | |
| int | GetSamplesPerPixel (void) |
| Retrieve the number of Samples Per Pixel (1 : gray level, 3 : RGB -1 or 3 Planes-). | |
| int | GetPlanarConfiguration (void) |
| Retrieve the Planar Configuration for RGB images (0 : RGB Pixels , 1 : R Plane + G Plane + B Plane). | |
| size_t | GetPixelOffset (void) |
| Recover the offset (from the beginning of the file) of *image* pixels (not *icone image* pixels, if any !). | |
| size_t | GetPixelAreaLength (void) |
| Recover the pixel area length (in Bytes). | |
| bool | HasLUT (void) |
| tells us if LUT are used | |
| int | GetLUTNbits (void) |
| gets the info from 0028,1101 : Lookup Table Desc-Red else 0 | |
| unsigned char * | GetLUTRGBA (void) |
| builts Red/Green/Blue/Alpha LUT from Header when (0028,0004),Photometric Interpretation = [PALETTE COLOR ] and (0028,1101),(0028,1102),(0028,1102) -xxx Palette Color Lookup Table Descriptor - are found and (0028,1201),(0028,1202),(0028,1202) -xxx Palette Color Lookup Table Data - are found | |
| std::string | GetTransfertSyntaxName (void) |
| gets the info from 0002,0010 : Transfert Syntax and gdcmTS else 1. | |
| virtual std::string | GetEntryByNumber (guint16 group, guint16 element) |
| Searches within Header Entries (Dicom Elements) parsed with the public and private dictionaries for the element value representation of a given tag. | |
| virtual std::string | GetEntryVRByNumber (guint16 group, guint16 element) |
| Searches within Header Entries (Dicom Elements) parsed with the public and private dictionaries for the element value representation of a given tag.. | |
| virtual std::string | GetEntryByName (std::string tagName) |
| Searches within Header Entries (Dicom Elements) parsed with the public and private dictionaries for the element value of a given tag. | |
| virtual std::string | GetEntryVRByName (std::string tagName) |
| Searches within Header Entries (Dicom Elements) parsed with the public and private dictionaries for the element value representation of a given tag. | |
| virtual bool | SetEntryByNumber (std::string content, guint16 group, guint16 element) |
| Accesses an existing gdcmHeaderEntry (i.e. a Dicom Element) through it's (group, element) and modifies it's content with the given value. | |
| virtual bool | SetEntryByName (std::string content, std::string tagName) |
| Sets the value (string) of the Header Entry (Dicom Element). | |
| virtual bool | SetEntryLengthByNumber (guint32 l, guint16 group, guint16 element) |
| Accesses an existing gdcmHeaderEntry (i.e. a Dicom Element) in the PubHeaderEntrySet of this instance through it's (group, element) and modifies it's length with the given value. | |
| virtual void | UpdateShaEntries (void) |
| Update the entries with the shadow dictionary. Only non even entries are analyzed. | |
| void | SetImageDataSize (size_t ExpectedSize) |
| Sets the Pixel Area size in the Header --> not-for-rats function. | |
| bool | operator< (gdcmHeader &header) |
| compares 2 Headers, according to DICOMDIR rules --> not-for-rats function | |
| void | SetPrintLevel (int level) |
| Sets the print level for the Dicom Header. | |
| virtual void | Print (std::ostream &os=std::cout) |
| virtual void | PrintEntry (std::ostream &os=std::cout) |
| Prints the Header Entries (Dicom Elements) both from the H Table and the chained list. | |
| virtual void | PrintPubDict (std::ostream &os=std::cout) |
| Prints The Dict Entries of THE public Dicom Dictionnry. | |
| virtual void | PrintShaDict (std::ostream &os=std::cout) |
| Prints The Dict Entries of THE shadow Dicom Dictionnry. | |
| std::string | GetFileName (void) |
| gdcmDict * | GetPubDict (void) |
| Get the public dictionary used. | |
| gdcmDict * | GetShaDict (void) |
| Get the shadow dictionary used. | |
| bool | SetShaDict (gdcmDict *dict) |
| Set the shadow dictionary used. | |
| bool | SetShaDict (DictKey dictName) |
| Set the shadow dictionary used. | |
| bool | IsImplicitVRLittleEndianTransferSyntax (void) |
| Determines if the Transfer Syntax was already encountered and if it corresponds to a ImplicitVRLittleEndian one. | |
| bool | IsExplicitVRLittleEndianTransferSyntax (void) |
| Determines if the Transfer Syntax was already encountered and if it corresponds to a ExplicitVRLittleEndian one. | |
| bool | IsDeflatedExplicitVRLittleEndianTransferSyntax (void) |
| Determines if the Transfer Syntax was already encountered and if it corresponds to a DeflatedExplicitVRLittleEndian one. | |
| bool | IsExplicitVRBigEndianTransferSyntax (void) |
| Determines if the Transfer Syntax was already encountered and if it corresponds to a Explicit VR Big Endian one. | |
| FileType | GetFileType (void) |
| returns the File Type (ACR, ACR_LIBIDO, ExplicitVR, ImplicitVR, Unknown) | |
| TagHeaderEntryHT & | GetEntry (void) |
| returns a ref to the Dicom Header H table (multimap) return the Dicom Header H table | |
| ListTag & | GetListEntry (void) |
| returns a ref to the Dicom Header chained list return the Dicom Header chained list | |
| FILE * | OpenFile (bool exception_on_error=false) throw (gdcmFileError) |
| opens the file | |
| bool | CloseFile (void) |
| closes the file | |
| virtual bool | Write (FILE *, FileType) |
| bool | ReplaceOrCreateByNumber (std::string Value, guint16 Group, guint16 Elem) |
| Modifies the value of a given Header Entry (Dicom Element) if it exists; Creates it with the given value if it doesn't. | |
| bool | ReplaceOrCreateByNumber (char *Value, guint16 Group, guint16 Elem) |
| Modifies the value of a given Header Entry (Dicom Element) if it exists; Creates it with the given value if it doesn't. | |
| bool | ReplaceIfExistByNumber (char *Value, guint16 Group, guint16 Elem) |
| Set a new value if the invoked element exists Seems to be useless !!! | |
| int | GetSwapCode (void) |
| guint16 | GetGrPixel (void) |
| guint16 | GetNumPixel (void) |
| guint16 | SwapShort (guint16) |
| Swaps the bytes so they agree with the processor order. | |
| guint32 | SwapLong (guint32) |
| Swaps back the bytes of 4-byte long integer accordingly to processor order. | |
| guint16 | UnswapShort (guint16) |
| Unswaps the bytes so they agree with the processor order. | |
| guint32 | UnswapLong (guint32) |
| Unswaps back the bytes of 4-byte long integer accordingly to processor order. | |
Protected Member Functions | |
| int | write (std::ostream &) |
| int | anonymize (std::ostream &) |
| bool | anonymizeHeader (void) |
| anonymize a Header (removes Patient's personal info) (read the code to see which ones ...) | |
| int | CheckIfEntryExistByNumber (guint16 Group, guint16 Elem) |
| Checks if a given Dicom Element exists within the H table. | |
| virtual size_t | GetEntryOffsetByNumber (guint16 Group, guint16 Elem) |
| Gets (from Header) the offset of a 'non string' element value (LoadElementValues has already be executed). | |
| virtual void * | GetEntryVoidAreaByNumber (guint16 Group, guint16 Elem) |
| Gets (from Header) a 'non string' element value (LoadElementValues has already be executed). | |
| virtual void * | LoadEntryVoidArea (guint16 Group, guint16 Element) |
| Loads (from disk) the element content when a string is not suitable. | |
| virtual bool | SetEntryVoidAreaByNumber (void *a, guint16 Group, guint16 Elem) |
| Sets a 'non string' value to a given Dicom Element. | |
| gdcmHeaderEntry * | GetHeaderEntryByNumber (guint16 group, guint16 element) |
| retrieves a Dicom Element (the first one) using (group, element) | |
| gdcmHeaderEntry * | GetHeaderEntryByName (std::string Name) |
| Searches within the Header Entries for a Dicom Element of a given tag. | |
| IterHT | GetHeaderEntrySameNumber (guint16 group, guint16 element) |
| retrieves the Dicom Elements (all of them) using (group, element) | |
| void | LoadHeaderEntrySafe (gdcmHeaderEntry *) |
| Loads the element while preserving the current underlying file position indicator as opposed to to LoadHeaderEntry that modifies it. | |
| void | UpdateGroupLength (bool SkipSequence=false, FileType type=ImplicitVR) |
| Re-computes the length of a ACR-NEMA/Dicom group from a DcmHeader. | |
| void | WriteEntries (FILE *_fp, FileType type) |
| writes on disc according to the requested format (ACR-NEMA, ExplicitVR, ImplicitVR) the image | |
Protected Attributes | |
| FILE * | fp |
| FileType | filetype |
| TagHeaderEntryHT | tagHT |
| ListTag | listEntries |
| int | enableSequences |
| int | printLevel |
| guint16 | GrPixel |
| guint16 | NumPixel |
| int | countGrPixel |
Static Protected Attributes | |
| const unsigned int | HEADER_LENGTH_TO_READ = 256 |
| const unsigned int | MAX_SIZE_LOAD_ELEMENT_VALUE = 4096 |
| const unsigned int | MAX_SIZE_PRINT_ELEMENT_VALUE = 64 |
|
|
constructor
Definition at line 18 of file gdcmHeaderHelper.cxx.
00018 : gdcmHeader( ) { 00019 00020 } |
|
||||||||||||||||||||
|
constructor
Definition at line 33 of file gdcmHeaderHelper.cxx.
00037 : gdcmHeader( InFilename, 00038 exception_on_error, 00039 enable_sequences, 00040 ignore_shadow) 00041 { 00042 } |
|
|
|
|
|
anonymize a Header (removes Patient's personal info) (read the code to see which ones ...)
Definition at line 795 of file gdcmHeader.cxx. References GDCM_UNFOUND, gdcmHeader::GetEntryByNumber(), gdcmParser::GetHeaderEntryByNumber(), gdcmParser::ReplaceIfExistByNumber(), and gdcmParser::ReplaceOrCreateByNumber().
00795 {
00796
00797 gdcmHeaderEntry *patientNameHE = GetHeaderEntryByNumber (0x0010, 0x0010);
00798 // gdcmHeaderEntry *patientIDHE = GetHeaderEntryByNumber (0x0010, 0x0020);
00799
00800 ReplaceIfExistByNumber (" ",0x0010, 0x2154); // Telephone
00801 ReplaceIfExistByNumber (" ",0x0010, 0x1040); // Adress
00802 ReplaceIfExistByNumber (" ",0x0010, 0x0020); // Patient ID
00803
00804 if (patientNameHE) {
00805 std::string StudyInstanceUID = GetEntryByNumber (0x0020, 0x000d);
00806 if (StudyInstanceUID !=GDCM_UNFOUND)
00807 ReplaceOrCreateByNumber(StudyInstanceUID, 0x0010, 0x0010);
00808 else
00809 ReplaceOrCreateByNumber("anonymised", 0x0010, 0x0010);
00810 }
00811
00812 // Just for fun :-(
00813 // (if any) remove or replace
00814
00815 //0008 0012 DA ID Instance Creation Date
00816 //0008 0020 DA ID Study Date
00817 //0008 0021 DA ID Series Date
00818 //0008 0022 DA ID Acquisition Date
00819 //0008 0023 DA ID Content Date
00820 //0008 0024 DA ID Overlay Date
00821 //0008 0025 DA ID Curve Date
00822 //0008 002a DT ID Acquisition Datetime
00823 //0018 9074 DT ACQ Frame Acquisition Datetime
00824 //0018 9151 DT ACQ Frame Reference Datetime
00825 //0018 a002 DT ACQ Contribution Date Time
00826 //0020 3403 SH REL Modified Image Date (RET)
00827 //0032 0032 DA SDY Study Verified Date
00828 //0032 0034 DA SDY Study Read Date
00829 //0032 1000 DA SDY Scheduled Study Start Date
00830 //0032 1010 DA SDY Scheduled Study Stop Date
00831 //0032 1040 DA SDY Study Arrival Date
00832 //0032 1050 DA SDY Study Completion Date
00833 //0038 001a DA VIS Scheduled Admission Date
00834 //0038 001c DA VIS Scheduled Discharge Date
00835 //0038 0020 DA VIS Admitting Date
00836 //0038 0030 DA VIS Discharge Date
00837 //0040 0002 DA PRC Scheduled Procedure Step Start Date
00838 //0040 0004 DA PRC Scheduled Procedure Step End Date
00839 //0040 0244 DA PRC Performed Procedure Step Start Date
00840 //0040 0250 DA PRC Performed Procedure Step End Date
00841 //0040 2004 DA PRC Issue Date of Imaging Service Request
00842 //0040 4005 DT PRC Scheduled Procedure Step Start Date and Time
00843 //0040 4011 DT PRC Expected Completion Date and Time
00844 //0040 a030 DT PRC Verification Date Time
00845 //0040 a032 DT PRC Observation Date Time
00846 //0040 a120 DT PRC DateTime
00847 //0040 a121 DA PRC Date
00848 //0040 a13a DT PRC Referenced Datetime
00849 //0070 0082 DA ??? Presentation Creation Date
00850 //0100 0420 DT ??? SOP Autorization Date and Time
00851 //0400 0105 DT ??? Digital Signature DateTime
00852 //2100 0040 DA PJ Creation Date
00853 //3006 0008 DA SSET Structure Set Date
00854 //3008 0024 DA ??? Treatment Control Point Date
00855 //3008 0054 DA ??? First Treatment Date
00856 //3008 0056 DA ??? Most Recent Treatment Date
00857 //3008 0162 DA ??? Safe Position Exit Date
00858 //3008 0166 DA ??? Safe Position Return Date
00859 //3008 0250 DA ??? Treatment Date
00860 //300a 0006 DA RT RT Plan Date
00861 //300a 022c DA RT Air Kerma Rate Reference Date
00862 //300e 0004 DA RT Review Date
00863 return true;
00864 }
|
|
||||||||||||
|
Checks if a given Dicom Element exists within the H table.
Definition at line 509 of file gdcmParser.cxx. References gdcmParser::tagHT, and gdcmDictEntry::TranslateToKey(). Referenced by gdcmParser::ReplaceOrCreateByNumber().
00509 {
00510 std::string key = gdcmDictEntry::TranslateToKey(group, element );
00511 return (tagHT.count(key));
00512 }
|
|
|
closes the file
Definition at line 365 of file gdcmParser.cxx. References gdcmParser::fp. Referenced by gdcmParser::gdcmParser(), gdcmFile::ParsePixelData(), and gdcmFile::ReadPixelData().
00365 {
00366 int closed = fclose(fp);
00367 fp = (FILE *)0;
00368 if (! closed)
00369 return false;
00370 return true;
00371 }
|
|
|
Retrieve the number of Bits Allocated (8, 12 -compacted ACR-NEMA files, 16, ...).
Definition at line 336 of file gdcmHeader.cxx. References GDCM_UNFOUND, and gdcmHeader::GetEntryByNumber(). Referenced by gdcmFile::gdcm_read_RLE_file(), and gdcmFile::ReadPixelData().
00336 {
00337 std::string StrSize = GetEntryByNumber(0x0028,0x0100);
00338 if (StrSize == GDCM_UNFOUND)
00339 return 0; // It's supposed to be mandatory
00340 // the caller will have to check
00341 return atoi(StrSize.c_str());
00342 }
|
|
|
Retrieve the number of Bits Stored (actually used) (as opposite to number of Bits Allocated).
Definition at line 321 of file gdcmHeader.cxx. References GDCM_UNFOUND, and gdcmHeader::GetEntryByNumber(). Referenced by gdcmFile::ReadPixelData().
00321 {
00322 std::string StrSize = GetEntryByNumber(0x0028,0x0101);
00323 if (StrSize == GDCM_UNFOUND)
00324 return 0; // It's supposed to be mandatory
00325 // the caller will have to check
00326 return atoi(StrSize.c_str());
00327 }
|
|
|
gets the info from 0008,0016 : SOP Class UID
Definition at line 325 of file gdcmHeaderHelper.cxx. References gdcmHeader::GetEntryByNumber().
00325 {
00326 return GetEntryByNumber(0x0008,0x0016); //0008 0016 UI ID SOP Class UID
00327 }
|
|
|
returns a ref to the Dicom Header H table (multimap) return the Dicom Header H table
Definition at line 80 of file gdcmParser.h. References TagHeaderEntryHT. Referenced by gdcmHeader::gdcmHeader(), and gdcmFile::WriteBase().
00080 { return tagHT; };
|
|
|
Searches within Header Entries (Dicom Elements) parsed with the public and private dictionaries for the element value of a given tag.
Reimplemented from gdcmParser. Definition at line 90 of file gdcmHeader.h. References gdcmParser::GetEntryByName().
00091 { return(gdcmParser::GetEntryByName(tagName)); }
|
|
||||||||||||
|
||||||||||||
|
Gets (from Header) the offset of a 'non string' element value (LoadElementValues has already be executed).
Definition at line 695 of file gdcmParser.cxx. References dbg, gdcmParser::GetHeaderEntryByNumber(), gdcmHeaderEntry::GetOffset(), and gdcmDebug::Verbose().
00696 {
00697 gdcmHeaderEntry* Entry = GetHeaderEntryByNumber(Group, Elem);
00698 if (!Entry)
00699 {
00700 dbg.Verbose(1, "gdcmParser::GetHeaderEntryByNumber",
00701 "failed to Locate gdcmHeaderEntry");
00702 return (size_t)0;
00703 }
00704 return Entry->GetOffset();
00705 }
|
|
||||||||||||
|
Gets (from Header) a 'non string' element value (LoadElementValues has already be executed).
Definition at line 715 of file gdcmParser.cxx. References dbg, gdcmParser::GetHeaderEntryByNumber(), gdcmHeaderEntry::GetVoidArea(), and gdcmDebug::Verbose(). Referenced by gdcmHeader::GetLUTRGBA().
00716 {
00717 gdcmHeaderEntry* Entry = GetHeaderEntryByNumber(Group, Elem);
00718 if (!Entry)
00719 {
00720 dbg.Verbose(1, "gdcmParser::GetHeaderEntryByNumber",
00721 "failed to Locate gdcmHeaderEntry");
00722 return (NULL);
00723 }
00724 return Entry->GetVoidArea();
00725 }
|
|
|
Searches within Header Entries (Dicom Elements) parsed with the public and private dictionaries for the element value representation of a given tag. Obtaining the VR (Value Representation) might be needed by caller to convert the string typed content to caller's native type (think of C++ vs Python). The VR is actually of a higher level of semantics than just the native C++ type.
Reimplemented from gdcmParser. Definition at line 92 of file gdcmHeader.h. References gdcmParser::GetEntryVRByName().
00093 { return(gdcmParser::GetEntryVRByName(tagName)); }
|
|
||||||||||||
|
Searches within Header Entries (Dicom Elements) parsed with the public and private dictionaries for the element value representation of a given tag.. Obtaining the VR (Value Representation) might be needed by caller to convert the string typed content to caller's native type (think of C++ vs Python). The VR is actually of a higher level of semantics than just the native C++ type.
Reimplemented from gdcmParser. Definition at line 87 of file gdcmHeader.h. References gdcmParser::GetEntryVRByNumber().
00088 { return(gdcmParser::GetEntryVRByNumber(group,element)); }
|
|
|
Definition at line 58 of file gdcmParser.h. Referenced by gdcmDicomDir::GetPath(), and gdcmDicomDir::SetElement().
00058 {return filename;}
|
|
|
returns the File Type (ACR, ACR_LIBIDO, ExplicitVR, ImplicitVR, Unknown)
Definition at line 315 of file gdcmParser.cxx. References gdcmParser::filetype, and FileType. Referenced by gdcmFile::WriteBase().
00315 {
00316 return(filetype);
00317 }
|
|
|
Definition at line 102 of file gdcmParser.h. Referenced by gdcmFile::WriteBase().
00102 {return GrPixel;}
|
|
|
Searches within the Header Entries for a Dicom Element of a given tag.
Definition at line 829 of file gdcmParser.cxx. References gdcmDict::GetDictEntryByName(), gdcmDictEntry::GetElement(), gdcmDictEntry::GetGroup(), gdcmParser::GetHeaderEntryByNumber(), and gdcmParser::RefPubDict.
00829 {
00830 gdcmDictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName);
00831 if( dictEntry == NULL)
00832 return NULL;
00833
00834 return(GetHeaderEntryByNumber(dictEntry->GetGroup(),dictEntry->GetElement()));
00835 }
|
|
||||||||||||
|
retrieves a Dicom Element (the first one) using (group, element)
Definition at line 848 of file gdcmParser.cxx. References gdcmParser::tagHT, TagKey, and gdcmDictEntry::TranslateToKey(). Referenced by gdcmHeader::anonymizeHeader(), gdcmParser::GetEntryOffsetByNumber(), gdcmParser::GetEntryVoidAreaByNumber(), gdcmParser::GetEntryVRByName(), gdcmParser::GetEntryVRByNumber(), gdcmParser::GetHeaderEntryByName(), gdcmHeader::HasLUT(), gdcmParser::IsDeflatedExplicitVRLittleEndianTransferSyntax(), gdcmHeader::IsDicomV3(), gdcmParser::IsExplicitVRBigEndianTransferSyntax(), gdcmParser::IsExplicitVRLittleEndianTransferSyntax(), gdcmParser::IsImplicitVRLittleEndianTransferSyntax(), gdcmHeader::IsJPEG2000(), gdcmHeader::IsJPEGBaseLineProcess1TransferSyntax(), gdcmHeader::IsJPEGExtendedProcess2_4TransferSyntax(), gdcmHeader::IsJPEGExtendedProcess3_5TransferSyntax(), gdcmHeader::IsJPEGLossless(), gdcmHeader::IsJPEGSpectralSelectionProcess6_8TransferSyntax(), gdcmHeader::IsReadable(), gdcmHeader::IsRLELossLessTransferSyntax(), gdcmParser::LoadEntryVoidArea(), gdcmHeader::SetImageDataSize(), and gdcmParser::UpdateGroupLength().
00849 {
00850 TagKey key = gdcmDictEntry::TranslateToKey(group, element);
00851 if ( ! tagHT.count(key))
00852 return NULL;
00853 return tagHT.find(key)->second;
00854 }
|
|
||||||||||||
|
retrieves the Dicom Elements (all of them) using (group, element)
Definition at line 864 of file gdcmParser.cxx. References IterHT, gdcmParser::tagHT, TagKey, and gdcmDictEntry::TranslateToKey(). Referenced by gdcmHeader::GetPixelAreaLength(), and gdcmHeader::GetPixelOffset().
00864 {
00865 TagKey key = gdcmDictEntry::TranslateToKey(group, element);
00866 return (tagHT.equal_range(key));
00867 }
|
|
|
gets the info from 0020,0013 : Image Number \ else 0.
Definition at line 463 of file gdcmHeaderHelper.cxx. References GDCM_UNFOUND, and gdcmHeader::GetEntryByNumber().
00463 {
00464 //The function i atoi() takes the address of an area of memory as parameter and converts
00465 //the string stored at that location to an integer using the external decimal to internal
00466 //binary conversion rules. This may be preferable to sscanf() since atoi() is a much smaller,
00467 // simpler and faster function. sscanf() can do all possible conversions whereas atoi() can
00468 //only do single decimal integer conversions.
00469 std::string StrImNumber = GetEntryByNumber(0x0020,0x0013); //0020 0013 IS REL Image Number
00470 if (StrImNumber != GDCM_UNFOUND) {
00471 return atoi( StrImNumber.c_str() );
00472 }
00473 return 0; //Hopeless
00474 }
|
|
|
gets the info from 0020,0037 : Image Orientation Patient
Definition at line 541 of file gdcmHeaderHelper.cxx. References dbg, GDCM_UNFOUND, gdcmHeader::GetEntryByNumber(), and gdcmDebug::Verbose().
00541 {
00542
00543 //iop is supposed to be float[6]
00544 iop[0] = iop[1] = iop[2] = iop[3] = iop[4] = iop[5] = 0;
00545
00546 std::string StrImOriPat = GetEntryByNumber(0x0020,0x0037); // 0020 0037 DS REL Image Orientation (Patient)
00547 if (StrImOriPat != GDCM_UNFOUND) {
00548 if( sscanf( StrImOriPat.c_str(), "%f\\%f\\%f\\%f\\%f\\%f",
00549 &iop[0], &iop[1], &iop[2], &iop[3], &iop[4], &iop[5]) != 6) {
00550 dbg.Verbose(0, "gdcmHeader::GetImageOrientationPatient: wrong Image Orientation Patient (0020,0037)");
00551 return ; // bug in the element 0x0020,0x0037
00552 }
00553 else
00554 return ;
00555 }
00556
00557 //For ACR-NEMA
00558 StrImOriPat = GetEntryByNumber(0x0020,0x0035); //0020 0035 DS REL Image Orientation (RET)
00559 if (StrImOriPat != GDCM_UNFOUND) {
00560 if( sscanf( StrImOriPat.c_str(), "%f\\%f\\%f\\%f\\%f\\%f",
00561 &iop[0], &iop[1], &iop[2], &iop[3], &iop[4], &iop[5]) != 6) {
00562 dbg.Verbose(0, "gdcmHeader::GetImageOrientationPatient: wrong Image Orientation Patient (0020,0035)");
00563 return ; // bug in the element 0x0020,0x0035
00564 }
00565 else
00566 return ;
00567 }
00568 }
|
|
|
gets the info from 0008,0018 : SOP Instance UID
Definition at line 335 of file gdcmHeaderHelper.cxx. References gdcmHeader::GetEntryByNumber().
00335 {
00336 return GetEntryByNumber(0x0008,0x0018); //0008 0018 UI ID SOP Instance UID
00337 }
|
|
|
returns a ref to the Dicom Header chained list return the Dicom Header chained list
Definition at line 87 of file gdcmParser.h. References ListTag. Referenced by gdcmDicomDir::CreateDicomDir(), gdcmDicomDir::gdcmDicomDir(), and gdcmParser::LoadHeaderEntries().
00087 { return listEntries; };
|
|
|
gets the info from 0028,1101 : Lookup Table Desc-Red else 0
Definition at line 538 of file gdcmHeader.cxx. References GDCM_UNFOUND, gdcmHeader::GetEntryByNumber(), and Tokenize().
00538 {
00539 std::vector<std::string> tokens;
00540 //int LutLength;
00541 //int LutDepth;
00542 int LutNbits;
00543 //Just hope Lookup Table Desc-Red = Lookup Table Desc-Red = Lookup Table Desc-Blue
00544 // Consistency already checked in GetLUTLength
00545 std::string LutDescription = GetEntryByNumber(0x0028,0x1101);
00546 if (LutDescription == GDCM_UNFOUND)
00547 return 0;
00548 tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
00549 Tokenize (LutDescription, tokens, "\\");
00550 //LutLength=atoi(tokens[0].c_str());
00551 //LutDepth=atoi(tokens[1].c_str());
00552 LutNbits=atoi(tokens[2].c_str());
00553 tokens.clear();
00554 return LutNbits;
00555 }
|
|
|
builts Red/Green/Blue/Alpha LUT from Header when (0028,0004),Photometric Interpretation = [PALETTE COLOR ] and (0028,1101),(0028,1102),(0028,1102) -xxx Palette Color Lookup Table Descriptor - are found and (0028,1201),(0028,1202),(0028,1202) -xxx Palette Color Lookup Table Data - are found
Definition at line 573 of file gdcmHeader.cxx. References GDCM_UNFOUND, gdcmHeader::GetEntryByNumber(), gdcmParser::GetEntryVoidAreaByNumber(), and Tokenize(). Referenced by gdcmFile::GetImageDataIntoVector().
00573 {
00574 // Not so easy : see
00575 // http://www.barre.nom.fr/medical/dicom2/limitations.html#Color%20Lookup%20Tables
00576
00577 // if Photometric Interpretation # PALETTE COLOR, no LUT to be done
00578 if (GetEntryByNumber(0x0028,0x0004) != "PALETTE COLOR ") {
00579 return NULL;
00580 }
00581 int lengthR, debR, nbitsR;
00582 int lengthG, debG, nbitsG;
00583 int lengthB, debB, nbitsB;
00584
00585 // Get info from Lut Descriptors
00586 // (the 3 LUT descriptors may be different)
00587 std::string LutDescriptionR = GetEntryByNumber(0x0028,0x1101);
00588 if (LutDescriptionR == GDCM_UNFOUND)
00589 return NULL;
00590 std::string LutDescriptionG = GetEntryByNumber(0x0028,0x1102);
00591 if (LutDescriptionG == GDCM_UNFOUND)
00592 return NULL;
00593 std::string LutDescriptionB = GetEntryByNumber(0x0028,0x1103);
00594 if (LutDescriptionB == GDCM_UNFOUND)
00595 return NULL;
00596
00597 std::vector<std::string> tokens;
00598
00599 tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
00600 Tokenize (LutDescriptionR, tokens, "\\");
00601 lengthR=atoi(tokens[0].c_str()); // Red LUT length in Bytes
00602 debR =atoi(tokens[1].c_str()); // subscript of the first Lut Value
00603 nbitsR =atoi(tokens[2].c_str()); // Lut item size (in Bits)
00604 tokens.clear();
00605
00606 tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
00607 Tokenize (LutDescriptionG, tokens, "\\");
00608 lengthG=atoi(tokens[0].c_str()); // Green LUT length in Bytes
00609 debG =atoi(tokens[1].c_str()); // subscript of the first Lut Value
00610 nbitsG =atoi(tokens[2].c_str()); // Lut item size (in Bits)
00611 tokens.clear();
00612
00613 tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
00614 Tokenize (LutDescriptionB, tokens, "\\");
00615 lengthB=atoi(tokens[0].c_str()); // Blue LUT length in Bytes
00616 debB =atoi(tokens[1].c_str()); // subscript of the first Lut Value
00617 nbitsB =atoi(tokens[2].c_str()); // Lut item size (in Bits)
00618 tokens.clear();
00619
00620 // Load LUTs into memory, (as they were stored on disk)
00621 unsigned char *lutR = (unsigned char *)
00622 GetEntryVoidAreaByNumber(0x0028,0x1201);
00623 unsigned char *lutG = (unsigned char *)
00624 GetEntryVoidAreaByNumber(0x0028,0x1202);
00625 unsigned char *lutB = (unsigned char *)
00626 GetEntryVoidAreaByNumber(0x0028,0x1203);
00627
00628 if (!lutR || !lutG || !lutB ) {
00629 return NULL;
00630 }
00631 // forge the 4 * 8 Bits Red/Green/Blue/Alpha LUT
00632
00633 unsigned char *LUTRGBA = (unsigned char *)calloc(1024,1); // 256 * 4 (R, G, B, Alpha)
00634 if (!LUTRGBA) {
00635 return NULL;
00636 }
00637 memset(LUTRGBA, 0, 1024);
00638 // Bits Allocated
00639 int nb;
00640 std::string str_nb = GetEntryByNumber(0x0028,0x0100);
00641 if (str_nb == GDCM_UNFOUND ) {
00642 nb = 16;
00643 } else {
00644 nb = atoi(str_nb.c_str() );
00645 }
00646 int mult;
00647
00648 if (nbitsR==16 && nb==8) // when LUT item size is different than pixel size
00649 mult=2; // high byte must be = low byte
00650 else // See PS 3.3-2003 C.11.1.1.2 p 619
00651 mult=1;
00652
00653 // if we get a black image, let's just remove the '+1'
00654 // from 'i*mult+1' and check again
00655 // if it works, we shall have to check the 3 Palettes
00656 // to see which byte is ==0 (first one, or second one)
00657 // and fix the code
00658 // We give up the checking to avoid some (useless ?)overhead
00659 // (optimistic asumption)
00660 unsigned char *a;
00661 int i;
00662
00663 a = LUTRGBA+0;
00664 for(i=0;i<lengthR;i++) {
00665 *a = lutR[i*mult+1];
00666 a+=4;
00667 }
00668 a = LUTRGBA+1;
00669 for(i=0;i<lengthG;i++) {
00670 *a = lutG[i*mult+1];
00671 a+=4;
00672 }
00673 a = LUTRGBA+2;
00674 for(i=0;i<lengthB;i++) {
00675 *a = lutB[i*mult+1];
00676 a+=4;
00677 }
00678 a = LUTRGBA+3;
00679 for(i=0;i<256;i++) {
00680 *a = 1; // Alpha component
00681 a+=4;
00682 }
00683
00684 //How to free the now useless LUTs?
00685 //free(LutR); free(LutB); free(LutG); // Seg Fault when used
00686 return(LUTRGBA);
00687 }
|
|
|
gets the info from 0008,0060 : Modality
Definition at line 481 of file gdcmHeaderHelper.cxx. References AS, AU, BI, CF, CP, CR, CS, CT, DD, DF, DG, DM, DS, DX, ECG, EPS, FA, FS, GDCM_UNFOUND, gdcmHeader::GetEntryByNumber(), HC, HD, LP, LS, MA, ModalityType, MR, NM, OT, PT, RF, RG, RTDOSE, RTIMAGE, RTPLAN, RTSTRUCT, SM, ST, TG, Unknow, US, VF, XA, and XC.
00481 {
00482 std::string StrModality = GetEntryByNumber(0x0008,0x0060); //0008 0060 CS ID Modality
00483 if (StrModality != GDCM_UNFOUND) {
00484 if ( StrModality.find("AU") < StrModality.length()) return AU;
00485 else if ( StrModality.find("AS") < StrModality.length()) return AS;
00486 else if ( StrModality.find("BI") < StrModality.length()) return BI;
00487 else if ( StrModality.find("CF") < StrModality.length()) return CF;
00488 else if ( StrModality.find("CP") < StrModality.length()) return CP;
00489 else if ( StrModality.find("CR") < StrModality.length()) return CR;
00490 else if ( StrModality.find("CT") < StrModality.length()) return CT;
00491 else if ( StrModality.find("CS") < StrModality.length()) return CS;
00492 else if ( StrModality.find("DD") < StrModality.length()) return DD;
00493 else if ( StrModality.find("DF") < StrModality.length()) return DF;
00494 else if ( StrModality.find("DG") < StrModality.length()) return DG;
00495 else if ( StrModality.find("DM") < StrModality.length()) return DM;
00496 else if ( StrModality.find("DS") < StrModality.length()) return DS;
00497 else if ( StrModality.find("DX") < StrModality.length()) return DX;
00498 else if ( StrModality.find("ECG") < StrModality.length()) return ECG;
00499 else if ( StrModality.find("EPS") < StrModality.length()) return EPS;
00500 else if ( StrModality.find("FA") < StrModality.length()) return FA;
00501 else if ( StrModality.find("FS") < StrModality.length()) return FS;
00502 else if ( StrModality.find("HC") < StrModality.length()) return HC;
00503 else if ( StrModality.find("HD") < StrModality.length()) return HD;
00504 else if ( StrModality.find("LP") < StrModality.length()) return LP;
00505 else if ( StrModality.find("LS") < StrModality.length()) return LS;
00506 else if ( StrModality.find("MA") < StrModality.length()) return MA;
00507 else if ( StrModality.find("MR") < StrModality.length()) return MR;
00508 else if ( StrModality.find("NM") < StrModality.length()) return NM;
00509 else if ( StrModality.find("OT") < StrModality.length()) return OT;
00510 else if ( StrModality.find("PT") < StrModality.length()) return PT;
00511 else if ( StrModality.find("RF") < StrModality.length()) return RF;
00512 else if ( StrModality.find("RG") < StrModality.length()) return RG;
00513 else if ( StrModality.find("RTDOSE") < StrModality.length()) return RTDOSE;
00514 else if ( StrModality.find("RTIMAGE") < StrModality.length()) return RTIMAGE;
00515 else if ( StrModality.find("RTPLAN") < StrModality.length()) return RTPLAN;
00516 else if ( StrModality.find("RTSTRUCT")< StrModality.length()) return RTSTRUCT;
00517 else if ( StrModality.find("SM") < StrModality.length()) return SM;
00518 else if ( StrModality.find("ST") < StrModality.length()) return ST;
00519 else if ( StrModality.find("TG") < StrModality.length()) return TG;
00520 else if ( StrModality.find("US") < StrModality.length()) return US;
00521 else if ( StrModality.find("VF") < StrModality.length()) return VF;
00522 else if ( StrModality.find("XA") < StrModality.length()) return XA;
00523 else if ( StrModality.find("XC") < StrModality.length()) return XC;
00524
00525 else
00526 {
00527 //throw error return value ???
00528 // specified <> unknow in our database
00529 return Unknow;
00530 }
00531 }
00532 return Unknow;
00533 }
|
|
|
This function is intended to user who doesn't want to have to manage a LUT and expects to get an RBG Pixel image (or a monochrome one ...).
Definition at line 248 of file gdcmHeaderHelper.cxx. References GDCM_UNFOUND, gdcmHeader::GetEntryByNumber(), gdcmHeader::GetSamplesPerPixel(), and gdcmHeader::HasLUT().
00248 {
00249 if (GetSamplesPerPixel() ==3)
00250 return 3;
00251
00252 // 0028 0100 US IMG Bits Allocated
00253 // (in order no to be messed up by old RGB images)
00254 if (gdcmHeader::GetEntryByNumber(0x0028,0x0100) == "24")
00255 return 3;
00256
00257 std::string PhotometricInterpretation =
00258 gdcmHeader::GetEntryByNumber(0x0028,0x0004);
00259
00260 if ( ( PhotometricInterpretation == "PALETTE COLOR ") ) {
00261 if (HasLUT()) // PALETTE COLOR is NOT enough
00262 return 3;
00263 else
00264 return 1;
00265 }
00266
00267 //beware of trailing space at end of string
00268 if (PhotometricInterpretation.find(GDCM_UNFOUND) <
00269 PhotometricInterpretation.length() ||
00270 PhotometricInterpretation.find("MONOCHROME1") <
00271 PhotometricInterpretation.length() ||
00272 PhotometricInterpretation.find("MONOCHROME2") <
00273 PhotometricInterpretation.length() )
00274 return 1;
00275 else
00276 // we assume that *all* kinds of YBR are dealt with
00277 return 3;
00278 }
|
|
|
This function is intended to user that DOESN'T want get RGB pixels image when it's stored as a PALETTE COLOR image \ - the (vtk) user is supposed to know how deal with LUTs -.
Definition at line 288 of file gdcmHeaderHelper.cxx. References gdcmHeader::GetEntryByNumber(), and gdcmHeader::GetSamplesPerPixel().
00288 {
00289
00290 // 0028 0100 US IMG Bits Allocated
00291 // (in order no to be messed up by old RGB images)
00292 if (gdcmHeader::GetEntryByNumber(0x0028,0x0100) == "24")
00293 return 3;
00294
00295 // we assume that *all* kinds of YBR are dealt with
00296 return GetSamplesPerPixel();
00297 }
|
|
|
Definition at line 103 of file gdcmParser.h. Referenced by gdcmFile::WriteBase().
00103 {return NumPixel;}
|
|
|
Recover the pixel area length (in Bytes).
Definition at line 476 of file gdcmHeader.cxx. References gdcmParser::GetHeaderEntrySameNumber(), gdcmHeaderEntry::GetLength(), IterHT, TagKey, and gdcmDictEntry::TranslateToKey(). Referenced by gdcmFile::ReadPixelData().
00476 {
00477
00478 IterHT it = GetHeaderEntrySameNumber(GrPixel,NumPixel);
00479 TagKey key = gdcmDictEntry::TranslateToKey(GrPixel,NumPixel);
00480 gdcmHeaderEntry* PixelElement;
00481
00482 if (countGrPixel==1)
00483 PixelElement = (it.first)->second;
00484 else
00485 PixelElement = (++it.first)->second;
00486
00487 if (PixelElement) {
00488 return PixelElement->GetLength();
00489 } else {
00490 /* std::cout << "Big trouble : Pixel Element ("
00491 << std::hex << GrPixel<<","<< NumPixel<< ") NOT found"
00492 << std::endl;*/
00493 return 0;
00494 }
00495 }
|
|
|
Recover the offset (from the beginning of the file) of *image* pixels (not *icone image* pixels, if any !).
Definition at line 440 of file gdcmHeader.cxx. References gdcmParser::GetHeaderEntrySameNumber(), gdcmHeaderEntry::GetOffset(), IterHT, TagKey, and gdcmDictEntry::TranslateToKey(). Referenced by gdcmFile::ParsePixelData(), and gdcmFile::ReadPixelData().
00440 {
00441 //
00442 // If the element (0x0088,0x0200) 'icone image sequence' is found
00443 // (grPixel,numPixel) is stored twice : the first one for the icon
00444 // the second one for the image ...
00445 // pb : sometimes , (0x0088,0x0200) exists, but doesn't contain *anything*
00446 // see gdcmData/MxTwinLossLess.dcm ...
00447
00448 //std::string icone = GetEntryByNumber(0x0088,0x0200); //icone image sequence
00449
00450 IterHT it = GetHeaderEntrySameNumber(GrPixel,NumPixel);
00451 TagKey key = gdcmDictEntry::TranslateToKey(GrPixel,NumPixel);
00452 gdcmHeaderEntry* PixelElement;
00453 if (countGrPixel == 1)
00454 PixelElement = (it.first)->second;
00455 else {
00456 PixelElement = (++it.first)->second; // hope there are no more than 2 !
00457 }
00458 if (PixelElement) {
00459 return PixelElement->GetOffset();
00460 } else {
00461 /* std::cout << "Big trouble : Pixel Element ("
00462 << std::hex << GrPixel<<","<< NumPixel<< ") NOT found"
00463 << std::endl; */
00464 return 0;
00465 }
00466 }
|
|
|
Returns the size (in bytes) of a single pixel of data.
Reimplemented from gdcmHeader. Definition at line 55 of file gdcmHeaderHelper.cxx. References dbg, gdcmHeader::GetEntryByNumber(), GetPixelType(), and gdcmDebug::Verbose().
00055 {
00056
00057 // 0028 0100 US IMG Bits Allocated
00058 // (in order no to be messed up by old RGB images)
00059 if (gdcmHeader::GetEntryByNumber(0x0028,0x0100) == "24")
00060 return 3;
00061
00062 std::string PixelType = GetPixelType();
00063 if (PixelType == "8U" || PixelType == "8S")
00064 return 1;
00065 if (PixelType == "16U" || PixelType == "16S")
00066 return 2;
00067 if (PixelType == "32U" || PixelType == "32S")
00068 return 4;
00069 if (PixelType == "FD") // to help unfortunate users to manage DOUBLE
00070 return 8;
00071 dbg.Verbose(0, "gdcmHeader::GetPixelSize: Unknown pixel type");
00072 return 0;
00073 }
|
|
|
Build the Pixel Type of the image. Possible values are: -8U unsigned 8 bit, -8S signed 8 bit, -16U unsigned 16 bit, -16S signed 16 bit, -32U unsigned 32 bit, -32S signed 32 bit, -FD Double,.
Reimplemented from gdcmHeader. Definition at line 93 of file gdcmHeaderHelper.cxx. References dbg, GDCM_UNFOUND, gdcmHeader::GetEntryByNumber(), and gdcmDebug::Verbose(). Referenced by GetPixelSize().
00093 {
00094 std::string BitsAlloc;
00095 BitsAlloc = GetEntryByNumber(0x0028, 0x0100);
00096 if (BitsAlloc == GDCM_UNFOUND) { // Bits Allocated
00097 dbg.Verbose(0, "gdcmHeader::GetPixelType: unfound Bits Allocated");
00098 BitsAlloc = std::string("16");
00099 }
00100 if (BitsAlloc == "12") // It will be unpacked
00101 BitsAlloc = std::string("16");
00102 else if (BitsAlloc == "24") // (in order no to be messed up
00103 BitsAlloc = std::string("8"); // by old RGB images)
00104
00105 std::string Signed;
00106 Signed = GetEntryByNumber(0x0028, 0x0103);
00107 if (Signed == GDCM_UNFOUND) { // "Pixel Representation"
00108 dbg.Verbose(0, "gdcmHeader::GetPixelType: unfound Pixel Representation");
00109 BitsAlloc = std::string("0");
00110 }
00111 if (BitsAlloc == "64") // to help users that want to deal with DOUBLE
00112 return("FD");
00113
00114 if (Signed == "0")
00115 Signed = std::string("U");
00116 else
00117 Signed = std::string("S");
00118
00119 return( BitsAlloc + Signed);
00120 }
|
|
|
Retrieve the Planar Configuration for RGB images (0 : RGB Pixels , 1 : R Plane + G Plane + B Plane).
Definition at line 365 of file gdcmHeader.cxx. References GDCM_UNFOUND, and gdcmHeader::GetEntryByNumber(). Referenced by gdcmFile::GetImageDataIntoVectorRaw().
00365 {
00366 std::string StrSize = GetEntryByNumber(0x0028,0x0006);
00367 if (StrSize == GDCM_UNFOUND)
00368 return 0;
00369 return atoi(StrSize.c_str());
00370 }
|
|
|
Get the public dictionary used.
Definition at line 185 of file gdcmParser.cxx. References gdcmParser::RefPubDict. Referenced by gdcmDicomDir::SetElement().
00185 {
00186 return(RefPubDict);
00187 }
|
|
|
gets the info from 0028,1052 : Rescale Intercept
Definition at line 211 of file gdcmHeaderHelper.cxx. References dbg, GDCM_UNFOUND, gdcmHeader::GetEntryByNumber(), and gdcmDebug::Verbose().
00211 {
00212 float resInter = 0.;
00213 std::string StrRescInter = GetEntryByNumber(0x0028,0x1052); //0028 1052 DS IMG Rescale Intercept
00214 if (StrRescInter != GDCM_UNFOUND) {
00215 if( sscanf( StrRescInter.c_str(), "%f", &resInter) != 1) {
00216 dbg.Verbose(0, "gdcmHeader::GetRescaleIntercept: Rescale Slope is empty");
00217 // bug in the element 0x0028,0x1052
00218 }
00219 }
00220 return resInter;
00221 }
|
|
|
gets the info from 0028,1053 : Rescale Slope
Definition at line 228 of file gdcmHeaderHelper.cxx. References dbg, GDCM_UNFOUND, gdcmHeader::GetEntryByNumber(), and gdcmDebug::Verbose().
00228 {
00229 float resSlope = 1.;
00230 std::string StrRescSlope = GetEntryByNumber(0x0028,0x1053); //0028 1053 DS IMG Rescale Slope
00231 if (StrRescSlope != GDCM_UNFOUND) {
00232 if( sscanf( StrRescSlope.c_str(), "%f", &resSlope) != 1) {
00233 dbg.Verbose(0, "gdcmHeader::GetRescaleSlope: Rescale Slope is empty");
00234 // bug in the element 0x0028,0x1053
00235 }
00236 }
00237 return resSlope;
00238 }
|
|
|
Retrieve the number of Samples Per Pixel (1 : gray level, 3 : RGB -1 or 3 Planes-).
Definition at line 351 of file gdcmHeader.cxx. References GDCM_UNFOUND, and gdcmHeader::GetEntryByNumber(). Referenced by GetNumberOfScalarComponents(), GetNumberOfScalarComponentsRaw(), gdcmFile::ParsePixelData(), gdcmFile::ReadPixelData(), and gdcmFile::SetPixelDataSizeFromHeader().
00351 {
00352 std::string StrSize = GetEntryByNumber(0x0028,0x0002);
00353 if (StrSize == GDCM_UNFOUND)
00354 return 1; // Well, it's supposed to be mandatory ...
00355 // but sometimes it's missing : *we* assume Gray pixels
00356 return atoi(StrSize.c_str());
00357 }
|
|
|
gets the info from 0020,000e : Series Instance UID
Definition at line 315 of file gdcmHeaderHelper.cxx. References gdcmHeader::GetEntryByNumber().
00315 {
00316 return GetEntryByNumber(0x0020,0x000e); //0020 000e UI REL Series Instance UID
00317 }
|
|
|
Get the shadow dictionary used.
Definition at line 193 of file gdcmParser.cxx. References gdcmParser::RefShaDict.
00193 {
00194 return(RefShaDict);
00195 }
|
|
|
gets the info from 0020,000d : Study Instance UID
Definition at line 305 of file gdcmHeaderHelper.cxx. References gdcmHeader::GetEntryByNumber().
00305 {
00306 return GetEntryByNumber(0x0020,0x000d); //0020 000d UI REL Study Instance UID
00307 }
|
|
|
Definition at line 101 of file gdcmParser.h. Referenced by gdcmFile::gdcm_read_RLE_file(), gdcmFile::GetImageDataIntoVectorRaw(), gdcmFile::ParsePixelData(), and gdcmFile::ReadPixelData().
00101 { return sw; }
|
|
|
gets the info from 0002,0010 : Transfert Syntax and gdcmTS else 1.
Definition at line 695 of file gdcmHeader.cxx. References dbg, GDCM_UNFOUND, gdcmHeader::GetEntryByNumber(), gdcmGlobal::GetTS(), gdcmTS::GetValue(), and gdcmDebug::Verbose().
00695 {
00696 // use the gdcmTS (TS : Transfert Syntax)
00697 std::string TransfertSyntax = GetEntryByNumber(0x0002,0x0010);
00698 if (TransfertSyntax == GDCM_UNFOUND) {
00699 dbg.Verbose(0, "gdcmHeader::GetTransfertSyntaxName: unfound Transfert Syntax (0002,0010)");
00700 return "Uncompressed ACR-NEMA";
00701 }
00702 // we do it only when we need it
00703 gdcmTS * ts = gdcmGlobal::GetTS();
00704 std::string tsName=ts->GetValue(TransfertSyntax);
00705 //delete ts; // Seg Fault when deleted ?!
00706 return tsName;
00707 }
|
|
|
gets the info from 0020,0032 : Image Position Patient else from 0020,0030 : Image Position (RET) else 0. change GetXImagePosition -> GetXOrigin in order not to confuse reader
Definition at line 362 of file gdcmHeaderHelper.cxx. References dbg, GDCM_UNFOUND, gdcmHeader::GetEntryByNumber(), and gdcmDebug::Verbose().
00362 {
00363 float xImPos, yImPos, zImPos;
00364 std::string StrImPos = GetEntryByNumber(0x0020,0x0032);
00365
00366 if (StrImPos == GDCM_UNFOUND) {
00367 dbg.Verbose(0, "gdcmHeader::GetXImagePosition: unfound Image Position Patient (0020,0032)");
00368 StrImPos = GetEntryByNumber(0x0020,0x0030); // For ACR-NEMA images
00369 if (StrImPos == GDCM_UNFOUND) {
00370 dbg.Verbose(0, "gdcmHeader::GetXImagePosition: unfound Image Position (RET) (0020,0030)");
00371 // How to tell the caller nothing was found ?
00372 return 0.;
00373 }
00374 }
00375 if( sscanf( StrImPos.c_str(), "%f\\%f\\%f", &xImPos, &yImPos, &zImPos) != 3)
00376 return 0.;
00377 return xImPos;
00378 }
|
|
|
Retrieve the number of columns of image.
Definition at line 264 of file gdcmHeader.cxx. References GDCM_UNFOUND, and gdcmHeader::GetEntryByNumber(). Referenced by gdcmFile::gdcm_read_RLE_file(), gdcmFile::GetImageDataIntoVectorRaw(), gdcmFile::ParsePixelData(), gdcmFile::ReadPixelData(), and gdcmFile::SetPixelDataSizeFromHeader().
00264 {
00265 std::string StrSize;
00266 StrSize = GetEntryByNumber(0x0028,0x0011);
00267 if (StrSize == GDCM_UNFOUND)
00268 return 0;
00269 return atoi(StrSize.c_str());
00270 }
|
|
|
gets the info from 0028,0030 : Pixel Spacing else 1.
Definition at line 128 of file gdcmHeaderHelper.cxx. References dbg, GDCM_UNFOUND, gdcmHeader::GetEntryByNumber(), and gdcmDebug::Verbose().
00128 {
00129 float xspacing, yspacing;
00130 std::string StrSpacing = GetEntryByNumber(0x0028,0x0030);
00131
00132 if (StrSpacing == GDCM_UNFOUND) {
00133 dbg.Verbose(0, "gdcmHeader::GetXSpacing: unfound Pixel Spacing (0028,0030)");
00134 return 1.;
00135 }
00136 if( sscanf( StrSpacing.c_str(), "%f\\%f", &yspacing, &xspacing) != 2)
00137 return 0.;
00138 if (xspacing == 0.) {
00139 dbg.Verbose(0, "gdcmHeader::GetYSpacing: gdcmData/CT-MONO2-8-abdo.dcm problem");
00140 // seems to be a bug in the header ...
00141 sscanf( StrSpacing.c_str(), "%f\\0\\%f", &yspacing, &xspacing);
00142 }
00143 return xspacing;
00144 }
|
|
|
gets the info from 0020,0032 : Image Position Patient else from 0020,0030 : Image Position (RET) else 0.
Definition at line 387 of file gdcmHeaderHelper.cxx. References dbg, GDCM_UNFOUND, gdcmHeader::GetEntryByNumber(), and gdcmDebug::Verbose().
00387 {
00388 float xImPos, yImPos, zImPos;
00389 std::string StrImPos = GetEntryByNumber(0x0020,0x0032);
00390
00391 if (StrImPos == GDCM_UNFOUND) {
00392 dbg.Verbose(0, "gdcmHeader::GetYImagePosition: unfound Image Position Patient (0020,0032)");
00393 StrImPos = GetEntryByNumber(0x0020,0x0030); // For ACR-NEMA images
00394 if (StrImPos == GDCM_UNFOUND) {
00395 dbg.Verbose(0, "gdcmHeader::GetYImagePosition: unfound Image Position (RET) (0020,0030)");
00396 // How to tell the caller nothing was found ?
00397 return 0.;
00398 }
00399 }
00400 if( sscanf( StrImPos.c_str(), "%f\\%f\\%f", &xImPos, &yImPos, &zImPos) != 3)
00401 return 0.;
00402 return yImPos;
00403 }
|
|
|
Retrieve the number of lines of image.
Definition at line 279 of file gdcmHeader.cxx. References GDCM_UNFOUND, gdcmHeader::GetEntryByNumber(), and gdcmHeader::IsDicomV3(). Referenced by gdcmFile::gdcm_read_RLE_file(), gdcmFile::GetImageDataIntoVectorRaw(), gdcmFile::ParsePixelData(), gdcmFile::ReadPixelData(), and gdcmFile::SetPixelDataSizeFromHeader().
00279 {
00280 std::string StrSize = GetEntryByNumber(0x0028,0x0010);
00281 if (StrSize != GDCM_UNFOUND)
00282 return atoi(StrSize.c_str());
00283 if ( IsDicomV3() )
00284 return 0;
00285 else
00286 // The Rows (0028,0010) entry was optional for ACR/NEMA. It might
00287 // hence be a signal (1d image). So we default to 1:
00288 return 1;
00289 }
|
|
|
gets the info from 0028,0030 : Pixel Spacing else 1.
Definition at line 152 of file gdcmHeaderHelper.cxx. References dbg, GDCM_UNFOUND, gdcmHeader::GetEntryByNumber(), and gdcmDebug::Verbose().
00152 {
00153 float xspacing, yspacing;
00154 std::string StrSpacing = GetEntryByNumber(0x0028,0x0030);
00155
00156 if (StrSpacing == GDCM_UNFOUND) {
00157 dbg.Verbose(0, "gdcmHeader::GetYSpacing: unfound Pixel Spacing (0028,0030)");
00158 return 1.;
00159 }
00160 if( sscanf( StrSpacing.c_str(), "%f\\%f", &yspacing, &xspacing) != 2)
00161 return 0.;
00162 if (xspacing == 0.) {
00163 dbg.Verbose(0, "gdcmHeader::GetYSpacing: gdcmData/CT-MONO2-8-abdo.dcm problem");
00164 // seems to be a bug in the header ...
00165 sscanf( StrSpacing.c_str(), "%f\\0\\%f", &yspacing, &xspacing);
00166 }
00167 return yspacing;
00168 }
|
|
|
gets the info from 0020,0032 : Image Position Patient \ else from 0020,0030 : Image Position (RET) \ else from 0020,1041 : Slice Location \ else from 0020,0050 : Location \ else 0.
Definition at line 414 of file gdcmHeaderHelper.cxx. References dbg, GDCM_UNFOUND, gdcmHeader::GetEntryByNumber(), and gdcmDebug::Verbose().
00414 {
00415 float xImPos, yImPos, zImPos;
00416 std::string StrImPos = GetEntryByNumber(0x0020,0x0032);
00417 if (StrImPos != GDCM_UNFOUND) {
00418 if( sscanf( StrImPos.c_str(), "%f\\%f\\%f", &xImPos, &yImPos, &zImPos) != 3) {
00419 dbg.Verbose(0, "gdcmHeader::GetZImagePosition: wrong Image Position Patient (0020,0032)");
00420 return 0.; // bug in the element 0x0020,0x0032
00421 } else {
00422 return zImPos;
00423 }
00424 }
00425 StrImPos = GetEntryByNumber(0x0020,0x0030); // For ACR-NEMA images
00426 if (StrImPos != GDCM_UNFOUND) {
00427 if( sscanf( StrImPos.c_str(), "%f\\%f\\%f", &xImPos, &yImPos, &zImPos) != 3) {
00428 dbg.Verbose(0, "gdcmHeader::GetZImagePosition: wrong Image Position (RET) (0020,0030)");
00429 return 0.; // bug in the element 0x0020,0x0032
00430 } else {
00431 return zImPos;
00432 }
00433 }
00434 std::string StrSliceLocation = GetEntryByNumber(0x0020,0x1041);// for *very* old ACR-NEMA images
00435 if (StrSliceLocation != GDCM_UNFOUND) {
00436 if( sscanf( StrSliceLocation.c_str(), "%f", &zImPos) !=1) {
00437 dbg.Verbose(0, "gdcmHeader::GetZImagePosition: wrong Slice Location (0020,1041)");
00438 return 0.; // bug in the element 0x0020,0x1041
00439 } else {
00440 return zImPos;
00441 }
00442 }
00443 dbg.Verbose(0, "gdcmHeader::GetZImagePosition: unfound Slice Location (0020,1041)");
00444 std::string StrLocation = GetEntryByNumber(0x0020,0x0050);
00445 if (StrLocation != GDCM_UNFOUND) {
00446 if( sscanf( StrLocation.c_str(), "%f", &zImPos) !=1) {
00447 dbg.Verbose(0, "gdcmHeader::GetZImagePosition: wrong Location (0020,0050)");
00448 return 0.; // bug in the element 0x0020,0x0050
00449 } else {
00450 return zImPos;
00451 }
00452 }
00453 dbg.Verbose(0, "gdcmHeader::GetYImagePosition: unfound Location (0020,0050)");
00454 return 0.; // Hopeless
00455 }
|
|
|
Retrieve the number of planes of volume or the number of frames of a multiframe.
Definition at line 300 of file gdcmHeader.cxx. References GDCM_UNFOUND, and gdcmHeader::GetEntryByNumber(). Referenced by gdcmFile::gdcm_read_RLE_file(), gdcmFile::GetImageDataIntoVectorRaw(), and gdcmFile::SetPixelDataSizeFromHeader().
00300 {
00301 // Both DicomV3 and ACR/Nema consider the "Number of Frames"
00302 // as the third dimension.
00303 std::string StrSize = GetEntryByNumber(0x0028,0x0008);
00304 if (StrSize != GDCM_UNFOUND)
00305 return atoi(StrSize.c_str());
00306
00307 // We then consider the "Planes" entry as the third dimension
00308 StrSize = GetEntryByNumber(0x0028,0x0012);
00309 if (StrSize != GDCM_UNFOUND)
00310 return atoi(StrSize.c_str());
00311 return 1;
00312 }
|
|
|
gets the info from 0018,0088 : Space Between Slices else from 0018,0050 : Slice Thickness else 1.
Definition at line 177 of file gdcmHeaderHelper.cxx. References dbg, GDCM_UNFOUND, gdcmHeader::GetEntryByNumber(), and gdcmDebug::Verbose().
00177 {
00178 // Spacing Between Slices : distance entre le milieu de chaque coupe
00179 // Les coupes peuvent etre :
00180 // jointives (Spacing between Slices = Slice Thickness)
00181 // chevauchantes (Spacing between Slices < Slice Thickness)
00182 // disjointes (Spacing between Slices > Slice Thickness)
00183 // Slice Thickness : epaisseur de tissus sur laquelle est acquis le signal
00184 // ca interesse le physicien de l'IRM, pas le visualisateur de volumes ...
00185 // Si le Spacing Between Slices est absent,
00186 // on suppose que les coupes sont jointives
00187
00188 std::string StrSpacingBSlices = GetEntryByNumber(0x0018,0x0088);
00189
00190 if (StrSpacingBSlices == GDCM_UNFOUND) {
00191 dbg.Verbose(0, "gdcmHeader::GetZSpacing: unfound StrSpacingBSlices");
00192 std::string StrSliceThickness = GetEntryByNumber(0x0018,0x0050);
00193 if (StrSliceThickness == GDCM_UNFOUND)
00194 return 1.;
00195 else
00196 // if no 'Spacing Between Slices' is found,
00197 // we assume slices join together
00198 // (no overlapping, no interslice gap)
00199 // if they don't, we're fucked up
00200 return atof(StrSliceThickness.c_str());
00201 } else {
00202 return atof(StrSpacingBSlices.c_str());
00203 }
00204 }
|
|
|
tells us if LUT are used
Definition at line 506 of file gdcmHeader.cxx. References gdcmParser::GetHeaderEntryByNumber(). Referenced by gdcmFile::GetImageDataIntoVector(), gdcmFile::GetImageDataRaw(), GetNumberOfScalarComponents(), and gdcmFile::SetPixelDataSizeFromHeader().
00506 {
00507
00508 // Check the presence of the LUT Descriptors, and LUT Tables
00509 // LutDescriptorRed
00510 if ( !GetHeaderEntryByNumber(0x0028,0x1101) )
00511 return false;
00512 // LutDescriptorGreen
00513 if ( !GetHeaderEntryByNumber(0x0028,0x1102) )
00514 return false;
00515 // LutDescriptorBlue
00516 if ( !GetHeaderEntryByNumber(0x0028,0x1103) )
00517 return false;
00518 // Red Palette Color Lookup Table Data
00519 if ( !GetHeaderEntryByNumber(0x0028,0x1201) )
00520 return false;
00521 // Green Palette Color Lookup Table Data
00522 if ( !GetHeaderEntryByNumber(0x0028,0x1202) )
00523 return false;
00524 // Blue Palette Color Lookup Table Data
00525 if ( !GetHeaderEntryByNumber(0x0028,0x1203) )
00526 return false;
00527 return true;
00528 }
|
|
|
Determines if the Transfer Syntax was already encountered and if it corresponds to a DeflatedExplicitVRLittleEndian one.
Definition at line 279 of file gdcmParser.cxx. References gdcmParser::GetHeaderEntryByNumber(), gdcmHeaderEntry::GetValue(), gdcmParser::LoadHeaderEntrySafe(), and UI1_2_840_10008_1_2_1_99. Referenced by gdcmFile::ParsePixelData(), and gdcmFile::ReadPixelData().
00279 {
00280 gdcmHeaderEntry* Element = GetHeaderEntryByNumber(0x0002, 0x0010);
00281 if ( !Element )
00282 return false;
00283 LoadHeaderEntrySafe(Element);
00284
00285 std::string Transfer = Element->GetValue();
00286 if ( Transfer == UI1_2_840_10008_1_2_1_99 )
00287 return true;
00288 return false;
00289 }
|
|
|
Predicate for dicom version 3 file.
Definition at line 250 of file gdcmHeader.cxx. References gdcmParser::GetHeaderEntryByNumber(). Referenced by gdcmHeader::GetYSize(), gdcmFile::ParsePixelData(), and gdcmFile::ReadPixelData().
00250 {
00251 // Checking if Transfert Syntax exists is enough
00252 // Anyway, it's to late check if the 'Preamble' was found ...
00253 // And ... would it be a rich idea to check ?
00254 // (some 'no Preamble' DICOM images exist !)
00255 return (GetHeaderEntryByNumber(0x0002, 0x0010) != NULL);
00256 }
|
|
|
Determines if the Transfer Syntax was already encountered and if it corresponds to a Explicit VR Big Endian one.
Definition at line 297 of file gdcmParser.cxx. References gdcmParser::GetHeaderEntryByNumber(), gdcmHeaderEntry::GetValue(), gdcmParser::LoadHeaderEntrySafe(), and UI1_2_840_10008_1_2_2. Referenced by gdcmParser::FindHeaderEntryLength(), gdcmFile::ParsePixelData(), and gdcmFile::ReadPixelData().
00297 {
00298 gdcmHeaderEntry* Element = GetHeaderEntryByNumber(0x0002, 0x0010);
00299 if ( !Element )
00300 return false;
00301 LoadHeaderEntrySafe(Element);
00302
00303 std::string Transfer = Element->GetValue();
00304 if ( Transfer == UI1_2_840_10008_1_2_2 ) //1.2.2 ??? A verifier !
00305 return true;
00306 return false;
00307 }
|
|
|
Determines if the Transfer Syntax was already encountered and if it corresponds to a ExplicitVRLittleEndian one.
Definition at line 261 of file gdcmParser.cxx. References gdcmParser::GetHeaderEntryByNumber(), gdcmHeaderEntry::GetValue(), gdcmParser::LoadHeaderEntrySafe(), and UI1_2_840_10008_1_2_1. Referenced by gdcmFile::ParsePixelData(), and gdcmFile::ReadPixelData().
00261 {
00262 gdcmHeaderEntry* Element = GetHeaderEntryByNumber(0x0002, 0x0010);
00263 if ( !Element )
00264 return false;
00265 LoadHeaderEntrySafe(Element);
00266
00267 std::string Transfer = Element->GetValue();
00268 if ( Transfer == UI1_2_840_10008_1_2_1 )
00269 return true;
00270 return false;
00271 }
|
|
|
Determines if the Transfer Syntax was already encountered and if it corresponds to a ImplicitVRLittleEndian one.
Definition at line 243 of file gdcmParser.cxx. References gdcmParser::GetHeaderEntryByNumber(), gdcmHeaderEntry::GetValue(), gdcmParser::LoadHeaderEntrySafe(), and UI1_2_840_10008_1_2. Referenced by gdcmFile::ParsePixelData(), and gdcmFile::ReadPixelData().
00243 {
00244 gdcmHeaderEntry *Element = GetHeaderEntryByNumber(0x0002, 0x0010);
00245 if ( !Element )
00246 return false;
00247 LoadHeaderEntrySafe(Element);
00248
00249 std::string Transfer = Element->GetValue();
00250 if ( Transfer == UI1_2_840_10008_1_2 )
00251 return true;
00252 return false;
00253 }
|
|
|
Determines if the Transfer Syntax was already encountered and if it corresponds to a JPEG2000 one.
Definition at line 232 of file gdcmHeader.cxx. References gdcmParser::GetHeaderEntryByNumber(), gdcmHeaderEntry::GetValue(), and gdcmParser::LoadHeaderEntrySafe(). Referenced by gdcmFile::ReadPixelData().
00232 {
00233 gdcmHeaderEntry* Element = GetHeaderEntryByNumber(0x0002, 0x0010);
00234 if ( !Element )
00235 return false;
00236 LoadHeaderEntrySafe(Element);
00237
00238 std::string Transfer = Element->GetValue();
00239 if ( (Transfer == "1.2.840.10008.1.2.4.90")
00240 || (Transfer == "1.2.840.10008.1.2.4.91") )
00241 return true;
00242 return false;
00243 }
|
|
|
Determines if the Transfer Syntax was already encountered and if it corresponds to a JPEGBaseLineProcess1 one.
Definition at line 120 of file gdcmHeader.cxx. References gdcmParser::GetHeaderEntryByNumber(), gdcmHeaderEntry::GetValue(), and gdcmParser::LoadHeaderEntrySafe().
00120 {
00121 gdcmHeaderEntry* Element = GetHeaderEntryByNumber(0x0002, 0x0010);
00122 if ( !Element )
00123 return false;
00124 LoadHeaderEntrySafe(Element);
00125
00126 std::string Transfer = Element->GetValue();
00127 if ( Transfer == "1.2.840.10008.1.2.4.50" )
00128 return true;
00129 return false;
00130 }
|
|
|
Determines if the Transfer Syntax was already encountered and if it corresponds to a JPEGExtendedProcess2-4 one.
Definition at line 138 of file gdcmHeader.cxx. References gdcmParser::GetHeaderEntryByNumber(), gdcmHeaderEntry::GetValue(), and gdcmParser::LoadHeaderEntrySafe().
00138 {
00139 gdcmHeaderEntry* Element = GetHeaderEntryByNumber(0x0002, 0x0010);
00140 if ( !Element )
00141 return false;
00142 LoadHeaderEntrySafe(Element);
00143 return ( Element->GetValue() == "1.2.840.10008.1.2.4.51" );
00144 }
|
|
|
Determines if the Transfer Syntax was already encountered and if it corresponds to a JPEGExtendeProcess3-5 one.
Definition at line 152 of file gdcmHeader.cxx. References gdcmParser::GetHeaderEntryByNumber(), gdcmHeaderEntry::GetValue(), and gdcmParser::LoadHeaderEntrySafe().
00152 {
00153 gdcmHeaderEntry* Element = GetHeaderEntryByNumber(0x0002, 0x0010);
00154 if ( !Element )
00155 return false;
00156 LoadHeaderEntrySafe(Element);
00157
00158 std::string Transfer = Element->GetValue();
00159 if ( Transfer == "1.2.840.10008.1.2.4.52" )
00160 return true;
00161 return false;
00162 }
|
|
|
Determines if Transfer Syntax was already encountered and if it corresponds to a JPEG Lossless one.
Definition at line 210 of file gdcmHeader.cxx. References gdcmParser::GetHeaderEntryByNumber(), gdcmHeaderEntry::GetValue(), and gdcmParser::LoadHeaderEntrySafe(). Referenced by gdcmFile::ReadPixelData().
00210 {
00211 gdcmHeaderEntry* Element = GetHeaderEntryByNumber(0x0002, 0x0010);
00212 // faire qq chose d'intelligent a la place de ça
00213 if ( !Element )
00214 return false;
00215 LoadHeaderEntrySafe(Element);
00216
00217 const char * Transfert = Element->GetValue().c_str();
00218 if ( memcmp(Transfert+strlen(Transfert)-2 ,"70",2)==0) return true;
00219 if ( memcmp(Transfert+strlen(Transfert)-2 ,"55",2)==0) return true;
00220 if (Element->GetValue() == "1.2.840.10008.1.2.4.57") return true;
00221
00222 return false;
00223 }
|
|
|
Determines if the Transfer Syntax was already encountered and if it corresponds to a JPEGSpectralSelectionProcess6-8 one.
Definition at line 171 of file gdcmHeader.cxx. References gdcmParser::GetHeaderEntryByNumber(), gdcmHeaderEntry::GetValue(), and gdcmParser::LoadHeaderEntrySafe().
00171 {
00172 gdcmHeaderEntry* Element = GetHeaderEntryByNumber(0x0002, 0x0010);
00173 if ( !Element )
00174 return false;
00175 LoadHeaderEntrySafe(Element);
00176
00177 std::string Transfer = Element->GetValue();
00178 if ( Transfer == "1.2.840.10008.1.2.4.53" )
00179 return true;
00180 return false;
00181 }
|
|
|
This predicate, based on hopefully reasonable heuristics, decides whether or not the current gdcmParser was properly parsed and contains the mandatory information for being considered as a well formed and usable Dicom/Acr File.
Reimplemented from gdcmParser. Definition at line 96 of file gdcmHeader.cxx. References GDCM_UNFOUND, gdcmHeader::GetEntryByNumber(), gdcmParser::GetHeaderEntryByNumber(), and gdcmParser::IsReadable(). Referenced by gdcmFile::gdcmFile(), and gdcmDicomDir::NewDicomDir().
00096 {
00097 if(!gdcmParser::IsReadable()) {
00098 return(false);
00099 }
00100 std::string res = GetEntryByNumber(0x0028, 0x0005);
00101 if ( res != GDCM_UNFOUND && atoi(res.c_str()) > 4 )
00102 return false; // Image Dimensions
00103 if ( !GetHeaderEntryByNumber(0x0028, 0x0100) )
00104 return false; // "Bits Allocated"
00105 if ( !GetHeaderEntryByNumber(0x0028, 0x0101) )
00106 return false; // "Bits Stored"
00107 if ( !GetHeaderEntryByNumber(0x0028, 0x0102) )
00108 return false; // "High Bit"
00109 if ( !GetHeaderEntryByNumber(0x0028, 0x0103) )
00110 return false; // "Pixel Representation" i.e. 'Sign'
00111 return true;
00112 }
|
|
|
Determines if the Transfer Syntax was already encountered and if it corresponds to a RLE Lossless one.
Definition at line 190 of file gdcmHeader.cxx. References gdcmParser::GetHeaderEntryByNumber(), gdcmHeaderEntry::GetValue(), and gdcmParser::LoadHeaderEntrySafe(). Referenced by gdcmFile::ParsePixelData(), and gdcmFile::ReadPixelData().
00190 {
00191 gdcmHeaderEntry* Element = GetHeaderEntryByNumber(0x0002, 0x0010);
00192 if ( !Element )
00193 return false;
00194 LoadHeaderEntrySafe(Element);
00195
00196 std::string Transfer = Element->GetValue();
00197 if ( Transfer == "1.2.840.10008.1.2.5" ) {
00198 return true;
00199 }
00200 return false;
00201 }
|
|
||||||||||||
|
Loads (from disk) the element content when a string is not suitable.
Definition at line 734 of file gdcmParser.cxx. References gdcmParser::fp, gdcmParser::GetHeaderEntryByNumber(), gdcmHeaderEntry::GetLength(), gdcmHeaderEntry::GetOffset(), and gdcmParser::SetEntryVoidAreaByNumber(). Referenced by gdcmParser::LoadHeaderEntries().
00735 {
00736 gdcmHeaderEntry * Element= GetHeaderEntryByNumber(Group, Elem);
00737 if ( !Element )
00738 return NULL;
00739 size_t o =(size_t)Element->GetOffset();
00740 fseek(fp, o, SEEK_SET);
00741 int l=Element->GetLength();
00742 void * a = malloc(l);
00743 if(!a)
00744 return NULL;
00745
00746 SetEntryVoidAreaByNumber(a, Group, Elem);
00747 // TODO check the result
00748 size_t l2 = fread(a, 1, l ,fp);
00749 if(l != l2)
00750 {
00751 free(a);
00752 return NULL;
00753 }
00754
00755 return a;
00756 }
|
|
|
Loads the element while preserving the current underlying file position indicator as opposed to to LoadHeaderEntry that modifies it.
Definition at line 877 of file gdcmParser.cxx. References gdcmParser::fp, and gdcmParser::LoadHeaderEntry(). Referenced by gdcmParser::IsDeflatedExplicitVRLittleEndianTransferSyntax(), gdcmParser::IsExplicitVRBigEndianTransferSyntax(), gdcmParser::IsExplicitVRLittleEndianTransferSyntax(), gdcmParser::IsImplicitVRLittleEndianTransferSyntax(), gdcmHeader::IsJPEG2000(), gdcmHeader::IsJPEGBaseLineProcess1TransferSyntax(), gdcmHeader::IsJPEGExtendedProcess2_4TransferSyntax(), gdcmHeader::IsJPEGExtendedProcess3_5TransferSyntax(), gdcmHeader::IsJPEGLossless(), gdcmHeader::IsJPEGSpectralSelectionProcess6_8TransferSyntax(), and gdcmHeader::IsRLELossLessTransferSyntax().
00877 {
00878 long PositionOnEntry = ftell(fp);
00879 LoadHeaderEntry(entry);
00880 fseek(fp, PositionOnEntry, SEEK_SET);
00881 }
|
|
|
opens the file
Definition at line 325 of file gdcmParser.cxx. References dbg, and gdcmDebug::Verbose(). Referenced by gdcmParser::gdcmParser(), gdcmFile::ParsePixelData(), and gdcmFile::ReadPixelData().
00327 {
00328 fp=fopen(filename.c_str(),"rb");
00329 if(exception_on_error)
00330 {
00331 if(!fp)
00332 throw gdcmFileError("gdcmParser::gdcmParser(const char *, bool)");
00333 }
00334
00335 if ( fp )
00336 {
00337 guint16 zero;
00338 fread(&zero, (size_t)2, (size_t)1, fp);
00339
00340 //ACR -- or DICOM with no Preamble --
00341 if( zero == 0x0008 || zero == 0x0800 || zero == 0x0002 || zero == 0x0200)
00342 return(fp);
00343
00344 //DICOM
00345 fseek(fp, 126L, SEEK_CUR);
00346 char dicm[4];
00347 fread(dicm, (size_t)4, (size_t)1, fp);
00348 if( memcmp(dicm, "DICM", 4) == 0 )
00349 return(fp);
00350
00351 fclose(fp);
00352 dbg.Verbose(0, "gdcmParser::OpenFile not DICOM/ACR", filename.c_str());
00353 }
00354 else {
00355 dbg.Verbose(0, "gdcmParser::OpenFile cannot open file", filename.c_str());
00356 }
00357 return(NULL);
00358 }
|
|
|
compares 2 Headers, according to DICOMDIR rules --> not-for-rats function
Definition at line 743 of file gdcmHeader.cxx. References gdcmHeader::GetEntryByNumber().
00743 {
00744 std::string s1,s2;
00745
00746 // Patient Name
00747 s1=this->GetEntryByNumber(0x0010,0x0010);
00748 s2=header.GetEntryByNumber(0x0010,0x0010);
00749 if(s1 < s2)
00750 return(true);
00751 else if(s1 > s2)
00752 return(false);
00753 else
00754 {
00755 // Patient ID
00756 s1=this->GetEntryByNumber(0x0010,0x0020);
00757 s2=header.GetEntryByNumber(0x0010,0x0020);
00758 if (s1 < s2)
00759 return(true);
00760 else if (s1 > s2)
00761 return(1);
00762 else
00763 {
00764 // Study Instance UID
00765 s1=this->GetEntryByNumber(0x0020,0x000d);
00766 s2=header.GetEntryByNumber(0x0020,0x000d);
00767 if (s1 < s2)
00768 return(true);
00769 else if(s1 > s2)
00770 return(false);
00771 else
00772 {
00773 // Serie Instance UID
00774 s1=this->GetEntryByNumber(0x0020,0x000e);
00775 s2=header.GetEntryByNumber(0x0020,0x000e);
00776 if (s1 < s2)
00777 return(true);
00778 else if(s1 > s2)
00779 return(false);
00780 }
00781 }
00782 }
00783 return(false);
00784 }
|
|
|
Reimplemented in gdcmDicomDir. Definition at line 52 of file gdcmParser.h.
00052 {PrintEntry(os);};
|
|
|
Prints the Header Entries (Dicom Elements) both from the H Table and the chained list.
Definition at line 148 of file gdcmParser.cxx. References gdcmParser::listEntries.
00148 {
00149 std::ostringstream s;
00150
00151 for (ListTag::iterator i = listEntries.begin();
00152 i != listEntries.end();
00153 ++i)
00154 {
00155 (*i)->SetPrintLevel(printLevel);
00156 (*i)->Print(os);
00157 }
00158 os<<s.str();
00159 }
|
|
|
Prints The Dict Entries of THE public Dicom Dictionnry.
Definition at line 166 of file gdcmParser.cxx. References gdcmDict::Print(), and gdcmParser::RefPubDict.
00166 {
00167 RefPubDict->Print(os);
00168 }
|
|
|
Prints The Dict Entries of THE shadow Dicom Dictionnry.
Definition at line 175 of file gdcmParser.cxx. References gdcmDict::Print(), and gdcmParser::RefShaDict.
00175 {
00176 RefShaDict->Print(os);
00177 }
|
|
||||||||||||||||
|
Set a new value if the invoked element exists Seems to be useless !!!
Definition at line 491 of file gdcmParser.cxx. References gdcmParser::SetEntryByNumber(). Referenced by gdcmHeader::anonymizeHeader().
00492 {
00493 std::string v = Value;
00494 SetEntryByNumber(v, Group, Elem);
00495 return true;
00496 }
|
|
||||||||||||||||
|
Modifies the value of a given Header Entry (Dicom Element) if it exists; Creates it with the given value if it doesn't.
Definition at line 469 of file gdcmParser.cxx. References gdcmParser::AddHeaderEntry(), gdcmParser::NewHeaderEntryByNumber(), and gdcmParser::SetEntryByNumber().
00469 {
00470 gdcmHeaderEntry* nvHeaderEntry=NewHeaderEntryByNumber(Group, Elem);
00471
00472 if(!nvHeaderEntry)
00473 return(false);
00474
00475 AddHeaderEntry(nvHeaderEntry);
00476
00477 std::string v = Value;
00478 SetEntryByNumber(v, Group, Elem);
00479 return(true);
00480 }
|
|
||||||||||||||||
|
Modifies the value of a given Header Entry (Dicom Element) if it exists; Creates it with the given value if it doesn't.
Definition at line 446 of file gdcmParser.cxx. References gdcmParser::AddHeaderEntry(), gdcmParser::CheckIfEntryExistByNumber(), gdcmParser::NewHeaderEntryByNumber(), and gdcmParser::SetEntryByNumber(). Referenced by gdcmHeader::anonymizeHeader(), and gdcmParser::Write().
00448 {
00449 if (CheckIfEntryExistByNumber(Group, Elem) == 0) {
00450 gdcmHeaderEntry *a =NewHeaderEntryByNumber(Group, Elem);
00451 if (a == NULL)
00452 return false;
00453 AddHeaderEntry(a);
00454 }
00455 SetEntryByNumber(Value, Group, Elem);
00456 return(true);
00457 }
|
|
||||||||||||
|
Sets the value (string) of the Header Entry (Dicom Element).
Reimplemented from gdcmParser. Definition at line 97 of file gdcmHeader.h. References gdcmParser::SetEntryByName().
00098 { return(gdcmParser::SetEntryByName(content,tagName)); }
|
|
||||||||||||||||
|
Accesses an existing gdcmHeaderEntry (i.e. a Dicom Element) through it's (group, element) and modifies it's content with the given value.
Reimplemented from gdcmParser. Definition at line 95 of file gdcmHeader.h. References gdcmParser::SetEntryByNumber(). Referenced by gdcmFile::GetImageDataIntoVector(), gdcmFile::GetImageDataIntoVectorRaw(), gdcmHeader::SetImageDataSize(), and gdcmFile::WriteBase().
00096 { return(gdcmParser::SetEntryByNumber(content,group,element)); }
|
|
||||||||||||||||
|
Accesses an existing gdcmHeaderEntry (i.e. a Dicom Element) in the PubHeaderEntrySet of this instance through it's (group, element) and modifies it's length with the given value.
Reimplemented from gdcmParser. Definition at line 100 of file gdcmHeader.h. References gdcmParser::SetEntryLengthByNumber().
00101 { return(gdcmParser::SetEntryLengthByNumber(l,group,element)); }
|
|
||||||||||||||||
|
Sets a 'non string' value to a given Dicom Element.
Definition at line 766 of file gdcmParser.cxx. References gdcmParser::tagHT, TagKey, and gdcmDictEntry::TranslateToKey(). Referenced by gdcmParser::LoadEntryVoidArea().
00769 {
00770 TagKey key = gdcmDictEntry::TranslateToKey(group, element);
00771 if ( ! tagHT.count(key))
00772 return false;
00773 ( ((tagHT.equal_range(key)).first)->second )->SetVoidArea(area);
00774 return true;
00775 }
|
|
|
Sets the Pixel Area size in the Header --> not-for-rats function.
Definition at line 716 of file gdcmHeader.cxx. References gdcmParser::GetHeaderEntryByNumber(), gdcmHeader::SetEntryByNumber(), and gdcmHeaderEntry::SetLength(). Referenced by gdcmFile::SetImageData().
00716 {
00717 std::string content1;
00718 char car[20];
00719
00720 // Assumes HeaderEntry (GrPixel, NumPixel) is unique ...
00721 // TODO deal with multiplicity (see gdcmData/icone.dcm)
00722 sprintf(car,"%d",ImageDataSize);
00723
00724 gdcmHeaderEntry *a = GetHeaderEntryByNumber(GrPixel, NumPixel);
00725 a->SetLength(ImageDataSize);
00726
00727 ImageDataSize+=8;
00728 sprintf(car,"%d",ImageDataSize);
00729 content1=car;
00730 SetEntryByNumber(content1, GrPixel, NumPixel);
00731 }
|
|
|
Sets the print level for the Dicom Header.
Reimplemented in gdcmDicomDir. Definition at line 51 of file gdcmParser.h.
00051 { printLevel = level; };
|
|
|
Set the shadow dictionary used.
Definition at line 212 of file gdcmParser.cxx. References DictKey, gdcmDictSet::GetDict(), gdcmGlobal::GetDicts(), and gdcmParser::RefShaDict.
00212 {
00213 RefShaDict=gdcmGlobal::GetDicts()->GetDict(dictName);
00214 return(!RefShaDict);
00215 }
|
|
|
Set the shadow dictionary used.
Definition at line 202 of file gdcmParser.cxx. References gdcmParser::RefShaDict.
00202 {
00203 RefShaDict=dict;
00204 return(!RefShaDict);
00205 }
|
|
|
Swaps back the bytes of 4-byte long integer accordingly to processor order.
Definition at line 1156 of file gdcmParser.cxx. References dbg, gdcmDebug::Error(), and gdcmParser::sw. Referenced by gdcmFile::gdcm_read_RLE_file(), gdcmParser::GetHeaderEntryValue(), gdcmFile::ParsePixelData(), gdcmParser::ReadInt32(), gdcmFile::ReadPixelData(), and gdcmParser::UnswapLong().
01156 {
01157 switch (sw) {
01158 case 0 :
01159 break;
01160 case 4321 :
01161 a=( ((a<<24) & 0xff000000) | ((a<<8) & 0x00ff0000) |
01162 ((a>>8) & 0x0000ff00) | ((a>>24) & 0x000000ff) );
01163 break;
01164
01165 case 3412 :
01166 a=( ((a<<16) & 0xffff0000) | ((a>>16) & 0x0000ffff) );
01167 break;
01168
01169 case 2143 :
01170 a=( ((a<<8) & 0xff00ff00) | ((a>>8) & 0x00ff00ff) );
01171 break;
01172 default :
01173 dbg.Error(" gdcmParser::SwapLong : unset swap code");
01174 a=0;
01175 }
01176 return(a);
01177 }
|
|
|
Swaps the bytes so they agree with the processor order.
Definition at line 1194 of file gdcmParser.cxx. References gdcmParser::sw. Referenced by gdcmParser::FindHeaderEntryLength(), gdcmFile::gdcm_read_RLE_file(), gdcmParser::GetHeaderEntryValue(), gdcmFile::ParsePixelData(), gdcmParser::ReadInt16(), gdcmFile::ReadPixelData(), and gdcmParser::UnswapShort().
01194 {
01195 if ( (sw==4321) || (sw==2143) )
01196 a =(((a<<8) & 0x0ff00) | ((a>>8)&0x00ff));
01197 return (a);
01198 }
|
|
|
Unswaps back the bytes of 4-byte long integer accordingly to processor order.
Definition at line 1185 of file gdcmParser.cxx. References gdcmParser::SwapLong().
01185 {
01186 return (SwapLong(a));
01187 }
|
|
|
Unswaps the bytes so they agree with the processor order.
Definition at line 1205 of file gdcmParser.cxx. References gdcmParser::SwapShort().
01205 {
01206 return (SwapShort(a));
01207 }
|
|
||||||||||||
|
Re-computes the length of a ACR-NEMA/Dicom group from a DcmHeader.
Definition at line 892 of file gdcmParser.cxx. References gdcmParser::AddHeaderEntry(), ExplicitVR, gdcmHeaderEntry::GetElement(), gdcmHeaderEntry::GetGroup(), gdcmParser::GetHeaderEntryByNumber(), gdcmHeaderEntry::GetLength(), gdcmHeaderEntry::GetVR(), GroupHT, GroupKey, gdcmHeaderEntry::SetLength(), gdcmHeaderEntry::SetValue(), gdcmParser::tagHT, and TagKey.
00892 {
00893 guint16 gr, el;
00894 std::string vr;
00895
00896 gdcmHeaderEntry *elem;
00897 char trash[10];
00898 std::string str_trash;
00899
00900 GroupKey key;
00901 GroupHT groupHt; // to hold the length of each group
00902 TagKey tk;
00903 // remember :
00904 // typedef std::map<GroupKey, int> GroupHT;
00905
00906 gdcmHeaderEntry *elemZ;
00907
00908 // for each Tag in the DCM Header
00909
00910 for (TagHeaderEntryHT::iterator tag2 = tagHT.begin();
00911 tag2 != tagHT.end();
00912 ++tag2)
00913 {
00914 elem = tag2->second;
00915 gr = elem->GetGroup();
00916 el = elem->GetElement();
00917 vr = elem->GetVR();
00918
00919 sprintf(trash, "%04x", gr);
00920 key = trash; // generate 'group tag'
00921
00922 // if the caller decided not to take SEQUENCEs into account
00923 // e.g : he wants to write an ACR-NEMA File
00924
00925 if (SkipSequence && vr == "SQ")
00926 continue;
00927
00928 // Still unsolved problem :
00929 // we cannot find the 'Sequence Delimitation Item'
00930 // since it's at the end of the Hash Table
00931 // (fffe,e0dd)
00932
00933 // pas SEQUENCE en ACR-NEMA
00934 // WARNING :
00935 // --> la descente a l'interieur' des SQ
00936 // devrait etre faite avec une liste chainee, pas avec une HTable...
00937
00938 if ( groupHt.count(key) == 0) // we just read the first elem of a given group
00939 {
00940 if (el == 0x0000) // the first elem is 0x0000
00941 {
00942 groupHt[key] = 0; // initialize group length
00943 }
00944 else
00945 {
00946 groupHt[key] = 2 + 2 + 4 + elem->GetLength(); // non 0x0000 first group elem
00947 }
00948 }
00949 else // any elem but the first
00950 {
00951 if (type == ExplicitVR)
00952 {
00953 if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") )
00954 {
00955 groupHt[key] += 4; // explicit VR AND OB, OW, SQ : 4 more bytes
00956 }
00957 }
00958 groupHt[key] += 2 + 2 + 4 + elem->GetLength();
00959 }
00960 }
00961
00962 unsigned short int gr_bid;
00963
00964 for (GroupHT::iterator g = groupHt.begin(); // for each group we found
00965 g != groupHt.end();
00966 ++g)
00967 {
00968 // FIXME: g++ -Wall -Wstrict-prototypes reports on following line:
00969 // warning: unsigned int format, different type arg
00970 sscanf(g->first.c_str(),"%x",&gr_bid);
00971 tk = g->first + "|0000"; // generate the element full tag
00972
00973 if ( tagHT.count(tk) == 0) // if element 0x0000 not found
00974 {
00975 gdcmDictEntry * tagZ = new gdcmDictEntry(gr_bid, 0x0000, "UL");
00976 elemZ = new gdcmHeaderEntry(tagZ);
00977 elemZ->SetLength(4);
00978 AddHeaderEntry(elemZ); // create it
00979 }
00980 else
00981 {
00982 elemZ=GetHeaderEntryByNumber(gr_bid, 0x0000);
00983 }
00984 sprintf(trash ,"%d",g->second);
00985 str_trash=trash;
00986 elemZ->SetValue(str_trash);
00987 }
00988 }
|
|
|
Update the entries with the shadow dictionary. Only non even entries are analyzed.
Reimplemented from gdcmParser. Definition at line 103 of file gdcmHeader.h. References gdcmParser::UpdateShaEntries().
00104 { gdcmParser::UpdateShaEntries(); }
|
|
||||||||||||
|
Definition at line 381 of file gdcmParser.cxx. References ExplicitVR, gdcmParser::ReplaceOrCreateByNumber(), gdcmParser::SetEntryLengthByNumber(), UI1_2_840_10008_1_2, UI1_2_840_10008_1_2_1, and gdcmParser::WriteEntries(). Referenced by gdcmFile::WriteBase().
00381 {
00382 // ==============
00383 // TODO The stuff was rewritten using the chained list instead
00384 // of the H table
00385 // so we could remove the GroupHT from the gdcmParser
00386 // To be checked
00387 // =============
00388
00389 // TODO : move the following lines (and a lot of others, to be written)
00390 // to a future function CheckAndCorrectHeader
00391
00392 // Question :
00393 // Comment pourrait-on savoir si le DcmHeader vient d'un fichier DicomV3 ou non
00394 // (FileType est un champ de gdcmParser ...)
00395 // WARNING : Si on veut ecrire du DICOM V3 a partir d'un DcmHeader ACR-NEMA
00396 // no way
00397 // a moins de se livrer a un tres complique ajout des champs manquants.
00398 // faire un CheckAndCorrectHeader (?)
00399
00400
00401 if (type == ImplicitVR)
00402 {
00403 std::string implicitVRTransfertSyntax = UI1_2_840_10008_1_2;
00404 ReplaceOrCreateByNumber(implicitVRTransfertSyntax,0x0002, 0x0010);
00405
00406 //FIXME Refer to standards on page 21, chapter 6.2 "Value representation":
00407 // values with a VR of UI shall be padded with a single trailing null
00408 // Dans le cas suivant on doit pader manuellement avec un 0
00409
00410 SetEntryLengthByNumber(18, 0x0002, 0x0010);
00411 }
00412
00413 if (type == ExplicitVR)
00414 {
00415 std::string explicitVRTransfertSyntax = UI1_2_840_10008_1_2_1;
00416 ReplaceOrCreateByNumber(explicitVRTransfertSyntax,0x0002, 0x0010);
00417
00418 //FIXME Refer to standards on page 21, chapter 6.2 "Value representation":
00419 // values with a VR of UI shall be padded with a single trailing null
00420 // Dans le cas suivant on doit pader manuellement avec un 0
00421
00422 SetEntryLengthByNumber(20, 0x0002, 0x0010);
00423 }
00424
00425 /* TODO : rewrite later
00426
00427 if ( (type == ImplicitVR) || (type == ExplicitVR) )
00428 UpdateGroupLength(false,type);
00429 if ( type == ACR)
00430 UpdateGroupLength(true,ACR);
00431 */
00432
00433 WriteEntries(fp,type);
00434 return(true);
00435 }
|
|
|
|
|
||||||||||||
|
writes on disc according to the requested format (ACR-NEMA, ExplicitVR, ImplicitVR) the image
Definition at line 1003 of file gdcmParser.cxx. References ACR, gdcmParser::countGrPixel, DICOMDIR, ExplicitVR, gdcmParser::GrPixel, gdcmParser::listEntries, gdcmParser::NumPixel, and Tokenize(). Referenced by gdcmParser::Write(), and gdcmDicomDir::Write().
01004 {
01005 guint16 gr, el;
01006 guint32 lgr;
01007 std::string value;
01008 const char * val;
01009 std::string vr;
01010 guint32 val_uint32;
01011 guint16 val_uint16;
01012 guint16 valZero =0;
01013 void *voidArea;
01014 std::vector<std::string> tokens;
01015
01016 // TODO : function CheckHeaderCoherence to be written
01017
01018 // uses now listEntries to iterate, not TagHt!
01019 //
01020 // pb : gdcmParser.Add does NOT update listEntries
01021 // TODO : find a trick (in STL?) to do it, at low cost !
01022
01023 void *ptr;
01024
01025 // TODO (?) tester les echecs en ecriture (apres chaque fwrite)
01026 int compte =0;
01027
01028 for (ListTag::iterator tag2=listEntries.begin();
01029 tag2 != listEntries.end();
01030 ++tag2)
01031 {
01032 // === Deal with the length
01033 // --------------------
01034 if(((*tag2)->GetLength())%2==1)
01035 {
01036 (*tag2)->SetValue((*tag2)->GetValue()+"\0");
01037 (*tag2)->SetLength((*tag2)->GetLength()+1);
01038 }
01039
01040 gr = (*tag2)->GetGroup();
01041 el = (*tag2)->GetElement();
01042 lgr = (*tag2)->GetReadLength();
01043 val = (*tag2)->GetValue().c_str();
01044 vr = (*tag2)->GetVR();
01045 voidArea = (*tag2)->GetVoidArea();
01046
01047 if ( type == ACR )
01048 {
01049 if (gr < 0x0008) continue; // ignore pure DICOM V3 groups
01050 if (gr %2) continue; // ignore shadow groups
01051 if (vr == "SQ" ) continue; // ignore Sequences
01052 // TODO : find a trick to *skip* the SeQuences !
01053 // Not only ignore the SQ element
01054 if (gr == 0xfffe ) continue; // ignore delimiters
01055 }
01056
01057 fwrite ( &gr,(size_t)2 ,(size_t)1 ,_fp); //group
01058 fwrite ( &el,(size_t)2 ,(size_t)1 ,_fp); //element
01059
01060 // if ( (type == ExplicitVR) && (gr <= 0x0002) ) // ?!? < 2
01061 if ( (type == ExplicitVR) || (type == DICOMDIR) )
01062 {
01063 // EXPLICIT VR
01064 guint16 z=0, shortLgr;
01065 if (vr == "unkn")
01066 { // Unknown was 'written'
01067 shortLgr=lgr;
01068 fwrite ( &shortLgr,(size_t)2 ,(size_t)1 ,_fp);
01069 fwrite ( &z, (size_t)2 ,(size_t)1 ,_fp);
01070 }
01071 else
01072 {
01073 if (gr != 0xfffe)
01074 { // NO value for 'delimiters'
01075 if (vr == "unkn") // Unknown was 'written'
01076 fwrite(&z,(size_t)2 ,(size_t)1 ,_fp);
01077 else
01078 fwrite (vr.c_str(),(size_t)2 ,(size_t)1 ,_fp);
01079 }
01080
01081 if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") || gr == 0xfffe)
01082 {
01083 if (gr != 0xfffe)
01084 fwrite ( &z, (size_t)2 ,(size_t)1 ,_fp);
01085 fwrite ( &lgr,(size_t)4 ,(size_t)1 ,_fp);
01086 }
01087 else
01088 {
01089 shortLgr=lgr;
01090 fwrite ( &shortLgr,(size_t)2 ,(size_t)1 ,_fp);
01091 }
01092 }
01093 }
01094 else // IMPLICIT VR
01095 {
01096 fwrite ( &lgr,(size_t)4 ,(size_t)1 ,_fp);
01097 }
01098
01099 // === Deal with the value
01100 // -------------------
01101 if (vr == "SQ") continue; // no "value" to write for the SEQuences
01102 if (gr == 0xfffe)continue;
01103
01104 if (voidArea != NULL)
01105 { // there is a 'non string' LUT, overlay, etc
01106 fwrite ( voidArea,(size_t)lgr ,(size_t)1 ,_fp); // Elem value
01107 continue;
01108 }
01109
01110 if (vr == "US" || vr == "SS")
01111 {
01112 tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
01113 Tokenize ((*tag2)->GetValue(), tokens, "\\");
01114 for (unsigned int i=0; i<tokens.size();i++)
01115 {
01116 val_uint16 = atoi(tokens[i].c_str());
01117 ptr = &val_uint16;
01118 fwrite ( ptr,(size_t)2 ,(size_t)1 ,_fp);
01119 }
01120 tokens.clear();
01121 continue;
01122 }
01123 if (vr == "UL" || vr == "SL")
01124 {
01125 tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
01126 Tokenize ((*tag2)->GetValue(), tokens, "\\");
01127 for (unsigned int i=0; i<tokens.size();i++)
01128 {
01129 val_uint32 = atoi(tokens[i].c_str());
01130 ptr = &val_uint32;
01131 fwrite ( ptr,(size_t)4 ,(size_t)1 ,_fp);
01132 }
01133 tokens.clear();
01134 continue;
01135 }
01136
01137 // Pixels are never loaded in the element !
01138 // we stop writting when Pixel are processed
01139 // FIX : we loose trailing elements (RAB, right now)
01140
01141 if ((gr == GrPixel) && (el == NumPixel) ) {
01142 compte++;
01143 if (compte == countGrPixel) // we passed *all* the GrPixel,NumPixel
01144 break;
01145 }
01146 fwrite ( val,(size_t)lgr ,(size_t)1 ,_fp); // Elem value
01147 }
01148 }
|
|
|
Definition at line 160 of file gdcmParser.h. Referenced by gdcmParser::WriteEntries(). |
|
|
Definition at line 152 of file gdcmParser.h. Referenced by gdcmParser::FixHeaderEntryFoundLength(), and gdcmParser::gdcmParser(). |
|
|
Definition at line 142 of file gdcmParser.h. Referenced by gdcmParser::CheckSwap(), gdcmParser::FindHeaderEntryLength(), gdcmParser::FindHeaderEntryVR(), gdcmParser::GetFileType(), gdcmParser::IsReadable(), and gdcmParser::LoadHeaderEntries(). |
|
|
Definition at line 141 of file gdcmParser.h. Referenced by gdcmParser::CheckSwap(), gdcmParser::CloseFile(), gdcmParser::FindHeaderEntryLength(), gdcmParser::FindHeaderEntryLengthOB(), gdcmParser::FindHeaderEntryVR(), gdcmParser::IsHeaderEntryAnInteger(), gdcmParser::LoadEntryVoidArea(), gdcmParser::LoadHeaderEntries(), gdcmParser::LoadHeaderEntry(), gdcmParser::LoadHeaderEntrySafe(), gdcmParser::ReadInt16(), gdcmParser::ReadInt32(), gdcmParser::ReadNextHeaderEntry(), and gdcmParser::SkipBytes(). |
|
|
Definition at line 156 of file gdcmParser.h. Referenced by gdcmParser::FindHeaderEntryLength(), and gdcmParser::WriteEntries(). |
|
|
Definition at line 69 of file gdcmParser.cxx. Referenced by gdcmParser::CheckSwap(). |
|
|
Definition at line 150 of file gdcmParser.h. Referenced by gdcmParser::AddHeaderEntry(), gdcmParser::IsReadable(), gdcmParser::PrintEntry(), gdcmParser::UpdateShaEntries(), and gdcmParser::WriteEntries(). |
|
|
Definition at line 72 of file gdcmParser.cxx. Referenced by gdcmParser::gdcmParser(). |
|
|
Definition at line 76 of file gdcmParser.cxx. |
|
|
Definition at line 157 of file gdcmParser.h. Referenced by gdcmParser::FindHeaderEntryLength(), and gdcmParser::WriteEntries(). |
|
|
Definition at line 153 of file gdcmParser.h. |
|
|
Definition at line 149 of file gdcmParser.h. Referenced by gdcmParser::AddHeaderEntry(), gdcmParser::CheckIfEntryExistByNumber(), gdcmParser::GenerateFreeTagKeyInGroup(), gdcmParser::GetEntryByNumber(), gdcmParser::GetHeaderEntryByNumber(), gdcmParser::GetHeaderEntrySameNumber(), gdcmParser::SetEntryByNumber(), gdcmParser::SetEntryLengthByNumber(), gdcmParser::SetEntryVoidAreaByNumber(), and gdcmParser::UpdateGroupLength(). |
1.3.6