GDCM 2026-06-18 (2b923808)

Code extracted from:

    https://github.com/malaterre/GDCM.git

at commit 2b9238088772254f66b2764b7e4a18e011c63926 (v3.2.8).

Author: GDCM Upstream

CMakeLists.txt

@@ -10,7 +10,7 @@ endif()
 #----------------------------------------------------------------------------
 
 project(GDCM
-  VERSION 3.3.0
+  VERSION 3.2.8
   LANGUAGES CXX C
 )
 ## NOTE: the "DESCRIPTION" feature of project() was introduced in cmake 3.10.0
@@ -86,7 +86,10 @@ if(GDCM_VERSION_MINOR MATCHES "[02468]$")
   # So unless the user *specifically* requested a particular cmake_build_type
   # do the work internally and append the NDEBUG def flag (hopefully portable)
   if(NOT CMAKE_BUILD_TYPE)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNDEBUG")
+    get_cmake_property(is_multi_config_generator GENERATOR_IS_MULTI_CONFIG)
+    if (NOT is_multi_config_generator)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNDEBUG")
+    endif()
   endif()
   # Since we are on a release branch, chance is that people don't care about testing
   # let's disable it for them
@@ -334,8 +337,7 @@ option(GDCM_USE_SYSTEM_JSON "Use system json" OFF)
 option(GDCM_USE_SYSTEM_PAPYRUS3 "Use system papyrus3" OFF)
 option(GDCM_USE_SYSTEM_SOCKETXX "Use system socket++" OFF)
 option(GDCM_USE_SYSTEM_LJPEG "Use system ljpeg (ijg lib)" OFF)
-option(GDCM_USE_SYSTEM_OPENJPEG "Use system openjpeg" OFF)
-option(GDCM_USE_SYSTEM_CHARLS "Use system charls" OFF)
+option(GDCM_USE_JPEGTURBO "Use libjpeg-turbo instead of IJG for JPEG codec" OFF)
 mark_as_advanced(
   GDCM_USE_SYSTEM_ZLIB
   GDCM_USE_SYSTEM_OPENSSL
@@ -347,6 +349,7 @@ mark_as_advanced(
   GDCM_USE_SYSTEM_LJPEG
   GDCM_USE_SYSTEM_OPENJPEG
   GDCM_USE_SYSTEM_CHARLS
+  GDCM_USE_JPEGTURBO
   )
 option(GDCM_USE_SYSTEM_POPPLER "Use system poppler (pdf)" OFF)
 if(GDCM_USE_SYSTEM_POPPLER)
@@ -360,7 +363,41 @@ if(GDCM_USE_SYSTEM_LIBXML2)
 endif()
 mark_as_advanced(GDCM_USE_SYSTEM_LIBXML2)
 
-if(GDCM_USE_SYSTEM_LJPEG)
+if(GDCM_USE_JPEGTURBO)
+  # libjpeg-turbo >= 3.0 is required for lossless JPEG and 12/16-bit support
+  set(_gdcm_jpegturbo_min_version "3.0")
+  find_package(libjpeg-turbo ${_gdcm_jpegturbo_min_version} QUIET)
+  if(libjpeg-turbo_FOUND)
+    set(GDCM_JPEGTURBO_INCLUDE_DIRS ${libjpeg-turbo_INCLUDE_DIRS})
+    set(GDCM_JPEGTURBO_LIBRARIES ${libjpeg-turbo_LIBRARIES})
+    # Modern config uses imported targets for libraries
+    if(NOT GDCM_JPEGTURBO_LIBRARIES AND TARGET libjpeg-turbo::jpeg)
+      set(GDCM_JPEGTURBO_LIBRARIES libjpeg-turbo::jpeg)
+    endif()
+  else()
+    # Fall back to CMake's FindJPEG which works with system libjpeg-turbo
+    find_package(JPEG REQUIRED)
+    include(CheckSymbolExists)
+    set(CMAKE_REQUIRED_INCLUDES ${JPEG_INCLUDE_DIRS})
+    check_symbol_exists(LIBJPEG_TURBO_VERSION "jconfig.h" JPEG_IS_TURBO)
+    if(NOT JPEG_IS_TURBO)
+      message(FATAL_ERROR "GDCM_USE_JPEGTURBO requires libjpeg-turbo, but found plain libjpeg")
+    endif()
+    # Verify version >= 3.0 by checking for jpeg_enable_lossless (added in 3.0)
+    include(CheckSymbolExists)
+    set(CMAKE_REQUIRED_INCLUDES ${JPEG_INCLUDE_DIRS})
+    set(CMAKE_REQUIRED_LIBRARIES ${JPEG_LIBRARIES})
+    check_symbol_exists(jpeg12_read_scanlines "jpeglib.h" JPEG_HAS_12BIT_API)
+    if(NOT JPEG_HAS_12BIT_API)
+      message(FATAL_ERROR
+        "GDCM_USE_JPEGTURBO requires libjpeg-turbo >= ${_gdcm_jpegturbo_min_version} "
+        "(for lossless JPEG and 12/16-bit support), but the installed version is too old.")
+    endif()
+    set(GDCM_JPEGTURBO_INCLUDE_DIRS ${JPEG_INCLUDE_DIRS})
+    set(GDCM_JPEGTURBO_LIBRARIES JPEG::JPEG)
+  endif()
+  set(GDCM_LJPEG_LIBRARIES "")
+elseif(GDCM_USE_SYSTEM_LJPEG)
   find_package(LJPEG REQUIRED)
   set(GDCM_LJPEG_LIBRARIES ${LJPEG_LIBRARIES})
 else()
@@ -375,6 +412,9 @@ else()
   set(GDCM_CHARLS_LIBRARIES gdcmcharls)
 endif()
 
+option(GDCM_USE_SYSTEM_OPENJPEG "Use system openjpeg" OFF)
+option(GDCM_USE_SYSTEM_CHARLS "Use system charls" OFF)
+
 if(GDCM_USE_SYSTEM_OPENJPEG)
   find_package(OpenJPEG 2.0.0 REQUIRED)
   set(GDCM_OPENJPEG_LIBRARIES ${OPENJPEG_LIBRARIES})
@@ -814,9 +854,11 @@ include(CMake/InstallRequiredVTKLibraries.cmake)
 endif()
 endif()
 
-# Make sure to run doxygen after everything else (in particular vtkgdcm):
-if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/doxygen)
-  add_subdirectory(Utilities/doxygen)
+if(GDCM_DOCUMENTATION)
+  # Make sure to run doxygen after everything else (in particular vtkgdcm):
+  if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/Utilities/doxygen)
+    add_subdirectory(Utilities/doxygen)
+  endif()
 endif()
 
 #-----------------------------------------------------------------------------

