dicube 0.1.4__cp312-cp312-macosx_11_0_arm64.whl → 0.2.0__cp312-cp312-macosx_11_0_arm64.whl

dicube/dicom/dcb_streaming.py

@@ -19,13 +19,13 @@ import pydicom
 from ..storage.dcb_file import DcbFile
 from .dicom_io import save_dicom
 
-# 定义所需的最低PyDicom版本
+# Required minimum PyDicom version
 REQUIRED_PYDICOM_VERSION = "3.0.0"
 
 class DcbStreamingReader:
-    """
-    PACS Viewer 的 dcb 文件流式读取器
-    保持文件打开状态，支持快速随机访问帧数据
+    """DCB file streaming reader for PACS Viewer.
+    
+    Keeps files open and supports fast random access to frame data.
     
     Example:
         reader = DcbStreamingReader('study.dcbs')
@@ -34,52 +34,51 @@ class DcbStreamingReader:
     """
     
     def __init__(self, dcb_file_path: str):
-        """
-        初始化并预解析所有元数据
+        """Initialize and preparse all metadata.
         
         Args:
-            dcb_file_path: dcb 文件路径
+            dcb_file_path: Path to DCB file
             
         Warnings:
-            UserWarning: 如果 PyDicom 版本低于 3.0.0，HTJ2K 解码可能无法正常工作
+            UserWarning: If PyDicom version is below 3.0.0, HTJ2K decoding may not work properly
         """
-        # 检查 PyDicom 版本
+        # Check PyDicom version
         self._check_pydicom_version()
         
         self.file_path = dcb_file_path
         self.file_handle = None
         self.transfer_syntax_uid = None
         
-        # 预解析的数据
+        # Pre-parsed data
         self.header = None
         self.dicom_meta = None
         self.pixel_header = None
         self.space = None
         
-        # 帧索引信息
+        # Frame index information
         self.frame_offsets = []
         self.frame_lengths = []
         self.frame_count = 0
         
-        # DcbFile 实例（用于读取元数据）
+        # DcbFile instance (for reading metadata)
         self.dcb_file = None
         
-        # 初始化
+        # Initialize
         self._open_and_parse()
     
     def _check_pydicom_version(self):
-        """
-        检查 PyDicom 版本，如果不满足要求则发出警告
+        """Check PyDicom version and warn if requirements not met.
         
         Warnings:
-            UserWarning: 如果 PyDicom 版本低于 3.0.0
+            UserWarning: If PyDicom version is below 3.0.0
         """
         current_version = pydicom.__version__
         if current_version < REQUIRED_PYDICOM_VERSION:
             warnings.warn(
-                f"DcbStreamingReader 需要 PyDicom >= {REQUIRED_PYDICOM_VERSION} 以完全支持 HTJ2K 传输语法。"
-                f"当前 PyDicom 版本为 {current_version}，可能无法读取像素数据。"
-                f"写入功能不受影响，但其他应用读取时可能会出现问题。建议升级: pip install pydicom>={REQUIRED_PYDICOM_VERSION}，需要 python 3.10 或更高版本",
+                f"DcbStreamingReader requires PyDicom >= {REQUIRED_PYDICOM_VERSION} for full HTJ2K transfer syntax support. "
+                f"Current PyDicom version is {current_version}, which may not be able to read pixel data. "
+                f"Write functionality is not affected, but other applications may have issues reading. "
+                f"Recommended upgrade: pip install pydicom>={REQUIRED_PYDICOM_VERSION}, requires python 3.10 or higher",
                 UserWarning
             )
             self._has_pydicom_htj2k_support = False
@@ -87,30 +86,30 @@ class DcbStreamingReader:
             self._has_pydicom_htj2k_support = True
 
     def _open_and_parse(self):
-        """打开文件并解析所有元数据"""
+        """Open file and parse all metadata."""
         try:
-            # 1. 创建 DcbFile 实例（会自动检测文件类型）
+            # 1. Create DcbFile instance (will auto-detect file type)
             self.dcb_file = DcbFile(self.file_path, mode='r')
             
-            # 2. 读取并缓存头部信息
+            # 2. Read and cache header information
             self.header = self.dcb_file.header
             self.frame_count = self.header['frame_count']
             
-            # 3. 读取并缓存元数据
+            # 3. Read and cache metadata
             self.dicom_meta = self.dcb_file.read_meta()
             self.pixel_header = self.dcb_file.read_pixel_header()
             self.space = self.dcb_file.read_space()
             
-            # 4. 获取 transfer syntax UID（从文件类型直接获取）
+            # 4. Get transfer syntax UID (directly from file type)
             self.transfer_syntax_uid = self.dcb_file.get_transfer_syntax_uid()
             if not self.transfer_syntax_uid:
-                # 如果文件类型没有定义 transfer syntax，使用默认的未压缩格式
+                # If file type doesn't define transfer syntax, use default uncompressed format
                 self.transfer_syntax_uid = '1.2.840.10008.1.2.1'  # Explicit VR Little Endian
             
-            # 5. 打开文件句柄用于读取帧数据
+            # 5. Open file handle for reading frame data
             self.file_handle = open(self.file_path, 'rb')
             
-            # 6. 读取所有帧的 offset 和 length
+            # 6. Read all frame offsets and lengths
             self._read_frame_indices()
             
         except Exception as e:
@@ -118,15 +117,15 @@ class DcbStreamingReader:
             raise RuntimeError(f"Failed to open and parse DCB file: {e}")
     
     def _read_frame_indices(self):
-        """读取所有帧的偏移量和长度信息"""
+        """Read all frame offset and length information."""
         self.file_handle.seek(self.header['frame_offsets_offset'])
         
-        # 读取 offsets
+        # Read offsets
         for _ in range(self.frame_count):
             offset, = struct.unpack('<Q', self.file_handle.read(8))
             self.frame_offsets.append(offset)
         
-        # 读取 lengths
+        # Read lengths
         self.file_handle.seek(self.header['frame_lengths_offset'])
         for _ in range(self.frame_count):
             length, = struct.unpack('<Q', self.file_handle.read(8))
@@ -134,37 +133,37 @@ class DcbStreamingReader:
     
     def get_dicom_for_frame(self, frame_index: int) -> bytes:
         """
