HDR Mapeo de Tonos y Conversión de Gamut de Color en Práctica 2025

// Verificación de límites de gamut
function isInGamut(color, gamut) {
  const [L, a, b] = rgbToLab(color);
  return checkGamutBoundary(L, a, b, gamut);
}

// Recorte vs compresión
function gamutMapping(color, sourceGamut, targetGamut) {
  if (isInGamut(color, targetGamut)) {
    return color; // No se necesita conversión
  }
  
  // Compresión perceptual
  return perceptualCompress(color, sourceGamut, targetGamut);
}

[R']   [3.2406 -1.5372 -0.4986]   [R]
[G'] = [-0.9689  1.8758  0.0415] × [G]
[B']   [0.0557 -0.2040  1.0570]   [B]

// Mapeo de Tonos ACES
vec3 acesToneMapping(vec3 color) {
  float a = 2.51;
  float b = 0.03;
  float c = 2.43;
  float d = 0.59;
  float e = 0.14;
  
  return clamp((color * (a * color + b)) / 
               (color * (c * color + d) + e), 0.0, 1.0);
}

function reinhardToneMapping(hdrColor, whitePoint = 1.0) {
  return hdrColor.map(channel => 
    channel * (1 + channel / (whitePoint * whitePoint)) / (1 + channel)
  );
}

vec3 filmicToneMapping(vec3 x) {
  float A = 0.15; // Shoulder Strength
  float B = 0.50; // Linear Strength  
  float C = 0.10; // Linear Angle
  float D = 0.20; // Toe Strength
  float E = 0.02; // Toe Numerator
  float F = 0.30; // Toe Denominator
  
  return ((x*(A*x+C*B)+D*E)/(x*(A*x+B)+D*F))-E/F;
}

import numpy as np
from colorspacious import cspace_convert

def convert_color_gamut(image, source_space, target_space):
    """
    Implementación de conversión de gamut de color
    """
    # Conversión RGB Lineal → Lab
    lab_image = cspace_convert(image, source_space, "CIELab")
    
    # Compresión de gamut (si es necesario)
    compressed_lab = apply_gamut_compression(lab_image, target_space)
    
    # Conversión Lab → espacio de color objetivo
    result = cspace_convert(compressed_lab, "CIELab", target_space)
    
    return np.clip(result, 0, 1)

def apply_gamut_compression(lab_color, target_gamut):
    """
    Compresión de gamut perceptual
    """
    L, a, b = lab_color[..., 0], lab_color[..., 1], lab_color[..., 2]
    
    # Cálculo de croma
    chroma = np.sqrt(a**2 + b**2)
    
    # Cálculo de límites de gamut
    max_chroma = calculate_max_chroma(L, target_gamut)
    
    # Cálculo de relación de compresión
    compression_ratio = np.where(chroma > max_chroma,
                                 max_chroma / chroma, 1.0)
    
    # Cálculo de color comprimido
    compressed_lab = np.stack([
        L,
        a * compression_ratio,
        b * compression_ratio
    ], axis=-1)
    
    return compressed_lab

from colorspacious import deltaE

def evaluate_conversion_quality(original, converted):
    """
    Evaluación de calidad de conversión
    """
    # Calcular diferencia de color en espacio de color Lab
    original_lab = cspace_convert(original, "sRGB1", "CIELab")
    converted_lab = cspace_convert(converted, "sRGB1", "CIELab")
    
    # Diferencia de color CIEDE2000
    delta_e = deltaE(original_lab, converted_lab, input_space="CIELab")
    
    # Rango aceptable: ΔE < 2.3 (perceptualmente equivalente)
    acceptable_ratio = np.mean(delta_e < 2.3)
    
    return {
        'mean_delta_e': np.mean(delta_e),
        'max_delta_e': np.max(delta_e),
        'acceptable_ratio': acceptable_ratio
    }

// Aplicación de perfil ICC en WebGL
const iccProfileTexture = gl.createTexture();
gl.bindTexture(gl.TEXTURE_3D, iccProfileTexture);

// Cargar perfil como 3D LUT
function loadICCProfile(profileData) {
  const lutSize = 64;
  const lutData = new Uint8Array(lutSize * lutSize * lutSize * 4);
  
  // Generar 3D LUT desde perfil
  generateLUT(profileData, lutData, lutSize);
  
  gl.texImage3D(gl.TEXTURE_3D, 0, gl.RGBA8,
                lutSize, lutSize, lutSize, 0,
                gl.RGBA, gl.UNSIGNED_BYTE, lutData);
}

function getAdaptiveTonemapParams(displayInfo) {
  const {
    maxLuminance,
    gamut,
    gamma,
    ambientLight
  } = displayInfo;
  
  // Ajuste basado en luz ambiental
  const adaptationFactor = calculateAdaptation(ambientLight);
  
  // Mapeo basado en gamut del display
  const gamutCompression = calculateGamutCompression(gamut);
  
  return {
    exposure: adaptationFactor * 0.8,
    whitePoint: maxLuminance / 100,
    gamutCompression: gamutCompression,
    gamma: gamma || 2.2
  };
}

// Vertex shader
attribute vec4 position;
attribute vec2 texCoord;
varying vec2 vTexCoord;

void main() {
  gl_Position = position;
  vTexCoord = texCoord;
}

// Fragment shader
precision highp float;
varying vec2 vTexCoord;
uniform sampler2D hdrTexture;
uniform sampler3D lutTexture;
uniform float exposure;
uniform float gamma;

vec3 ACESFilmic(vec3 x) {
  float a = 2.51;
  float b = 0.03;
  float c = 2.43;
  float d = 0.59;
  float e = 0.14;
  return clamp((x*(a*x+b))/(x*(c*x+d)+e), 0.0, 1.0);
}

void main() {
  vec4 hdrColor = texture2D(hdrTexture, vTexCoord);
  
  // Ajuste de exposición
  vec3 exposedColor = hdrColor.rgb * exposure;
  
  // Mapeo de tonos
  vec3 toneMapped = ACESFilmic(exposedColor);
  
  // Corrección gamma
  vec3 gammaCorrected = pow(toneMapped, vec3(1.0 / gamma));
  
  // Aplicación 3D LUT (conversión de gamut de color)
  vec3 lutColor = texture3D(lutTexture, gammaCorrected).rgb;
  
  gl_FragColor = vec4(lutColor, hdrColor.a);
}

import multiprocessing as mp
from functools import partial

def process_hdr_batch(image_paths, source_space, target_space):
    """
    Ejecución paralela de conversión HDR en procesamiento por lotes
    """
    pool_size = mp.cpu_count()
    
    with mp.Pool(pool_size) as pool:
        convert_func = partial(
            convert_single_image,
            source_space=source_space,
            target_space=target_space
        )
        
        results = pool.map(convert_func, image_paths)
    
    return results

def convert_single_image(image_path, source_space, target_space):
    """
    Procesamiento de conversión HDR de imagen única
    """
    # Carga de imagen
    image = load_hdr_image(image_path)
    
    # Mapeo de tonos
    tone_mapped = apply_tone_mapping(image)
    
    # Conversión de gamut de color
    converted = convert_color_gamut(tone_mapped, source_space, target_space)
    
    # Guardar
    output_path = get_output_path(image_path, target_space)
    save_image(converted, output_path)
    
    return output_path

def evaluate_hdr_conversion(original_hdr, converted_sdr, reference_sdr=None):
    """
    Evaluación de calidad de conversión HDR→SDR
    """
    metrics = {}
    
    # Similitud Estructural (SSIM)
    metrics['ssim'] = calculate_ssim(converted_sdr, reference_sdr)
    
    # Evaluación de Calidad de Imagen Perceptual (LPIPS)
    metrics['lpips'] = calculate_lpips(converted_sdr, reference_sdr)
    
    # Comparación de histograma de color
    metrics['histogram_correlation'] = compare_histograms(
        converted_sdr, reference_sdr)
    
    # Tasa de preservación de rango dinámico
    metrics['dynamic_range_preservation'] = calculate_dr_preservation(
        original_hdr, converted_sdr)
    
    return metrics

def calculate_dr_preservation(hdr_image, sdr_image):
    """
    Cálculo de tasa de preservación de rango dinámico
    """
    # Rango dinámico efectivo de HDR
    hdr_range = np.log10(np.max(hdr_image) / np.min(hdr_image[hdr_image > 0]))
    
    # Rango dinámico efectivo de SDR  
    sdr_range = np.log10(np.max(sdr_image) / np.min(sdr_image[sdr_image > 0]))
    
    # Relación de preservación
    preservation_ratio = sdr_range / hdr_range
    
    return preservation_ratio

class HDRConversionTester {
  constructor(originalHDR, methods) {
    this.originalHDR = originalHDR;
    this.methods = methods;
    this.results = {};
  }
  
  async runAllTests() {
    for (const [methodName, method] of Object.entries(this.methods)) {
      console.log(`Testing ${methodName}...`);
      
      const startTime = performance.now();
      const converted = await method.convert(this.originalHDR);
      const endTime = performance.now();
      
      this.results[methodName] = {
        image: converted,
        processingTime: endTime - startTime,
        quality: await this.evaluateQuality(converted),
        fileSize: this.calculateFileSize(converted)
      };
    }
    
    return this.generateReport();
  }
  
  generateReport() {
    const sortedResults = Object.entries(this.results)
      .sort((a, b) => b[1].quality.overall - a[1].quality.overall);
    
    return {
      bestMethod: sortedResults[0][0],
      rankings: sortedResults,
      recommendations: this.generateRecommendations(sortedResults)
    };
  }
}

# Ejemplo de pipeline CI/CD
hdr_processing:
  stage: process
  script:
    - python scripts/batch_hdr_convert.py
      --input-dir assets/hdr/
      --output-dir dist/images/
      --source-space rec2020
      --target-space srgb
      --tone-mapping aces
      --quality-check
  artifacts:
    paths:
      - dist/images/
    reports:
      - quality_report.json

def setup_quality_monitoring():
    """
    Configuración de monitoreo de calidad
    """
    quality_thresholds = {
        'min_ssim': 0.85,
        'max_lpips': 0.1,
        'min_dynamic_range_preservation': 0.7
    }
    
    def quality_check_callback(metrics):
        for metric, value in metrics.items():
            if metric.startswith('min_') and value < quality_thresholds[metric]:
                send_alert(f"Quality degradation: {metric} = {value}")
            elif metric.startswith('max_') and value > quality_thresholds[metric]:
                send_alert(f"Quality degradation: {metric} = {value}")
    
    return quality_check_callback