HDR टोन मैपिंग और कलर गैमट कन्वर्जन व्यवहार में 2025

// गैमट सीमा जांच
function isInGamut(color, gamut) {
  const [L, a, b] = rgbToLab(color);
  return checkGamutBoundary(L, a, b, gamut);
}

// क्लिपिंग बनाम संपीड़न
function gamutMapping(color, sourceGamut, targetGamut) {
  if (isInGamut(color, targetGamut)) {
    return color; // कोई कन्वर्जन आवश्यक नहीं
  }
  
  // अवधारणात्मक संपीड़न
  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]

// 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):
    """
    कलर गैमट कन्वर्जन कार्यान्वयन
    """
    # रैखिक RGB → Lab कन्वर्जन
    lab_image = cspace_convert(image, source_space, "CIELab")
    
    # गैमट संपीड़न (यदि आवश्यक हो)
    compressed_lab = apply_gamut_compression(lab_image, target_space)
    
    # Lab → लक्ष्य कलर स्पेस कन्वर्जन
    result = cspace_convert(compressed_lab, "CIELab", target_space)
    
    return np.clip(result, 0, 1)

def apply_gamut_compression(lab_color, target_gamut):
    """
    अवधारणात्मक गैमट संपीड़न
    """
    L, a, b = lab_color[..., 0], lab_color[..., 1], lab_color[..., 2]
    
    # क्रोमा गणना
    chroma = np.sqrt(a**2 + b**2)
    
    # गैमट सीमा गणना
    max_chroma = calculate_max_chroma(L, target_gamut)
    
    # संपीड़न अनुपात गणना
    compression_ratio = np.where(chroma > max_chroma,
                                 max_chroma / chroma, 1.0)
    
    # संपीड़ित रंग गणना
    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):
    """
    कन्वर्जन गुणवत्ता मूल्यांकन
    """
    # Lab कलर स्पेस में कलर अंतर की गणना
    original_lab = cspace_convert(original, "sRGB1", "CIELab")
    converted_lab = cspace_convert(converted, "sRGB1", "CIELab")
    
    # CIEDE2000 कलर अंतर
    delta_e = deltaE(original_lab, converted_lab, input_space="CIELab")
    
    # स्वीकार्य सीमा: ΔE < 2.3 (अवधारणात्मक रूप से समकक्ष)
    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
    }

// WebGL में ICC प्रोफाइल आवेदन
const iccProfileTexture = gl.createTexture();
gl.bindTexture(gl.TEXTURE_3D, iccProfileTexture);

// प्रोफाइल को 3D LUT के रूप में लोड करें
function loadICCProfile(profileData) {
  const lutSize = 64;
  const lutData = new Uint8Array(lutSize * lutSize * lutSize * 4);
  
  // प्रोफाइल से 3D LUT जेनरेट करें
  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;
  
  // परिवेशी प्रकाश के आधार पर समायोजन
  const adaptationFactor = calculateAdaptation(ambientLight);
  
  // डिस्प्ले गैमट के आधार पर मैपिंग
  const gamutCompression = calculateGamutCompression(gamut);
  
  return {
    exposure: adaptationFactor * 0.8,
    whitePoint: maxLuminance / 100,
    gamutCompression: gamutCompression,
    gamma: gamma || 2.2
  };
}

// वर्टेक्स शेडर
attribute vec4 position;
attribute vec2 texCoord;
varying vec2 vTexCoord;

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

// फ्रैगमेंट शेडर
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);
  
  // एक्सपोज़र समायोजन
  vec3 exposedColor = hdrColor.rgb * exposure;
  
  // टोन मैपिंग
  vec3 toneMapped = ACESFilmic(exposedColor);
  
  // गामा सुधार
  vec3 gammaCorrected = pow(toneMapped, vec3(1.0 / gamma));
  
  // 3D LUT आवेदन (कलर गैमट कन्वर्जन)
  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):
    """
    बैच प्रसंस्करण में HDR कन्वर्जन का समानांतर निष्पादन
    """
    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):
    """
    एकल छवि HDR कन्वर्जन प्रसंस्करण
    """
    # छवि लोडिंग
    image = load_hdr_image(image_path)
    
    # टोन मैपिंग
    tone_mapped = apply_tone_mapping(image)
    
    # कलर गैमट कन्वर्जन
    converted = convert_color_gamut(tone_mapped, source_space, target_space)
    
    # सेव करना
    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):
    """
    HDR→SDR कन्वर्जन गुणवत्ता मूल्यांकन
    """
    metrics = {}
    
    # संरचनात्मक समानता (SSIM)
    metrics['ssim'] = calculate_ssim(converted_sdr, reference_sdr)
    
    # अवधारणात्मक छवि गुणवत्ता मूल्यांकन (LPIPS)
    metrics['lpips'] = calculate_lpips(converted_sdr, reference_sdr)
    
    # कलर हिस्टोग्राम तुलना
    metrics['histogram_correlation'] = compare_histograms(
        converted_sdr, reference_sdr)
    
    # डायनामिक रेंज संरक्षण दर
    metrics['dynamic_range_preservation'] = calculate_dr_preservation(
        original_hdr, converted_sdr)
    
    return metrics

def calculate_dr_preservation(hdr_image, sdr_image):
    """
    डायनामिक रेंज संरक्षण दर की गणना
    """
    # HDR का प्रभावी डायनामिक रेंज
    hdr_range = np.log10(np.max(hdr_image) / np.min(hdr_image[hdr_image > 0]))
    
    # SDR का प्रभावी डायनामिक रेंज  
    sdr_range = np.log10(np.max(sdr_image) / np.min(sdr_image[sdr_image > 0]))
    
    # संरक्षण अनुपात
    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)
    };
  }
}

# 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():
    """
    गुणवत्ता निगरानी सेटअप
    """
    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"गुणवत्ता में गिरावट: {metric} = {value}")
            elif metric.startswith('max_') and value > quality_thresholds[metric]:
                send_alert(f"गुणवत्ता में गिरावट: {metric} = {value}")
    
    return quality_check_callback