-        获取指定帧的 DICOM 数据
+        Get DICOM data for the specified frame.
         
         Args:
-            frame_index: 帧索引（0-based）
+            frame_index: Frame index (0-based)
             
         Returns:
-            bytes: 完整的 DICOM 文件数据
+            bytes: Complete DICOM file data
             
         Raises:
-            IndexError: 如果 frame_index 超出范围
-            RuntimeError: 如果读取失败
+            IndexError: If frame_index is out of range
+            RuntimeError: If reading fails
         """
-        # 验证索引
+        # Validate index
         if not 0 <= frame_index < self.frame_count:
             raise IndexError(f"Frame index {frame_index} out of range [0, {self.frame_count})")
         
         try:
-            # 1. 读取该帧的编码数据
+            # 1. Read encoded data for the frame
             encoded_pixel_data = self._read_encoded_frame(frame_index)
             
-            # 2. 生成该帧的 DICOM Dataset
+            # 2. Generate DICOM Dataset for the frame
             ds = self._create_dicom_dataset(frame_index, encoded_pixel_data)
             
-            # 3. 序列化为 DICOM 文件格式
+            # 3. Serialize to DICOM file format
             return self._serialize_to_dicom_bytes(ds)
             
         except Exception as e:
             raise RuntimeError(f"Failed to create DICOM for frame {frame_index}: {e}")
     
     def _read_encoded_frame(self, frame_index: int) -> bytes:
-        """直接读取指定帧的编码数据"""
+        """Read encoded data for the specified frame directly."""
         offset = self.frame_offsets[frame_index]
         length = self.frame_lengths[frame_index]
         
@@ -172,17 +171,17 @@ class DcbStreamingReader:
         return self.file_handle.read(length)
     
     def _create_dicom_dataset(self, frame_index: int, encoded_data: bytes) -> Dataset:
-        """快速创建 DICOM Dataset"""
-        # 1. 从缓存的 DicomMeta 获取该帧的元数据
+        """Quickly create DICOM Dataset."""
+        # 1. Get metadata for the frame from cached DicomMeta
         if self.dicom_meta:
             frame_meta_dict = self.dicom_meta.index(frame_index)
         else:
             frame_meta_dict = {}
         
-        # 2. 创建 Dataset
+        # 2. Create Dataset
         ds = Dataset.from_json(frame_meta_dict)
         
-        # 3. 创建并设置文件元信息
+        # 3. Create and set file metadata
         file_meta = FileMetaDataset()
         file_meta.MediaStorageSOPClassUID = ds.get('SOPClassUID', '1.2.840.10008.5.1.4.1.1.2')
         file_meta.MediaStorageSOPInstanceUID = ds.get('SOPInstanceUID', generate_uid())
@@ -191,37 +190,36 @@ class DcbStreamingReader:
         
         ds.file_meta = file_meta
         
-        # 4. 确保必要的 SOP 信息
+        # 4. Ensure necessary SOP information
         if not hasattr(ds, 'SOPClassUID'):
             ds.SOPClassUID = file_meta.MediaStorageSOPClassUID
         if not hasattr(ds, 'SOPInstanceUID'):
             ds.SOPInstanceUID = file_meta.MediaStorageSOPInstanceUID
         
-        # 5. 设置像素相关属性
+        # 5. Set pixel-related attributes
         if self.pixel_header:
-            ds.RescaleSlope = self.pixel_header.RESCALE_SLOPE
-            ds.RescaleIntercept = self.pixel_header.RESCALE_INTERCEPT
+            ds.RescaleSlope = self.pixel_header.RescaleSlope
+            ds.RescaleIntercept = self.pixel_header.RescaleIntercept
         
-        # 6. 设置像素数据（使用 encapsulated format for compressed data）
-        # 压缩数据需要封装
+        # 6. Set pixel data (using encapsulated format for compressed data)
         ds.PixelData = encapsulate([encoded_data])
         
         return ds
     
     def _serialize_to_dicom_bytes(self, ds: Dataset) -> bytes:
-        """将 Dataset 序列化为 DICOM 文件字节流"""
-        # 使用 BytesIO 在内存中创建 DICOM 文件
+        """Serialize Dataset to DICOM file byte stream."""
+        # Use BytesIO to create DICOM file in memory
         buffer = io.BytesIO()
         save_dicom(ds, buffer)
         buffer.seek(0)
         return buffer.read()
     
     def get_frame_count(self) -> int:
-        """获取总帧数"""
+        """Get total number of frames."""
         return self.frame_count
     
     def get_metadata(self) -> Dict[str, Any]:
-        """获取缓存的元数据信息"""
+        """Get cached metadata information."""
         return {
             'frame_count': self.frame_count,
             'pixel_header': self.pixel_header.to_dict() if self.pixel_header else {},
@@ -232,19 +230,19 @@ class DcbStreamingReader:
         }
     
     def close(self):
-        """关闭文件句柄"""
+        """Close file handle."""
         if self.file_handle:
             self.file_handle.close()
             self.file_handle = None
     
     def __enter__(self):
-        """支持 with 语句"""
+        """Support with statement."""
         return self
     
     def __exit__(self, exc_type, exc_val, exc_tb):
-        """退出 with 语句时自动关闭"""
+        """Automatically close when exiting with statement."""
         self.close()
     
     def __del__(self):
-        """析构时确保文件关闭"""
+        """Ensure file is closed on destruction."""
         self.close() 

dicube/dicom/dicom_io.py

@@ -86,34 +86,34 @@ def create_dicom_dataset(meta_dict: dict, pixel_header):
 
     ds.file_meta = create_file_meta(ds)
     ensure_required_tags(ds)
-    ds.RescaleSlope = pixel_header.RESCALE_SLOPE
-    ds.RescaleIntercept = pixel_header.RESCALE_INTERCEPT
+    ds.RescaleSlope = pixel_header.RescaleSlope
+    ds.RescaleIntercept = pixel_header.RescaleIntercept
 
     return ds
 
 
 def save_dicom(ds: Dataset, output_path: str):
-    """保存DICOM文件
+    """Save DICOM file.
     
-    参数:
-        ds: DICOM数据集
-        output_path: 输出文件路径
+    Args:
+        ds: DICOM dataset
+        output_path: Output file path
     """
     
     sig = inspect.signature(Dataset.save_as)
     if "enforce_file_format" in sig.parameters:  # pydicom >= 3.0
         ds.save_as(output_path, enforce_file_format=True)
     else:
