Lecture des fichiers DNG

DNG (Digital Negative) est le format RAW ouvert d'Adobe. Votre première tâche est de charger les données brutes du capteur à partir d'un fichier DNG. Le code de départ effectue cette section en entier pour vous dans la fonction process_dng_files().

Métadonnées extraites du fichier DNG :

• L'arrangement du motif de Bayer (RGGB, BGGR, GRBG, ou GBRG); Faites attention, chaque image peut avoir un arrangement différent!
• La profondeur de bits du capteur
• Les valeurs de niveau de noir (black level) et de niveau de blanc (white level)
• Les multiplicateurs de balance des blancs disponibles dans les métadonnées

Normalisation requise :

Normalisez les données brutes en valeurs à virgule flottante dans l'intervalle [0, 1], en tenant compte de la soustraction du niveau de noir :

image_normalized = (image_raw - black_level) / (white_level - black_level)

Ces valeurs sont disponibles dans les métadonnées du fichier DNG. Avec rawpy, ces valeurs sont disponibles dans les attributs black_level_per_channel et camera_white_level_per_channel.

L'image est enregistrée en tiff 16 bits, ainsi que la matrice RGB-XYZ (rgb_xyz_matrix) et camera_whitebalance (camera_whitebalance) sont enregistrées dans un fichier de métadonnées en format JSON.

Discussion requise : Veuillez discuter brièvement des résultats obtenus dans cette section.

Le dématriçage (aussi appelé debayering) reconstruit l'image RGB complète à partir de la mosaïque Bayer mono-canal. Puisque chaque pixel n'enregistre qu'une seule couleur, les deux autres doivent être interpolées à partir des pixels voisins.

Prenez la sortie de la section 1 et applquez-y les algorithmes suivants.

A) Interpolation bilinéaire 5%

Interpoler les valeurs de couleur manquantes en utilisant la moyenne des pixels voisins de la même couleur. Par exemple, pour trouver la valeur rouge à un pixel d'une autre couleur, faites la moyenne des quatre voisins rouges diagonaux. Implémentez votre code dans la fonction demosaic_bilinear().

B) Méthode Malvar-He-Cutler (2004) 25% (GIF-4105) 20% (GIF-7105)

Cette interpolation corrigée par gradient améliore l'interpolation bilinéaire en utilisant l'information sur les contours. Implémentez l'algorithme tel que décrit dans :

• Malvar, He, and Cutler, "High-Quality Linear Interpolation for Demosaicing of Bayer-Patterned Color Images," ICASSP 2004
• Référence : Malvar He Cutler 2004

Utilisez les poids d'interpolation décrits dans la Fig. 2 de la référence. Implémentez votre code dans la fonction demosaic_malvar().

Les images RAW capturent la couleur réelle de la lumière atteignant le capteur, qui varie dramatiquement selon la source d'éclairage. La balance des blancs ajuste les canaux RGB pour que les objets neutres apparaissent neutres dans l'image finale.

Appliquez cette balance des blancs sur l'image produite par un des algorithmes de la section précédente de votre choix. Nous vous recommandons de prendre Malvar-He-Cutler.

A) Sélection automatique de région neutre 10%

Implémentez dans find_neutral_region() un algorithme qui trouve automatiquement une région « neutre » dans l'image. L'idée est de chercher des régions qui sont à la fois lumineuses et neutres (faible écart-type entre les canaux R, G, B).

Algorithme suggéré :

1. Parcourez l'image par pas réguliers (ex: 20 pixels)
2. Pour chaque région de taille fixe (ex: 11×11 pixels), calculez :
   • La luminosité moyenne : luminosité = 0.299×R + 0.587×G + 0.114×B
   • La neutralité : neutralité = 1 / (1 + écart_type(R, G, B) × 10)
   • Le score combiné : score = luminosité × neutralité
3. Gardez la région avec le meilleur score (si luminosité > 0.2)
4. Utilisez cette région pour calculer les multiplicateurs de correction :
   • multiplicateur_R = gris_cible / moyenne_R_dans_région
   • multiplicateur_G = gris_cible / moyenne_G_dans_région
   • multiplicateur_B = gris_cible / moyenne_B_dans_région

Appliquez ces multiplicateurs à l'image entière dans la fonction white_balance_auto_neutral().

B) Algorithme Grey World 10%

