#!/usr/bin/env python3 """ XYZ to RGB Color Space Converter Features: - Convert XYZ color space data to RGB color space - Support multiple RGB working spaces (sRGB, Adobe RGB, DCI-P3, etc.) - Configurable compression/gamma correction methods - Support various output data types (uint8, uint16, float32, etc.) - Input: 3-band .dat file containing XYZ data - Output: 3-band .bip file (Band Interleaved by Pixel format) Dependencies: - numpy, colour-science: color space conversion - spectral: ENVI file processing - tqdm: progress bar (optional) Installation: pip install numpy colour-science spectral tqdm """ import numpy as np import os import sys import warnings import argparse from pathlib import Path from typing import Optional, Tuple, Union, Dict, Any from enum import Enum # Try importing optional dependencies try: import colour from colour import XYZ_to_RGB, RGB_COLOURSPACES COLOUR_AVAILABLE = True except ImportError: COLOUR_AVAILABLE = False print("Warning: colour-science library not available, please install: pip install colour-science") try: import spectral SPECTRAL_AVAILABLE = True except ImportError: SPECTRAL_AVAILABLE = False print("Warning: spectral library not available, will not be able to process ENVI format files") try: from tqdm import tqdm TQDM_AVAILABLE = True except ImportError: TQDM_AVAILABLE = False print("Note: tqdm library not available, progress bar will be disabled. Install: pip install tqdm") try: from osgeo import gdal GDAL_AVAILABLE = True except ImportError: GDAL_AVAILABLE = False print("Note: GDAL library not available, will use spectral as fallback. Install: pip install GDAL") class RGBColorSpace(Enum): """RGB color space enumeration""" SRGB = "sRGB" ADOBE_RGB = "Adobe RGB (1998)" DCI_P3 = "DCI-P3" BT_709 = "ITU-R BT.709" BT_2020 = "ITU-R BT.2020" ACES2065_1 = "ACES2065-1" ACESCG = "ACEScg" PROPHOTO_RGB = "ProPhoto RGB" APPLE_RGB = "Apple RGB" PAL_SECAM = "PAL/SECAM" NTSC = "NTSC (1953)" class GammaMethod(Enum): """Gamma correction method enumeration""" NONE = "none" SRGB = "sRGB" BT_709 = "BT.709" GAMMA_2_2 = "gamma_2.2" GAMMA_1_8 = "gamma_1.8" GAMMA_2_4 = "gamma_2.4" L_STAR = "L*" BT_1886 = "BT.1886" ST_2084 = "ST 2084" HLG = "HLG" LOG = "log" class OutputDataType(Enum): """Output data type enumeration""" UINT8 = "uint8" UINT10 = "uint10" UINT12 = "uint12" UINT16 = "uint16" INT8 = "int8" INT16 = "int16" FLOAT16 = "float16" FLOAT32 = "float32" FLOAT64 = "float64" class XYZ2RGBConverter: """ XYZ to RGB Color Space Converter Converts XYZ color space data to specified RGB color space """ def __init__(self, rgb_space: RGBColorSpace = RGBColorSpace.SRGB, gamma_method: GammaMethod = GammaMethod.SRGB, output_dtype: OutputDataType = OutputDataType.UINT8): """ Initialize XYZ to RGB converter Parameters: rgb_space: Target RGB color space gamma_method: Gamma correction method output_dtype: Output data type """ if not COLOUR_AVAILABLE: raise ImportError("colour-science library is required: pip install colour-science") self.rgb_space = rgb_space self.gamma_method = gamma_method self.output_dtype = output_dtype # Get colour space definition self.colour_space = RGB_COLOURSPACES.get(rgb_space.value) if self.colour_space is None: available_spaces = list(RGB_COLOURSPACES.keys()) raise ValueError(f"Unsupported RGB color space: {rgb_space.value}. " f"Available: {available_spaces}") print(f"Initialized XYZ to RGB converter:") print(f" Target RGB space: {rgb_space.value}") print(f" Gamma method: {gamma_method.value}") print(f" Output data type: {output_dtype.value}") def convert_xyz_to_rgb(self, xyz_data: np.ndarray) -> np.ndarray: """ Convert XYZ color data to RGB Parameters: xyz_data: XYZ color data array (..., 3) Returns: rgb_data: RGB color data array (..., 3) """ print("Starting XYZ to RGB conversion...") # Validate input shape if xyz_data.shape[-1] != 3: raise ValueError(f"Input must have 3 bands (X, Y, Z), got {xyz_data.shape[-1]}") # Reshape to 2D for processing original_shape = xyz_data.shape xyz_flat = xyz_data.reshape(-1, 3) print(f"Input shape: {original_shape}") print(f"Processing {xyz_flat.shape[0]} pixels...") # Apply gamma correction to XYZ data if needed xyz_processed = self._apply_gamma_to_xyz(xyz_flat) # Convert XYZ to RGB using colour library rgb_linear = XYZ_to_RGB(xyz_processed, self.colour_space.whitepoint, self.colour_space.whitepoint, self.colour_space.matrix_XYZ_to_RGB) # Apply gamma correction to RGB data rgb_corrected = self._apply_gamma_to_rgb(rgb_linear) # Clip to valid range rgb_corrected = np.clip(rgb_corrected, 0.0, 1.0) # Convert to output data type rgb_output = self._convert_to_output_dtype(rgb_corrected) # Reshape back to original shape rgb_result = rgb_output.reshape(original_shape) print(f"Conversion completed. Output shape: {rgb_result.shape}") print(f"Output data type: {rgb_result.dtype}") print(f"Value range: [{rgb_result.min()}, {rgb_result.max()}]") return rgb_result def _apply_gamma_to_xyz(self, xyz_data: np.ndarray) -> np.ndarray: """ Apply gamma correction to XYZ data if needed Parameters: xyz_data: XYZ data array Returns: Processed XYZ data """ # For XYZ to RGB conversion, XYZ data should typically be linear # We assume input XYZ data is already in linear space return xyz_data def _apply_gamma_to_rgb(self, rgb_linear: np.ndarray) -> np.ndarray: """ Apply gamma correction to RGB data Parameters: rgb_linear: Linear RGB data Returns: Gamma-corrected RGB data """ if self.gamma_method == GammaMethod.NONE: return rgb_linear elif self.gamma_method == GammaMethod.SRGB: # sRGB gamma correction mask = rgb_linear <= 0.0031308 rgb_corrected = np.where(mask, rgb_linear * 12.92, 1.055 * np.power(rgb_linear, 1/2.4) - 0.055) return rgb_corrected elif self.gamma_method == GammaMethod.BT_709: # BT.709 gamma correction (same as sRGB for most purposes) mask = rgb_linear <= 0.018 rgb_corrected = np.where(mask, rgb_linear * 4.5, 1.099 * np.power(rgb_linear, 0.45) - 0.099) return rgb_corrected elif self.gamma_method == GammaMethod.GAMMA_2_2: return np.power(rgb_linear, 1/2.2) elif self.gamma_method == GammaMethod.GAMMA_1_8: return np.power(rgb_linear, 1/1.8) elif self.gamma_method == GammaMethod.GAMMA_2_4: return np.power(rgb_linear, 1/2.4) elif self.gamma_method == GammaMethod.L_STAR: # L* (CIE 1976) lightness correction # L* = 116 * (Y/Yn)^(1/3) - 16 for Y/Yn > 0.008856 # L* = 903.3 * (Y/Yn) for Y/Yn <= 0.008856 # For simplicity, approximate with power function return np.power(rgb_linear, 1/3.0) elif self.gamma_method == GammaMethod.BT_1886: # BT.1886 gamma (for reference displays) # V = a * L^γ where γ ≈ 2.4, a is chosen so V=1 when L=1 return np.power(rgb_linear, 1/2.4) elif self.gamma_method == GammaMethod.ST_2084: # SMPTE ST 2084 (PQ curve) for HDR # This is a complex EOTF, simplified approximation m1 = 0.1593017578125 m2 = 78.84375 c1 = 0.8359375 c2 = 18.8515625 c3 = 18.6875 rgb_corrected = np.power((c1 + c2 * np.power(rgb_linear, m1)) / (1 + c3 * np.power(rgb_linear, m1)), m2) return rgb_corrected elif self.gamma_method == GammaMethod.HLG: # Hybrid Log-Gamma (HLG) for HDR # Simplified approximation a = 0.17883277 b = 0.28466892 c = 0.55991073 mask = rgb_linear <= 0.5 rgb_corrected = np.where(mask, np.sqrt(3 * rgb_linear), a * np.log(12 * rgb_linear - b) + c) return rgb_corrected elif self.gamma_method == GammaMethod.LOG: # Logarithmic encoding return np.log1p(rgb_linear) else: warnings.warn(f"Unknown gamma method: {self.gamma_method}, using linear") return rgb_linear def _convert_to_output_dtype(self, rgb_data: np.ndarray) -> np.ndarray: """ Convert RGB data to output data type Parameters: rgb_data: RGB data in [0, 1] range Returns: RGB data in specified output format """ if self.output_dtype == OutputDataType.UINT8: return (rgb_data * 255).astype(np.uint8) elif self.output_dtype == OutputDataType.UINT10: return (rgb_data * 1023).astype(np.uint16) # Use uint16 to store uint10 elif self.output_dtype == OutputDataType.UINT12: return (rgb_data * 4095).astype(np.uint16) # Use uint16 to store uint12 elif self.output_dtype == OutputDataType.UINT16: return (rgb_data * 65535).astype(np.uint16) elif self.output_dtype == OutputDataType.INT8: # Convert [0,1] to [-128,127] range return ((rgb_data * 255) - 128).astype(np.int8) elif self.output_dtype == OutputDataType.INT16: # Convert [0,1] to [-32768,32767] range return ((rgb_data * 65535) - 32768).astype(np.int16) elif self.output_dtype == OutputDataType.FLOAT16: return rgb_data.astype(np.float16) elif self.output_dtype == OutputDataType.FLOAT32: return rgb_data.astype(np.float32) elif self.output_dtype == OutputDataType.FLOAT64: return rgb_data.astype(np.float64) else: return rgb_data class EnviFileHandler: """ENVI file handler for XYZ/RGB data""" def __init__(self): if not SPECTRAL_AVAILABLE: raise ImportError("spectral library is required for ENVI file processing") def load_xyz_image(self, image_path: Union[str, Path]) -> Tuple[np.ndarray, Dict[str, Any]]: """ Load XYZ image from ENVI format file Parameters: image_path: Path to ENVI image file (.dat, .bip, .bsq, etc.) Returns: xyz_data: XYZ data array (height, width, 3) metadata: ENVI file metadata dictionary """ image_path = Path(image_path) print(f"Loading XYZ image: {image_path}") try: # Open image using spectral library img = spectral.open_image(str(image_path)) print(f"Image shape: {img.shape}") print(f"Data type: {img.dtype}") print(f"Number of bands: {img.shape[2] if len(img.shape) > 2 else 1}") except Exception as e: error_msg = f"Failed to open ENVI image {image_path}: {str(e)}" # Check if file exists if not image_path.exists(): error_msg += f"\nFile does not exist: {image_path}" # Suggest possible ENVI files in directory parent_dir = image_path.parent if parent_dir.exists(): envi_files = [] for ext in ['*.hdr', '*.dat', '*.bip', '*.bsq', '*.bil']: envi_files.extend(list(parent_dir.glob(ext))) if envi_files: error_msg += f"\n\nENVI files in directory:" for f in envi_files[:10]: # Show max 10 files error_msg += f"\n {f.name}" else: error_msg += f"\n\nNo ENVI files found in directory" error_msg += f"\n\nSuggestions:" error_msg += f"\n1. Ensure file path is correct" error_msg += f"\n2. Try using data file (.bip, .dat) instead of header file (.hdr)" error_msg += f"\n3. Or use basename without extension to let spectral find files automatically" raise IOError(error_msg) # Check number of bands if img.shape[2] != 3: raise ValueError(f"XYZ image must have 3 bands (X, Y, Z), got {img.shape[2]}") # Load data xyz_data = img.load().astype(np.float32) print(f"Loaded XYZ data shape: {xyz_data.shape}") print(f"Data type: {xyz_data.dtype}") # Validate XYZ value ranges self._print_xyz_range(xyz_data, "Input XYZ") # Extract metadata metadata = {} if hasattr(img, 'metadata') and img.metadata: metadata = dict(img.metadata) return xyz_data, metadata def save_rgb_image(self, rgb_data: np.ndarray, output_path: Union[str, Path], rgb_space: str, input_hdr_path: Optional[Union[str, Path]] = None) -> None: """ Save RGB data as BIP format ENVI file Parameters: rgb_data: RGB data array (height, width, 3) output_path: Output file path (.bip) rgb_space: RGB color space name input_hdr_path: Input HDR file path to copy metadata from """ output_path = Path(output_path) output_path.parent.mkdir(parents=True, exist_ok=True) print(f"Saving RGB data to BIP file: {output_path}") print(f"RGB color space: {rgb_space}") print(f"Data shape: {rgb_data.shape}") print(f"Data type: {rgb_data.dtype}") # Band names for RGB band_names = ['R', 'G', 'B'] if GDAL_AVAILABLE and rgb_data.shape[2] == 3: # Use GDAL to save BIP file driver = gdal.GetDriverByName('ENVI') height, width, channels = rgb_data.shape # Create output dataset out_dataset = driver.Create( str(output_path), width, height, channels, self._gdal_dtype_from_numpy(rgb_data.dtype), options=['INTERLEAVE=BIP'] ) if out_dataset is None: raise ValueError(f"Failed to create output file: {output_path}") # Write each band for band_idx in range(channels): band_data = rgb_data[:, :, band_idx] out_band = out_dataset.GetRasterBand(band_idx + 1) out_band.WriteArray(band_data.astype(rgb_data.dtype)) out_band.SetDescription(band_names[band_idx]) # Set metadata out_dataset.SetMetadataItem('RGB_color_space', rgb_space) out_dataset.SetMetadataItem('data_type', str(rgb_data.dtype)) out_dataset.SetMetadataItem('interleave', 'bip') out_dataset.FlushCache() out_dataset = None print(f"Saved BIP file using GDAL: {output_path}") elif SPECTRAL_AVAILABLE: # Fallback to spectral library # spectral expects (channels, height, width) format rgb_transposed = np.transpose(rgb_data, (2, 0, 1)) # Create HDR file path hdr_path = output_path.with_suffix('.hdr') # Save using spectral spectral.envi.save_image(str(hdr_path), rgb_transposed, dtype=rgb_data.dtype, interleave='bip') print(f"Saved BIP file using spectral: HDR={hdr_path}, DAT={output_path}") else: raise ImportError("Need GDAL or spectral library to save ENVI format") # Create or update HDR file with RGB-specific metadata self._create_rgb_hdr_file(output_path, rgb_data.shape, rgb_data.dtype, rgb_space, input_hdr_path) print(f"RGB data saved successfully: {output_path}") def _gdal_dtype_from_numpy(self, dtype: np.dtype) -> int: """Convert numpy dtype to GDAL data type""" dtype_map = { np.uint8: gdal.GDT_Byte, np.uint16: gdal.GDT_UInt16, np.int8: gdal.GDT_Int8, np.int16: gdal.GDT_Int16, np.uint32: gdal.GDT_UInt32, np.int32: gdal.GDT_Int32, np.float16: gdal.GDT_Float32, # GDAL doesn't have Float16, use Float32 np.float32: gdal.GDT_Float32, np.float64: gdal.GDT_Float64, } return dtype_map.get(dtype.type, gdal.GDT_Float32) def _create_rgb_hdr_file(self, bip_path: Union[str, Path], shape: Tuple[int, int, int], dtype: np.dtype, rgb_space: str, input_hdr_path: Optional[Union[str, Path]] = None) -> None: """ Create ENVI header file for RGB data Parameters: bip_path: BIP file path shape: Data shape (height, width, channels) dtype: Data type rgb_space: RGB color space name input_hdr_path: Input HDR file to copy metadata from """ hdr_path = Path(bip_path).with_suffix('.hdr') height, width, channels = shape # Data type mapping for ENVI dtype_map = { np.uint8: '1', np.int8: '1', # ENVI doesn't distinguish signed/unsigned byte np.int16: '2', np.int32: '3', np.float32: '4', np.float64: '5', np.complex64: '6', np.complex128: '9', np.uint16: '12', np.uint32: '13', np.int64: '14', np.uint64: '15', np.float16: '4', # Use float32 for float16 } envi_dtype = dtype_map.get(dtype.type, '4') # Default to float32 with open(hdr_path, 'w') as f: f.write("ENVI\n") f.write("description = {\n") f.write(f" RGB Color Data - Converted from XYZ to {rgb_space}\n") f.write(" Band Interleaved by Pixel (BIP) format\n") f.write("}\n") f.write(f"samples = {width}\n") f.write(f"lines = {height}\n") f.write(f"bands = {channels}\n") f.write("header offset = 0\n") f.write("file type = ENVI Standard\n") f.write(f"data type = {envi_dtype}\n") f.write("interleave = bip\n") f.write("sensor type = Unknown\n") f.write("byte order = 0\n") # Band names f.write("band names = {\n") band_names = ['Red', 'Green', 'Blue'] for i, name in enumerate(band_names): f.write(f' "{name}"') if i < len(band_names) - 1: f.write(",") f.write("\n") f.write("}\n") # RGB-specific metadata f.write(f"RGB_color_space = {rgb_space}\n") f.write(f"data_type_description = {dtype}\n") # Copy metadata from input file if available if input_hdr_path and Path(input_hdr_path).exists(): try: self._copy_hdr_metadata(input_hdr_path, f) except Exception as e: print(f"Warning: Failed to copy metadata from input HDR: {e}") print(f"ENVI header file created: {hdr_path}") def _copy_hdr_metadata(self, input_hdr_path: Union[str, Path], output_file) -> None: """ Copy relevant metadata from input HDR file Parameters: input_hdr_path: Input HDR file path output_file: Output file object """ try: with open(input_hdr_path, 'r', encoding='utf-8', errors='ignore') as f: content = f.read() lines = content.split('\n') metadata_to_copy = [] # Fields to copy fields_to_copy = [ 'wavelength units', 'wavelength', 'fwhm', 'bbl', 'map info', 'coordinate system string', 'projection info', 'pixel size', 'acquisition time', 'sensor type' ] i = 0 while i < len(lines): line = lines[i].strip() if '=' in line: key = line.split('=')[0].strip().lower() if any(field in key for field in fields_to_copy): metadata_to_copy.append(lines[i]) i += 1 # Continue reading multi-line values while i < len(lines) and not ('=' in lines[i] and not lines[i].strip().endswith(',')): if lines[i].strip(): metadata_to_copy.append(lines[i]) i += 1 if i >= len(lines): break continue i += 1 # Write copied metadata if metadata_to_copy: output_file.write("\n") for line in metadata_to_copy: if line.strip(): output_file.write(line + "\n") print(f"Copied {len(metadata_to_copy)} metadata lines from input HDR") except Exception as e: print(f"Error reading input HDR file: {e}") def _print_xyz_range(self, xyz_data: np.ndarray, data_name: str) -> None: """Print XYZ value ranges""" X_min, X_max = xyz_data[..., 0].min(), xyz_data[..., 0].max() Y_min, Y_max = xyz_data[..., 1].min(), xyz_data[..., 1].max() Z_min, Z_max = xyz_data[..., 2].min(), xyz_data[..., 2].max() print(f"{data_name} XYZ value ranges:") print(f" X: [{X_min:.3f}, {X_max:.3f}]") print(f" Y: [{Y_min:.3f}, {Y_max:.3f}]") print(f" Z: [{Z_min:.3f}, {Z_max:.3f}]") class XYZ2RGBApp: """Main application class for XYZ to RGB conversion""" def __init__(self): self.converter = None self.file_handler = None if not SPECTRAL_AVAILABLE else EnviFileHandler() def run(self, args): """Run the conversion application""" print("=" * 60) print("XYZ to RGB Color Space Converter") print("=" * 60) # Initialize converter rgb_space = RGBColorSpace(args.rgb_space) gamma_method = GammaMethod(args.gamma) output_dtype = OutputDataType(args.output_dtype) self.converter = XYZ2RGBConverter(rgb_space, gamma_method, output_dtype) # Load XYZ image xyz_data, metadata = self.file_handler.load_xyz_image(args.input) # Convert XYZ to RGB rgb_data = self.converter.convert_xyz_to_rgb(xyz_data) # Save RGB image output_path = Path(args.output) self.file_handler.save_rgb_image(rgb_data, output_path, rgb_space.value, args.input) print("=" * 60) print("Conversion completed successfully!") print("=" * 60) def parse_arguments(): """Parse command line arguments""" parser = argparse.ArgumentParser( description='XYZ to RGB Color Space Converter', formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" Usage examples: # Convert XYZ to sRGB with uint8 output python XYZ2RGB.py --input xyz_image.dat --output rgb_image.bip # Convert to Adobe RGB with gamma correction python XYZ2RGB.py --input xyz_image.dat --output rgb_image.bip \\ --rgb-space "Adobe RGB (1998)" --gamma sRGB # Convert to DCI-P3 with float32 output python XYZ2RGB.py --input xyz_image.dat --output rgb_image.bip \\ --rgb-space "DCI-P3" --output-dtype float32 """ ) # Required arguments parser.add_argument('--input', required=True, help='Input XYZ image file path (.dat, .bip, .bsq, etc.)') parser.add_argument('--output', required=True, help='Output RGB image file path (.bip)') # Conversion parameters parser.add_argument('--rgb-space', default='sRGB', choices=[space.value for space in RGBColorSpace], help='Target RGB color space (default: sRGB)') parser.add_argument('--gamma', default='sRGB', choices=[method.value for method in GammaMethod], help='Gamma correction method (default: sRGB)') parser.add_argument('--output-dtype', default='uint8', choices=[dtype.value for dtype in OutputDataType], help='Output data type (default: uint8)') return parser.parse_args() # Direct function call interface def convert_xyz_to_rgb(input_path: Union[str, Path], output_path: Union[str, Path], rgb_space: str = 'sRGB', gamma_method: str = 'sRGB', output_dtype: str = 'uint8') -> np.ndarray: """ Directly convert XYZ image to RGB Parameters: input_path: Input XYZ image file path output_path: Output RGB image file path rgb_space: Target RGB color space gamma_method: Gamma correction method output_dtype: Output data type Returns: rgb_data: Converted RGB data array Example: >>> rgb_data = convert_xyz_to_rgb( ... input_path="xyz_image.dat", ... output_path="rgb_image.bip", ... rgb_space="Adobe RGB (1998)", ... output_dtype="float32" ... ) """ # Validate dependencies if not SPECTRAL_AVAILABLE: raise ImportError("spectral library is required: pip install spectral") if not COLOUR_AVAILABLE: raise ImportError("colour-science library is required: pip install colour-science") # Create application instance app = XYZ2RGBApp() try: # Initialize converter rgb_space_enum = RGBColorSpace(rgb_space) gamma_enum = GammaMethod(gamma_method) dtype_enum = OutputDataType(output_dtype) app.converter = XYZ2RGBConverter(rgb_space_enum, gamma_enum, dtype_enum) # Load and convert xyz_data, metadata = app.file_handler.load_xyz_image(input_path) rgb_data = app.converter.convert_xyz_to_rgb(xyz_data) # Save result app.file_handler.save_rgb_image(rgb_data, output_path, rgb_space, input_path) print(f"Conversion completed! RGB data saved to: {output_path}") return rgb_data except Exception as e: print(f"Conversion failed: {e}") raise def main(): """Main function""" try: # Parse command line arguments args = parse_arguments() # Validate required libraries if not SPECTRAL_AVAILABLE: print("Error: spectral library is required for ENVI file processing") print("Install with: pip install spectral") sys.exit(1) if not COLOUR_AVAILABLE: print("Error: colour-science library is required for color space conversion") print("Install with: pip install colour-science") sys.exit(1) # Create and run application app = XYZ2RGBApp() app.run(args) except ImportError as e: print(f"Import error: {e}") print("Please ensure all required libraries are installed:") print(" pip install numpy colour-science spectral") if TQDM_AVAILABLE: print(" pip install tqdm # Optional, for progress bars") sys.exit(1) except FileNotFoundError as e: print(f"File error: File not found - {e}") sys.exit(1) except ValueError as e: print(f"Data error: {e}") sys.exit(1) except Exception as e: print(f"Unexpected error: {e}") import traceback traceback.print_exc() sys.exit(1) # Direct execution example def main(): """主函数：命令行接口""" import argparse parser = argparse.ArgumentParser( description='XYZ到RGB颜色空间转换工具', formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" 使用示例: 1. 基本转换 (sRGB, uint8): python XYZ2RGB.py input_xyz.hdr -o output_rgb.bip 2. 指定RGB色彩空间和数据类型: python XYZ2RGB.py input_xyz.dat -s "Adobe RGB (1998)" -g gamma_2.2 -t uint16 -o output.bip 3. 无伽马校正 (保持线性): python XYZ2RGB.py input_xyz.hdr -g none -t float32 -o output_linear.bip 支持的RGB色彩空间: sRGB, Adobe RGB (1998), DCI-P3, ITU-R BT.709, ITU-R BT.2020, ACES2065-1, ACEScg, ProPhoto RGB, Apple RGB, PAL/SECAM, NTSC (1953) 支持的伽马方法: sRGB, BT.709, gamma_2.2, gamma_1.8, L*, BT.1886, ST 2084, HLG, none 支持的输出数据类型: uint8, uint10, uint12, uint16, int8, int16, float16, float32, float64 """ ) parser.add_argument('input_path', help='输入XYZ文件路径 (.hdr 或 .dat)') parser.add_argument('-o', '--output', required=True, help='输出RGB文件路径') parser.add_argument('-s', '--rgb_space', default='sRGB', choices=['sRGB', 'Adobe RGB (1998)', 'DCI-P3', 'ITU-R BT.709', 'ITU-R BT.2020', 'ACES2065-1', 'ACEScg', 'ProPhoto RGB', 'Apple RGB', 'PAL/SECAM', 'NTSC (1953)'], help='RGB色彩空间 (默认: sRGB)') parser.add_argument('-g', '--gamma_method', default='sRGB', choices=['sRGB', 'BT.709', 'gamma_2.2', 'gamma_1.8', 'L*', 'BT.1886', 'ST 2084', 'HLG', 'none'], help='伽马校正方法 (默认: sRGB)') parser.add_argument('-t', '--output_dtype', default='uint8', choices=['uint8', 'uint10', 'uint12', 'uint16', 'int8', 'int16', 'float16', 'float32', 'float64'], help='输出数据类型 (默认: uint8)') args = parser.parse_args() try: print("=" * 60) print("XYZ到RGB颜色空间转换工具") print("=" * 60) print(f"输入文件: {args.input_path}") print(f"输出文件: {args.output}") print(f"RGB色彩空间: {args.rgb_space}") print(f"伽马方法: {args.gamma_method}") print(f"输出数据类型: {args.output_dtype}") print() rgb_result = convert_xyz_to_rgb( input_path=args.input_path, output_path=args.output, rgb_space=args.rgb_space, gamma_method=args.gamma_method, output_dtype=args.output_dtype ) print("\n" + "=" * 60) print("转换完成!") print(f"RGB数据形状: {rgb_result.shape}") print(f"RGB数据类型: {rgb_result.dtype}") print(f"值范围: [{rgb_result.min()}, {rgb_result.max()}]") print("=" * 60) except Exception as e: print(f"✗ 处理失败: {e}") import traceback traceback.print_exc() return 1 return 0 if __name__ == '__main__': exit(main())