-        # 确保使用有效的传输语法UID
+        # Ensure valid transfer syntax UID
         if hasattr(ds, 'file_meta') and hasattr(ds.file_meta, 'TransferSyntaxUID'):
-            # 检查是否有效，如果无效则替换为标准的ExplicitVRLittleEndian
+            # Check if valid, replace with standard ExplicitVRLittleEndian if invalid
             try:
                 from pydicom.uid import UID
                 uid = UID(ds.file_meta.TransferSyntaxUID)
                 if not hasattr(uid, 'is_little_endian'):
                     ds.file_meta.TransferSyntaxUID = ExplicitVRLittleEndian
             except (ValueError, AttributeError):
-                # 如果UID无效，使用标准的ExplicitVRLittleEndian
+                # If UID is invalid, use standard ExplicitVRLittleEndian
                 ds.file_meta.TransferSyntaxUID = ExplicitVRLittleEndian
         ds.save_as(output_path, write_like_original=False)
 
@@ -124,14 +124,14 @@ def save_to_dicom_folder(
     output_dir: str,
     filenames: Optional[List[str]] = None,
 ):
-    """将图像数据保存为DICOM文件夹
+    """Save image data as DICOM folder.
     
-    参数:
-        raw_images: 原始图像数据，可以是2D或3D数组
-        dicom_meta: DICOM元数据
-        pixel_header: 像素头信息
-        output_dir: 输出目录
-        filenames: 自定义文件名列表，如果为None则使用默认名称
+    Args:
+        raw_images: Raw image data, can be 2D or 3D array
+        dicom_meta: DICOM metadata
+        pixel_header: Pixel header information
+        output_dir: Output directory
+        filenames: Custom filename list, if None default names will be used
     """
     prepare_output_dir(output_dir)
 

dicube/storage/dcb_file.py

@@ -86,12 +86,14 @@ class DcbFile:
         MAGIC (bytes): Magic bytes for file identification.
         VERSION (int): File format version.
         TRANSFER_SYNTAX_UID (str, optional): DICOM transfer syntax UID.
+        FILE_EXTENSION (str): File extension for this format.
     """
 
     HEADER_STRUCT = "<8sI13Q"
     MAGIC = b"DCMCUBE\x00"
     VERSION = 1
     TRANSFER_SYNTAX_UID = None  # Base class has no specific transfer syntax