Implémentez dans white_balance_grey_world() la balance des blancs automatique basée sur l'hypothèse du grey world : la couleur moyenne d'une scène devrait être un gris neutre.

• Calculez la moyenne de chaque canal sur l'image entière
• Mettez à l'échelle chaque canal pour que toutes les moyennes soient égales (typiquement à la moyenne du canal vert)

C) Balance des Blancs proposée par la caméra

La caméra peut proposer une balance des blancs automatique basée sur les métadonnées de l'image. Employez cette valeur (camera_whitebalance dans RawPy) pour appliquer une balance des blancs automatique. Note : Le code de départ fourni implémente déjà cette fonctionnalité dans white_balance_camera().

• Multipliez les 3 premières valeurs de camera_whitebalance par chacun des canaux de l'image pour appliquer une balance des blancs automatique.

Post-traitement

La sortie de cette étape doit être en espace XYZ. Pour ce faire, prenez vos valeurs de sortie en A), B), et C) et multipliez-les par la matrice RGB-XYZ (rgb_xyz_matrix) pour obtenir la sortie en espace XYZ.

Note sur les espaces de couleur : Après le dématriçage, l'espace de couleur est "RGB de la caméra", qui n'est pas un espace standard. Le manufacturier donne la matrice de conversion vers XYZ, et après on peut convertir en ce qu'on veut (sRGB dans ce cas-ci). Le code de démarrage vous offre cette fonctionalité dans camera_rgb_to_xyz().

Discussion requise : Veuillez discuter brièvement des résultats obtenus dans cette section.

Après le dématriçage et la balance des blancs, vous avez une image RGB linéaire en espace XYZ. Cependant, cette image n'est pas encore prête à être affichée — elle nécessite un mappage tonal pour compresser la plage dynamique et un encodage de fonction de transfert pour un affichage correct.

A) Ajustement de luminosité

Avant de commencer le mappage tonal, appliquez un ajustement de luminosité à votre image. Implémentez votre algorithme dans adjust_brightness pour régler la luminosité de l'image. Utilisez l'algorithme de votre choix, par exemple mesurez le 99e percentile d'intensité de l'image, et divisez l'image par cette valeur.

B) Mappage tonal global

Implémentez les opérateurs globaux suivants :

1. Linéaire (tonemap_linear()):

Aucune courbe n'est appliquée: $L_{out} = L_{in}$.

2. Opérateur global de Reinhard (de "Photographic Tone Reproduction for Digital Images", (tonemap_reinhard())) :

$L_{out} = \frac{L_{in}}{1 + L_{in}}$

Cette formule simple compresse naturellement les hautes lumières tout en préservant les détails dans les ombres.

Traitez vos propres images à travers votre pipeline complet. La plupart des smartphones sont maintenant capables de photographier en DNG. Si vous n'êtes pas sûr de comment faire, vous pouvez utiliser l'application gratuite Lightroom tel qu'expliqué dans ce document.

• Capturez au moins 3 scènes différentes avec des conditions d'éclairage variées
• Documentez les détailsde votre appareil/capteur
• Montrez des comparaisons avant/après complètes à travers votre pipeline

Reading DNG Files

DNG (Digital Negative) is Adobe's open RAW format. Your first task is to load the raw sensor data from a DNG file. The starter code implements this entire section for you in the process_dng_files() function.

What is extracted from the DNG file:

• The Bayer pattern arrangement (RGGB, BGGR, GRBG, or GBRG); Be careful, each image may have a different arrangement!
• The bit depth of the sensor (typically 12-14 bits)
• Black level (black level) and white level (white level) values
• Any available white balance multipliers stored in metadata

Required Normalization:

The raw data is normalized to floating-point values in [0, 1] range, accounting for black level subtraction:

normalized = (raw_value - black_level) / (white_level - black_level)

These values are available in the DNG file metadata. With rawpy, these values are available in the black_level_per_channel and camera_white_level_per_channel attributes.

The image is saved as a 16-bit TIFF, and the RGB-XYZ matrix (rgb_xyz_matrix), color_matrix (color_matrix), and camera_whitebalance (camera_whitebalance) are saved in a metadata file in JSON format.

Required Discussion: Please discuss briefly the results obtained in this section.

Demosaicking (also called debayering) reconstructs the full RGB image from the single-channel Bayer mosaic. Since each pixel only records one color, the other two must be interpolated from neighboring pixels.