Source/DataDictionary/gdcmPrivateDefaultDicts.cxx

@@ -38,6 +38,104 @@ using DICT_ENTRY = struct
 };
 
 static const DICT_ENTRY DICOMV3DataDict [] = {
+  // Major MRI vendors typically use identifiable creator names for a good reason...
+  // BEGIN UIH
+  // See https://github.com/rordenlab/dcm2niix/issues/225
+  {0x0019,0x0018,"EPI Private Header",VR::IS,VM::VM1,"?",false },
+  {0x0019,0x0028,"EPI Private Header",VR::FD,VM::VM1,"?",false },
+  {0x0051,0x0011,"EPI Private Header",VR::LO,VM::VM1,"?",false },
+  {0x0061,0x0002,"DB Dicom Private Creator",VR::US,VM::VM1,"Generate Private",false },
+  {0x0061,0x0004,"EditStatus",VR::US,VM::VM1,"?",false },
+  {0x0061,0x0001,"Common Private Header",VR::SH,VM::VM1,"?",false },
+  {0x0061,0x0002,"Common Private Header",VR::SH,VM::VM1,"FOV",false },
+  {0x0061,0x0003,"Common Private Header",VR::SH,VM::VM1,"?",false },
+  {0x0061,0x0006,"PrivateCreator16",VR::ST,VM::VM1,"Radiopharmaceutical Information JSON",false },
+  {0x0065,0x0000,"Image Private Header",VR::UL,VM::VM1,"MeasurmentUID",false },
+  {0x0065,0x0002,"Image Private Header",VR::LO,VM::VM1,"ImageOrientationDisplayed",false },
+  {0x0065,0x0003,"Image Private Header",VR::LO,VM::VM1,"ReceiveCoil",false },
+  {0x0065,0x0004,"Image Private Header",VR::SH,VM::VM1,"Interpolation",false },
+  {0x0065,0x0005,"Image Private Header",VR::SH,VM::VM1,"PE Direction Displayed",false },
+  {0x0065,0x0006,"Image Private Header",VR::IS,VM::VM1,"Slice Group ID",false },
+  {0x0065,0x0007,"Image Private Header",VR::OB,VM::VM1,"Uprotocol",false },
+  {0x0065,0x0009,"Image Private Header",VR::FD,VM::VM1,"BActualValue",false },
+  {0x0065,0x000a,"Image Private Header",VR::FD,VM::VM1,"BUserValue",false },
+  {0x0065,0x000d,"Image Private Header",VR::SH,VM::VM1,"Parallel Information",false },
+  {0x0065,0x000f,"Image Private Header",VR::SH,VM::VM1,"Slice Position",false },
+  {0x0065,0x0011,"Image Private Header",VR::SH,VM::VM1,"Sections",false },
+  {0x0065,0x0012,"Image Private Header",VR::LO,VM::VM1,"?",false },
+  {0x0065,0x0013,"Image Private Header",VR::FD,VM::VM1,"InPlaneRotAngle",false },
+  {0x0065,0x0014,"Image Private Header",VR::DS,VM::VM3,"SliceNormalVector",false },
+  {0x0065,0x0015,"Image Private Header",VR::DS,VM::VM3,"SliceCenterPosition",false },
+  {0x0065,0x0016,"Image Private Header",VR::UL,VM::VM1,"PixelRotateModel",false },
+  {0x0065,0x0017,"Image Private Header",VR::LO,VM::VM1,"SAR Model",false },
+  {0x0065,0x0018,"Image Private Header",VR::LO,VM::VM1,"dB/dt Model",false },
+  {0x0065,0x0021,"Image Private Header",VR::SH,VM::VM1,"?",false },
+  {0x0065,0x0023,"Image Private Header",VR::LO,VM::VM1,"TablePosition",false },
+  {0x0065,0x0025,"Image Private Header",VR::DS,VM::VM1,"Slice Gap",false },
+  {0x0065,0x0029,"Image Private Header",VR::SH,VM::VM1,"AcquisitionDuration",false },
+  {0x0065,0x002b,"Image Private Header",VR::LT,VM::VM1,"ApplicationCategory",false },
+  {0x0065,0x002c,"Image Private Header",VR::IS,VM::VM1,"RepeatitionIndex",false },
+  {0x0065,0x002d,"Image Private Header",VR::ST,VM::VM1,"SequenceDisplayName",false },
+  {0x0065,0x002e,"Image Private Header",VR::LO,VM::VM1,"NoiseDecovarFlag",false },
+  {0x0065,0x002f,"Image Private Header",VR::FL,VM::VM1,"ScaleFactor",false },
+  {0x0065,0x0030,"Image Private Header",VR::LO,VM::VM1,"?Customer?",false },
+  {0x0065,0x0031,"Image Private Header",VR::SH,VM::VM1,"MRSequenceVariant",false },
+  {0x0065,0x0032,"Image Private Header",VR::SH,VM::VM1,"MRKSpaceFilter",false },
+  {0x0065,0x0033,"Image Private Header",VR::SH,VM::VM1,"MRTableMode",false },
+  {0x0065,0x0036,"Image Private Header",VR::OB,VM::VM1,"MRDiscoParameter",false },
+  {0x0065,0x0037,"Image Private Header",VR::FD,VM::VM3,"MRDiffusionGradOrientation",false },
+  {0x0065,0x0038,"Image Private Header",VR::FD,VM::VM1,"MRPerfusionNoiseLevel",false },
+  {0x0065,0x0039,"Image Private Header",VR::SH,VM::VM6,"MRGradRange",false },
+  {0x0065,0x0040,"Image Private Header",VR::LO,VM::VM1,"?",false },
+  {0x0065,0x0041,"Image Private Header",VR::LT,VM::VM1,"?NIN?",false },
+  {0x0065,0x0048,"Image Private Header",VR::OB,VM::VM1,"?",false },
+  {0x0065,0x0049,"Image Private Header",VR::DS,VM::VM3,"?",false },
+  {0x0065,0x0050,"Image Private Header",VR::DS,VM::VM1,"MR Number Of Slice In Volume",false },
+  {0x0065,0x0051,"Image Private Header",VR::SQ,VM::VM1,"MR VFrame Sequence",false },
+  {0x0065,0x0052,"Image Private Header",VR::LO,VM::VM1_n,"?",false },
+  {0x0065,0x0053,"Image Private Header",VR::DS,VM::VM3,"?",false },
+  {0x0065,0x0055,"Image Private Header",VR::DS,VM::VM1,"?",false },
+  {0x0065,0x0058,"Image Private Header",VR::IS,VM::VM1,"?",false },
+  {0x0065,0x0059,"Image Private Header",VR::LO,VM::VM1,"?",false },
+  {0x0065,0x0060,"Image Private Header",VR::LO,VM::VM1,"?",false },
+  {0x0065,0x006a,"Image Private Header",VR::LO,VM::VM1,"?",false },
+  {0x0065,0x006c,"Image Private Header",VR::OB,VM::VM1,"UIH serialized protocol",false },
+  {0x0065,0x0071,"Image Private Header",VR::US,VM::VM1,"?",false },
+  {0x0065,0x0073,"Image Private Header",VR::OB,VM::VM1,"?",false },
+  {0x0065,0x0076,"Image Private Header",VR::SH,VM::VM1,"?",false },
+  {0x0065,0x0077,"Image Private Header",VR::LO,VM::VM1,"?",false },
+  {0x0065,0x0078,"Image Private Header",VR::LO,VM::VM1,"?",false },
+  {0x0067,0x0004,"PrivateCreator10",VR::FD,VM::VM1,"?",false },
+  {0x0067,0x0005,"PrivateCreator10",VR::FD,VM::VM2,"?",false },
+  {0x0067,0x0007,"PrivateCreator10",VR::CS,VM::VM3,"?",false },
+  {0x0067,0x0008,"PrivateCreator10",VR::LO,VM::VM1,"?",false },
+  {0x0067,0x0009,"PrivateCreator10",VR::IS,VM::VM1,"?",false },
+  {0x0067,0x000a,"PrivateCreator10",VR::IS,VM::VM1,"?",false },
+  {0x0067,0x000b,"PrivateCreator10",VR::IS,VM::VM1,"?",false },
+  {0x0067,0x000d,"PrivateCreator10",VR::SH,VM::VM1,"?",false },
+  {0x0067,0x0010,"PrivateCreator10",VR::DT,VM::VM1,"?",false },
+  {0x0067,0x0012,"PrivateCreator10",VR::DT,VM::VM1,"?",false },
+  {0x0067,0x0014,"PrivateCreator10",VR::CS,VM::VM1,"?",false },
+  {0x0067,0x0015,"PrivateCreator10",VR::CS,VM::VM1,"?",false },
+  {0x0067,0x0017,"PrivateCreator10",VR::CS,VM::VM1,"?",false },
+  {0x0067,0x0019,"PrivateCreator10",VR::CS,VM::VM1,"?",false },
+  {0x0067,0x001a,"PrivateCreator10",VR::CS,VM::VM1,"?",false },
+  {0x0067,0x001b,"PrivateCreator10",VR::CS,VM::VM1,"?",false },
+  {0x0067,0x001c,"PrivateCreator10",VR::CS,VM::VM1,"?",false },
+  {0x0067,0x001d,"PrivateCreator10",VR::IS,VM::VM1,"?",false },
+  {0x0067,0x0020,"PrivateCreator10",VR::UT,VM::VM1,"?",false },
+  {0x0067,0x0021,"PrivateCreator10",VR::SQ,VM::VM1,"?",false },
+  {0x0067,0x002c,"PrivateCreator10",VR::ST,VM::VM1,"?",false },
+  {0x0067,0x002f,"PrivateCreator10",VR::DS,VM::VM1,"?",false },
+  {0x0067,0x0031,"PrivateCreator10",VR::UT,VM::VM1,"?",false },
+  {0x0067,0x0001,"PrivateCreator11",VR::TM,VM::VM1,"?",false },
+  {0x0067,0x0002,"PrivateCreator11",VR::DA,VM::VM1,"?",false },
+  {0x0067,0x0003,"PrivateCreator11",VR::DS,VM::VM1,"?",false },
+  {0x0067,0x0004,"PrivateCreator11",VR::TM,VM::VM1,"?",false },
+  {0x0067,0x0005,"PrivateCreator11",VR::DA,VM::VM1,"?",false },
+  {0x0067,0x0006,"PrivateCreator11",VR::DS,VM::VM1,"?",false },
+  {0x0067,0x0007,"PrivateCreator11",VR::LO,VM::VM1,"?",false },
+  // END UIH
   {0x0033,0x0001,"KONICA MINOLTA QA 1.4",VR::SQ,VM::VM1,"?Possibly PHI?",false },
   {0x0033,0x0004,"KONICA MINOLTA QA 1.4",VR::SS,VM::VM1,"?",false },
   {0x0033,0x0006,"KONICA MINOLTA QA 1.4",VR::SS,VM::VM1,"?",false },
@@ -1296,7 +1394,7 @@ static const DICT_ENTRY DICOMV3DataDict [] = {
   {0x0021,0x008e,"SIEMENS MR SDI 02",VR::ST,VM::VM1,"?",false},
   {0x0021,0x00fe,"SIEMENS MR SDI 02",VR::SQ,VM::VM1,"??",false},
   {0x0021,0x00fe,"SIEMENS MR SDS 01",VR::SQ,VM::VM1,"Series Data Sequence",false},
-  {0x0089,0x0054,"SYNGO_IMAGING",VR::OW,VM::VM1,"??",false},
+  {0x0089,0x0054,"SYNGO_IMAGING",VR::OB,VM::VM1,"??",false},
   {0x0095,0x00fa,"SIENET",VR::PN,VM::VM1,"?Some kind of Patient Name?",false},
   {0x8ff1,0x0010,"SSI Image enhancement Group",VR::LO,VM::VM1,"SSI Image enhancement Group Version",false },
   {0x8ff1,0x0020,"SSI Image enhancement Group",VR::IS,VM::VM256,"RGB LUT",false },

Source/InformationObjectDefinition/CMakeLists.txt

@@ -37,11 +37,10 @@ include_directories(
   "${GDCM_SOURCE_DIR}/Source/DataStructureAndEncodingDefinition"
   "${GDCM_SOURCE_DIR}/Source/DataDictionary"
   "${GDCM_SOURCE_DIR}/Utilities"
-  "${GDCM_BINARY_DIR}/Utilities/gdcmexpat" # expat_mangle.h
   )
-if(GDCM_USE_SYSTEM_EXPAT)
+if(NOT GDCM_USE_SYSTEM_EXPAT) # only needed _without_ find_package
   include_directories(
-    ${EXPAT_INCLUDE_DIRS}
+    "${GDCM_BINARY_DIR}/Utilities/gdcmexpat" # expat_mangle.h
   )
 endif()
 

Source/MediaStorageAndFileFormat/CMakeLists.txt

@@ -42,6 +42,7 @@ set(MSFF_SRCS
   gdcmDICOMDIR.cxx
   gdcmSpectroscopy.cxx
   gdcmEncapsulatedDocument.cxx
+  gdcmSplitGridFilter.cxx
   gdcmSplitMosaicFilter.cxx
   gdcmFiducials.cxx
   gdcmWaveform.cxx
@@ -67,13 +68,10 @@ set(MSFF_SRCS
   gdcmImage.cxx
   gdcmImageConverter.cxx
   gdcmImageCodec.cxx
-  gdcmJPEG12Codec.cxx
   gdcmRLECodec.cxx
   gdcmPDFCodec.cxx
   gdcmAudioCodec.cxx
-  gdcmJPEG16Codec.cxx
   gdcmJPEGLSCodec.cxx
-  gdcmJPEG8Codec.cxx
   gdcmJPEGCodec.cxx
   gdcmPVRGCodec.cxx
   gdcmKAKADUCodec.cxx
@@ -102,6 +100,19 @@ set(MSFF_SRCS
   gdcmJPEG2000Codec.cxx
   )
 
+# Per-bitdepth IJG codecs or single libjpeg-turbo codec
+if(GDCM_USE_JPEGTURBO)
+  list(APPEND MSFF_SRCS
+    gdcmJPEGTurboCodec.cxx
+  )
+else()
+  list(APPEND MSFF_SRCS
+    gdcmJPEG8Codec.cxx
+    gdcmJPEG12Codec.cxx
+    gdcmJPEG16Codec.cxx
+  )
+endif()
+
   list(APPEND MSFF_SRCS
     ${GDCM_SOURCE_DIR}/Utilities/gdcmrle/rle.cxx
     ${GDCM_SOURCE_DIR}/Utilities/gdcmrle/info.cxx
@@ -178,6 +189,10 @@ endif()
 if(GDCM_USE_SYSTEM_LJPEG)
   include_directories(${LJPEG_INCLUDE_DIRS} )
 endif()
+if(GDCM_USE_JPEGTURBO)
+  include_directories(${GDCM_JPEGTURBO_INCLUDE_DIRS})
+  add_definitions(-DGDCM_USE_JPEGTURBO)
+endif()
 if(NOT GDCM_USE_SYSTEM_ZLIB)
   include_directories(
     "${GDCM_BINARY_DIR}/Utilities/gdcmzlib"
@@ -211,6 +226,9 @@ endif()
 # main libs:
 target_link_libraries(gdcmMSFF LINK_PUBLIC gdcmIOD gdcmDSED gdcmDICT)
 target_link_libraries(gdcmMSFF LINK_PRIVATE ${GDCM_LJPEG_LIBRARIES} ${GDCM_OPENJPEG_LIBRARIES})
+if(GDCM_USE_JPEGTURBO)
+  target_link_libraries(gdcmMSFF LINK_PRIVATE ${GDCM_JPEGTURBO_LIBRARIES})
+endif()
 if(GDCM_USE_JPEGLS)
   target_link_libraries(gdcmMSFF LINK_PRIVATE ${GDCM_CHARLS_LIBRARIES})
 endif()

Source/MediaStorageAndFileFormat/gdcmBitmap.cxx

@@ -888,13 +888,13 @@ bool Bitmap::TryJPEG2000Codec(char *buffer, bool &lossyflag) const
     DataElement out;
     bool r = codec.Decode(PixelData, out);
     if(!r) return false;
-    gdcm_assert( r );
     const ByteValue *outbv = out.GetByteValue();
-    gdcm_assert( outbv );
-    unsigned long check = outbv->GetLength();  // FIXME
-    (void)check;
-    gdcm_assert( len <= outbv->GetLength() );
-    memcpy(buffer, outbv->GetPointer(), len /*outbv->GetLength()*/ );  // FIXME
+    // A missing or short decoded buffer is a runtime condition (e.g. an
+    // allocation failed while decoding), not a logic invariant: fail gracefully
+    // rather than throwing out of GetBuffer, which is uncatchable across the
+    // SWIG language bindings and aborts the host process.
+    if( !outbv || outbv->GetLength() < len ) return false;
+    memcpy(buffer, outbv->GetPointer(), len);
 
     lossyflag = codec.IsLossy();
     if( codec.IsLossy() && !ts.IsLossy() )

Source/MediaStorageAndFileFormat/gdcmDirectionCosines.cxx

@@ -103,6 +103,14 @@ static inline double NormImpl(const double x[3])
   return sqrt(x[0]*x[0] + x[1]*x[1] + x[2]*x[2]);
 }
 
+double DirectionCosines::Distance(const double x[3], const double y[3])
+{
+    const double dx = x[0] - y[0];
+    const double dy = x[1] - y[1];
+    const double dz = x[2] - y[2];
+    return std::sqrt(dx * dx + dy * dy + dz * dz);
+}
+
 double DirectionCosines::Norm(const double v[3])
 {
   return NormImpl(v);

Source/MediaStorageAndFileFormat/gdcmDirectionCosines.h

@@ -43,6 +43,9 @@ class GDCM_EXPORT DirectionCosines
   /// Compute Dot
   static double Dot(const double x[3], const double y[3]);
 
+  /// Compute Distance
+  static double Distance(const double x[3], const double y[3]);
+
   /// Normalize in-place
   void Normalize();