+    FILE_EXTENSION = ".dcb"  # Default extension
 
     def __init__(self, filename: str, mode: str = "r"):
         """Initialize a DCB file object.
@@ -112,6 +114,10 @@ class DcbFile:
                 suggestion="Use 'r' for reading, 'w' for writing, or 'a' for appending"
             )
         
+        # For write mode, ensure filename has correct extension
+        if mode == "w":
+            filename = self._ensure_correct_extension(filename)
+        
         self.filename = filename
         self.mode = mode
         self._header = None  # Delay reading header until needed
@@ -119,6 +125,19 @@ class DcbFile:
         if os.path.exists(filename) and mode in ("r", "a"):
             self._read_header_and_check_type()
 
+    def _ensure_correct_extension(self, filename: str) -> str:
+        """Ensure the filename has the correct extension for this file type.
+        
+        Args:
+            filename (str): The original filename.
+            
+        Returns:
+            str: The filename with correct extension.
+        """
+        if not filename.endswith(self.FILE_EXTENSION):
+            return filename + self.FILE_EXTENSION
+        return filename
+
     def _read_header_and_check_type(self):
         """Read file header and determine the correct subclass."""
         try:
@@ -265,12 +284,9 @@ class DcbFile:
             else:
                 dicom_status = DicomStatus.CONSISTENT
 
-        # Handle both enum and string values for dicom_status
-        if isinstance(dicom_status, DicomStatus):
-            dicom_status_bin = dicom_status.value.encode("utf-8")
-        else:
-            # If it's already a string, encode it directly
-            dicom_status_bin = dicom_status.encode("utf-8")
+        # Convert DicomStatus enum to string for storage
+        # If None was provided, dicom_status will be a DicomStatus enum at this point
+        dicom_status_bin = dicom_status.value.encode("utf-8")
 
         # Process dicom_meta
         if dicom_meta:
@@ -297,17 +313,20 @@ class DcbFile:
             'pixel_header_bin': pixel_header_bin
         }
     
-    def _encode_frames(self, images: List, num_threads: int = 4):
+    def _encode_frames(self, images: List):
         """Encode frames using parallel or serial processing.
         
         Args:
             images (List): List of frames to encode.
