Mapeamento de Tom HDR e Conversão de Gamut de Cor na Prática 2025

// Verificação de limites de gamut
function isInGamut(color, gamut) {
  const [L, a, b] = rgbToLab(color);
  return checkGamutBoundary(L, a, b, gamut);
}

// Recorte vs compressão
function gamutMapping(color, sourceGamut, targetGamut) {
  if (isInGamut(color, targetGamut)) {
    return color; // Nenhuma conversão necessária
  }
  
  // Compressão 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]

// Mapeamento de Tom 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):
    """
    Implementação de conversão de gamut de cor
    """
    # Conversão RGB Linear → Lab
    lab_image = cspace_convert(image, source_space, "CIELab")
    
    # Compressão de gamut (se necessário)
    compressed_lab = apply_gamut_compression(lab_image, target_space)
    
    # Conversão Lab → espaço de cor alvo
    result = cspace_convert(compressed_lab, "CIELab", target_space)
    
    return np.clip(result, 0, 1)

def apply_gamut_compression(lab_color, target_gamut):
    """
    Compressão 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 limites de gamut
    max_chroma = calculate_max_chroma(L, target_gamut)
    
    # Cálculo da razão de compressão
    compression_ratio = np.where(chroma > max_chroma,
                                 max_chroma / chroma, 1.0)
    
    # Cálculo de cor comprimida
    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):
    """
    Avaliação de qualidade de conversão
    """
    # Calcular diferença de cor no espaço de cor Lab
    original_lab = cspace_convert(original, "sRGB1", "CIELab")
    converted_lab = cspace_convert(converted, "sRGB1", "CIELab")
    
    # Diferença de cor CIEDE2000
    delta_e = deltaE(original_lab, converted_lab, input_space="CIELab")
    
    # Faixa aceitável: Δ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
    }

// Aplicação de perfil ICC no WebGL
const iccProfileTexture = gl.createTexture();
gl.bindTexture(gl.TEXTURE_3D, iccProfileTexture);

// Carregar perfil como 3D LUT
function loadICCProfile(profileData) {
  const lutSize = 64;
  const lutData = new Uint8Array(lutSize * lutSize * lutSize * 4);
  
  // Gerar 3D LUT a partir do 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 baseado na luz ambiente
  const adaptationFactor = calculateAdaptation(ambientLight);
  
  // Mapeamento baseado no gamut da exibição
  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 exposição
  vec3 exposedColor = hdrColor.rgb * exposure;
  
  // Mapeamento de tom
  vec3 toneMapped = ACESFilmic(exposedColor);
  
  // Correção gamma
  vec3 gammaCorrected = pow(toneMapped, vec3(1.0 / gamma));
  
  // Aplicação 3D LUT (conversão de gamut de cor)
  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):
    """
    Execução paralela de conversão HDR em processamento em lote
    """
    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):
    """
    Processamento de conversão HDR de imagem única
    """
    # Carregamento de imagem
    image = load_hdr_image(image_path)
    
    # Mapeamento de tom
    tone_mapped = apply_tone_mapping(image)
    
    # Conversão de gamut de cor
    converted = convert_color_gamut(tone_mapped, source_space, target_space)
    
    # Salvar
    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):
    """
    Avaliação de qualidade de conversão HDR→SDR
    """
    metrics = {}
    
    # Similaridade Estrutural (SSIM)
    metrics['ssim'] = calculate_ssim(converted_sdr, reference_sdr)
    
    # Avaliação de Qualidade de Imagem Perceptual (LPIPS)
    metrics['lpips'] = calculate_lpips(converted_sdr, reference_sdr)
    
    # Comparação de histograma de cor
    metrics['histogram_correlation'] = compare_histograms(
        converted_sdr, reference_sdr)
    
    # Taxa de preservação de faixa dinâmica
    metrics['dynamic_range_preservation'] = calculate_dr_preservation(
        original_hdr, converted_sdr)
    
    return metrics

def calculate_dr_preservation(hdr_image, sdr_image):
    """
    Cálculo da taxa de preservação de faixa dinâmica
    """
    # Faixa dinâmica efetiva do HDR
    hdr_range = np.log10(np.max(hdr_image) / np.min(hdr_image[hdr_image > 0]))
    
    # Faixa dinâmica efetiva do SDR  
    sdr_range = np.log10(np.max(sdr_image) / np.min(sdr_image[sdr_image > 0]))
    
    # Razão de preservação
    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)
    };
  }
}

# Exemplo 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():
    """
    Configuração de monitoramento de qualidade
    """
    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"Degradação de qualidade: {metric} = {value}")
            elif metric.startswith('max_') and value > quality_thresholds[metric]:
                send_alert(f"Degradação de qualidade: {metric} = {value}")
    
    return quality_check_callback