rawpy

Warnings

• breaking macOS Intel support was removed in v0.26.0. Users on macOS with Intel CPUs will not be able to install or use rawpy versions 0.26.0 and later.
  Fix: Use rawpy v0.25.x or earlier on macOS Intel, or migrate to a different architecture (e.g., Apple Silicon) or operating system.
• breaking As of v0.23.0, rawpy will now raise an error for corrupt or malformed RAW files instead of silently returning garbage data. This improves robustness but may require updating existing code that implicitly handled such cases.
  Fix: Implement explicit try-except blocks (e.g., for `rawpy.LibRawError` or `rawpy.LibRawFileUnsupportedError`) around file opening and processing to handle corrupted or unsupported RAW files gracefully.
• breaking Python 3.8 support was dropped in v0.22.0. Users on Python 3.8 must upgrade their Python version to continue using recent rawpy releases.
  Fix: Upgrade to Python 3.9 or newer.
• breaking Numpy 2.x support was added in v0.22.0, but older numpy versions are no longer supported. Ensure your numpy installation is compatible with rawpy.
  Fix: Upgrade numpy to a compatible version (e.g., `pip install --upgrade numpy`). Check rawpy's documentation for specific minimum numpy versions for your Python version.
• gotcha On Linux, `rawpy` requires the `LibRaw` library to be installed system-wide. Binary wheels for `rawpy` do not bundle `LibRaw` on Linux. Installation instructions for `LibRaw` vary by distribution.
  Fix: Install `libraw-dev` (or equivalent) via your system's package manager (e.g., `sudo apt-get install libraw-dev` on Ubuntu) or compile `LibRaw` from source before installing `rawpy`.
• gotcha Attempting to open a non-RAW file, a corrupted file, or a RAW file with an unsupported format/camera model will raise a `rawpy.LibRawFileUnsupportedError`.
  Fix: Verify the input file is a genuine, uncorrupted RAW image from a supported camera model. Use a `try-except` block to catch `rawpy.LibRawFileUnsupportedError` and handle unsupported files gracefully.
• gotcha When using Python's `multiprocessing` module on Linux, deadlocks can occur due to an interaction between OpenMP (used in rawpy's Linux wheels) and the default `fork` start method.
  Fix: Change the multiprocessing start method to 'spawn' or 'forkserver' (e.g., `multiprocessing.set_start_method('spawn')`) before creating any `multiprocessing.Process` objects or pools.

Install

• pip install rawpy Install stable version
• pip install --pre rawpy Install pre-release version

Imports

• rawpy

  import rawpy

• rawpy.enhance

  import rawpy.enhance

  For advanced features like bad pixel detection and repair.

Quickstart

This quickstart demonstrates how to load a RAW image, postprocess it using default settings, and save the resulting RGB image as a TIFF file. It also shows an example of saving a 16-bit linear image. It uses `imageio` for saving the output, which needs to be installed separately. The code includes basic error handling for unsupported RAW files and uses a dummy file for execution without requiring an actual RAW image upfront.

import rawpy
import imageio.v3 as iio
import os

# Create a dummy RAW file for demonstration (replace with your .CR2, .NEF, etc.)
# In a real scenario, you would have an actual RAW image file.
dummy_raw_content = b'\x00' * 1024 # Not a real RAW, but allows the code to run without file not found
dummy_raw_filename = 'dummy.nef'
with open(dummy_raw_filename, 'wb') as f:
    f.write(dummy_raw_content)

path = dummy_raw_filename

try:
    # Load a RAW file using the context manager for resource safety
    with rawpy.imread(path) as raw:
        # Postprocess the RAW image to an RGB NumPy array
        # Uses default parameters for demosaicing, white balance, etc.
        rgb = raw.postprocess()

        # Save the postprocessed image using imageio (requires 'imageio' installed)
        output_filename = 'default.tiff'
        iio.imwrite(output_filename, rgb)
        print(f"Image saved to {output_filename}")

        # Example: Save as 16-bit linear image
        rgb_16bit = raw.postprocess(gamma=(1,1), no_auto_bright=True, output_bps=16)
        output_filename_16bit = 'linear.tiff'
        iio.imwrite(output_filename_16bit, rgb_16bit)
        print(f"16-bit linear image saved to {output_filename_16bit}")

except rawpy.LibRawFileUnsupportedError:
    print(f"Error: '{path}' is not a supported RAW file format, or it's corrupted/incomplete.")
except Exception as e:
    print(f"An unexpected error occurred: {e}")
finally:
    # Clean up dummy file
    if os.path.exists(dummy_raw_filename):
        os.remove(dummy_raw_filename)