Take the output from Section 1 and apply the following algorithms to it.

A) Bilinear Interpolation 5%

In demosaic_bilinear(), interpolate missing color values using the average of neighboring pixels of the same color. For example, to find the red value at a blue pixel, average the four diagonal red neighbors. Implement your code in

B) Malvar-He-Cutler (2004) Method 25% (GIF-4105) 20% (GIF-7105)

This gradient-corrected interpolation improves upon bilinear by using edge information. Implement in demosaic_malvar the algorithm as described in:

• Malvar, He, and Cutler, "High-Quality Linear Interpolation for Demosaicing of Bayer-Patterned Color Images," ICASSP 2004
• Reference: Malvar He Cutler 2004

Implement the interpolation weights described in Fig. 2 of the reference.

RAW images capture the actual color of light hitting the sensor, which varies dramatically based on the illumination source. White balancing adjusts the RGB channels so that neutral objects appear neutral in the final image.

Apply this white balance to the image produced by one of the algorithms from the previous section of your choice. We recommend using Malvar-He-Cutler.

A) Automatic Neutral Region Selection 10%

Implement an algorithm that automatically finds a "neutral" region in the image. The idea is to search for regions that are both bright and neutral (low standard deviation between R, G, B channels). Implement your algorithm in find_neutral_region().

Suggested algorithm:

1. Scan the image at regular intervals (e.g., every 20 pixels)
2. For each region of fixed size (e.g., 11×11 pixels), compute:
   • Average brightness: brightness = 0.299×R + 0.587×G + 0.114×B
   • Neutrality score: neutrality = 1 / (1 + std(R, G, B) × 10)
   • Combined score: score = brightness × neutrality
3. Keep the region with the best score (if brightness > 0.2)
4. Use this region to compute the correction multipliers:
   • multiplier_R = target_grey / average_R_in_region
   • multiplier_G = target_grey / average_G_in_region
   • multiplier_B = target_grey / average_B_in_region

Apply these multipliers to the entire image in white_balance_auto_neutral().

B) Grey World Algorithm 10%

Implement automatic white balance based on the grey world assumption: the average color of a scene should be neutral grey. Implement your algorithm in white_balance_grey_world().

• Compute the mean of each channel across the entire image
• Scale each channel so that all means are equal (typically to the green channel mean)

C) White Balance proposed by the camera

The camera may propose an automatic white balance based on the image metadata. Use this value (camera_whitebalance in rawpy) to apply an automatic white balance. Note: The provided starter code already implements this functionality in white_balance_camera().

• Multiply the first 3 values of camera_whitebalance by each channel of the image to apply an automatic white balance.

Post-processing

The output of this step should be in XYZ color space. To do this, take your output values from A), B), and C) and multiply them by the RGB-XYZ matrix (rgb_xyz_matrix) to obtain the output in XYZ color space. The starter code implements this functionality in camera_rgb_to_xyz().

Note on color spaces: After demosaicking, the color space is "camera RGB", which is not a standard space. The manufacturer provides the conversion matrix to XYZ, and then we can convert to whatever we want (sRGB in this case).

Required Discussion: Please discuss briefly the results obtained in this section.

After demosaicking and white balancing, you have a linear RGB image in XYZ color space. However, this image is not yet ready to be displayed—it needs tone mapping to compress the dynamic range and transfer function encoding for proper display.

A) Brightness Adjustment

Before starting tone mapping, apply a brightness adjustment to your image. This allows you to set the image brightness correctly. Use an algorithm of your choice, for example measure the 99th percentile of image intensity, and divide the image by this value. Implement your algorithm in adjust_brightness().

B) Global Tone Mapping

Implement the following global operators:

1. Linear (tonemap_linear()):

No curve is applied: $L_{out} = L_{in}$.

2. Reinhard Global Operator (from "Photographic Tone Reproduction for Digital Images", tonemap_reinhard()):

$L_{out} = \frac{L_{in}}{1 + L_{in}}$

This simple formula naturally compresses highlights while preserving shadow detail.

Process your own images through your complete pipeline. Most cellphones are now capable of shooting DNG. If you're unsure about how to do this, you can use the free Lightroom application as explained in this document.

Capture your own RAW photos and process them:

• Capture at least 3 different scenes with varying lighting conditions
• Document the details of your camera/sensor
• Show complete before/after comparisons through your pipeline