-            num_threads (int): Number of worker threads for parallel encoding.
             
         Returns:
             List[bytes]: List of encoded frame data.
         """
-        if num_threads is not None and num_threads > 1:
+        # Import get_num_threads function to avoid circular import
+        from .. import get_num_threads
+        num_threads = get_num_threads()
+        
+        if num_threads > 1:
             # Parallel encoding
             with ThreadPoolExecutor(max_workers=num_threads) as executor:
                 encoded_blobs = list(
@@ -408,9 +427,8 @@ class DcbFile:
         images: List,  # Can be List[np.ndarray] or List[Tuple] for ROI data
         pixel_header: PixelDataHeader,
         dicom_meta: Optional[DicomMeta] = None,
+        dicom_status: DicomStatus = DicomStatus.CONSISTENT,
         space: Optional[Space] = None,
-        num_threads: int = 4,
-        dicom_status: Optional[DicomStatus] = None,
     ):
         """Write image data and metadata to a DCB file.
 
@@ -422,9 +440,8 @@ class DcbFile:
                 or List[Tuple[np.ndarray, np.ndarray, np.ndarray]] for ROI files.
             pixel_header (PixelDataHeader): PixelDataHeader instance containing pixel metadata.
             dicom_meta (DicomMeta, optional): DICOM metadata. Defaults to None.
+            dicom_status (DicomStatus): DICOM status enumeration. Defaults to DicomStatus.CONSISTENT.
             space (Space, optional): Spatial information. Defaults to None.
-            num_threads (int): Number of worker threads for parallel encoding. Defaults to 4.
-            dicom_status (str, optional): DICOM status string value. Defaults to None.
         """
         if images is None:
             images = []
@@ -436,7 +453,7 @@ class DcbFile:
         )
         
         # Encode frames
-        encoded_frames = self._encode_frames(images, num_threads)
+        encoded_frames = self._encode_frames(images)
 
         # Write file structure
         header_size = struct.calcsize(self.HEADER_STRUCT)
@@ -560,42 +577,41 @@ class DcbFile:
         pixel_header_json = pixel_header_bin.decode("utf-8")
         return HeaderClass.from_json(pixel_header_json)
 
-    def read_images(self, num_threads: int = 4):
+    def read_images(self):
         """Read all image frames from the file.
-
-        Args:
-            num_threads (int): Number of worker threads for parallel decoding.
-                Defaults to 4.
-
+            
         Returns:
             List[np.ndarray] or np.ndarray: The decoded image frames. If the number of frames is 1,
                 returns a single numpy array, otherwise returns a list of arrays.
         """
+        # Import get_num_threads function to avoid circular import
+        from .. import get_num_threads
+        
         hdr = self.header
         frame_count = hdr["frame_count"]
-
+        
         if frame_count == 0:
             # No frames to read
             pixel_header = self.read_pixel_header()
-            return np.array([], dtype=pixel_header.ORIGINAL_PIXEL_DTYPE)
+            return np.array([], dtype=pixel_header.OriginalPixelDtype)
 
         # Read frame offsets and lengths
         frame_offsets_offset = hdr["frame_offsets_offset"]
         frame_offsets_length = hdr["frame_offsets_length"]
         frame_lengths_offset = hdr["frame_lengths_offset"]
         frame_lengths_length = hdr["frame_lengths_length"]
-
+        
         with open(self.filename, "rb") as f:
             # Read frame offsets
             f.seek(frame_offsets_offset)
             frame_offsets_bin = f.read(frame_offsets_length)
             frame_offsets = struct.unpack(f"<{frame_count}Q", frame_offsets_bin)
-
+            
             # Read frame lengths
             f.seek(frame_lengths_offset)
             frame_lengths_bin = f.read(frame_lengths_length)
             frame_lengths = struct.unpack(f"<{frame_count}Q", frame_lengths_bin)
-
+            
             # Read each frame data
             frame_data_list = []
             for offset, length in zip(frame_offsets, frame_lengths):
@@ -610,8 +626,9 @@ class DcbFile:
 
         # Decode frames (with parallelization if needed)
         frames = []
-
-        if num_threads is not None and num_threads > 1 and frame_count > 1:
+        
+        num_threads = get_num_threads()
+        if num_threads > 1 and frame_count > 1:
             # Parallel decoding
             with ThreadPoolExecutor(max_workers=num_threads) as executor:
                 frames = list(
@@ -633,7 +650,7 @@ class DcbFile:
         if len(frames) == 0:
             # Return empty array if no frames were decoded
             pixel_header = self.read_pixel_header()
-            return np.array([], dtype=pixel_header.ORIGINAL_PIXEL_DTYPE)
+            return np.array([], dtype=pixel_header.OriginalPixelDtype)
         elif len(frames) == 1:
             # Return single frame directly
             return frames[0]
@@ -642,49 +659,45 @@ class DcbFile:
             return frames
 
     def _encode_one_frame(self, frame_data: np.ndarray) -> bytes:
-        """Encode a single frame of image data.
-
-        This is a placeholder method to be implemented by subclasses.
+        """Encode a single frame to bytes.
+        
+        Default implementation returns empty bytes.
+        Subclasses should override this method to implement specific encoding.
 
         Args:
-            frame_data (np.ndarray): The frame data to encode.
-
+            frame_data (np.ndarray): The image frame to encode.
+            
         Returns:
             bytes: The encoded frame data.
-
-        Raises:
-            NotImplementedError: This method must be implemented by subclasses.
         """
-        raise NotImplementedError("Subclass must implement _encode_one_frame")
+        return np.array([], dtype=self.pixel_header.OriginalPixelDtype)
 
     def _decode_one_frame(self, bytes) -> np.ndarray:
-        """Decode a single frame of image data.
-
-        This is a placeholder method to be implemented by subclasses.
+        """Decode a single frame from bytes.
+        
+        Default implementation returns an empty array with the correct data type.
+        Subclasses should override this method to implement specific decoding.
 
         Args:
             bytes (bytes): The encoded frame data.
 
         Returns:
-            np.ndarray: The decoded frame data.
-
-        Raises:
-            NotImplementedError: This method must be implemented by subclasses.
+            np.ndarray: The decoded image frame.
         """
-        raise NotImplementedError("Subclass must implement _decode_one_frame")
+        return np.array([], dtype=self.header_data['pixel_header'].OriginalPixelDtype)
 
-    def read_dicom_status(self) -> str:
+    def read_dicom_status(self) -> DicomStatus:
         """Read DICOM status information from the file.
 
         Returns:
-            str: The DICOM status string, or DicomStatus.CONSISTENT.value if not present.
+            DicomStatus: The DICOM status enum value, or DicomStatus.CONSISTENT if not present.
         """
         hdr = self.header
         dicom_status_offset = hdr["dicom_status_offset"]
         dicom_status_length = hdr["dicom_status_length"]
 
         if dicom_status_length == 0:
-            return DicomStatus.CONSISTENT.value
+            return DicomStatus.CONSISTENT
 
         with open(self.filename, "rb") as f:
             f.seek(dicom_status_offset)
@@ -715,12 +728,14 @@ class DcbSFile(DcbFile):
         VERSION (int): File format version.
         TRANSFER_SYNTAX_UID (str): DICOM transfer syntax UID for HTJ2K Lossless.
         CODEC_NAME (str): Codec name used for compression.
+        FILE_EXTENSION (str): File extension for speed-optimized format.
     """
 
     MAGIC = b"DCMCUBES"
     VERSION = 1
     TRANSFER_SYNTAX_UID = "1.2.840.10008.1.2.4.201"  # HTJ2K Lossless
     CODEC_NAME = "jph"
+    FILE_EXTENSION = ".dcbs"
 
     def _encode_one_frame(self, frame_data: np.ndarray) -> bytes:
         """Encode a single frame using the HTJ2K codec.
@@ -778,12 +793,14 @@ class DcbAFile(DcbFile):
         VERSION (int): File format version.
         TRANSFER_SYNTAX_UID (str, optional): DICOM transfer syntax UID, set when codec is selected.
         CODEC_NAME (str, optional): Codec name, set when codec is selected.
+        FILE_EXTENSION (str): File extension for archive-optimized format.
     """
 
     MAGIC = b"DCMCUBEA"
     VERSION = 1
     TRANSFER_SYNTAX_UID = None  # To be defined when codec is selected
     CODEC_NAME = None  # To be defined when codec is selected
+    FILE_EXTENSION = ".dcba"
 
 
 class DcbLFile(DcbFile):
@@ -797,9 +814,11 @@ class DcbLFile(DcbFile):
         VERSION (int): File format version.
         TRANSFER_SYNTAX_UID (str, optional): DICOM transfer syntax UID, set when codec is selected.
         CODEC_NAME (str, optional): Codec name, set when codec is selected.
+        FILE_EXTENSION (str): File extension for lossy compression format.
     """
 
     MAGIC = b"DCMCUBEL"
     VERSION = 1
     TRANSFER_SYNTAX_UID = None  # To be defined when codec is selected
-    CODEC_NAME = None  # To be defined when codec is selected
+    CODEC_NAME = None  # To be defined when codec is selected
+    FILE_EXTENSION = ".dcbl"