Raw images are the image format of choice for most serious professional or enthusiast photographers as this format provides the optimal base material for further processing, e.g., tonal adjustments, color grading and all kinds of geometric and lens corrections. Yet, dealing with raw files can be cumbersome. Each camera manufacturer uses its own proprietary raw file format for his cameras. Raw files cannot be displayed directly, the must be processed first. Therefore raw files are sometimes called digital negatives. Raw processing is usually carried out by specialized programs such as darktable<\/a> or RawTherapee<\/a>.<\/p>\n The Python packages rawpy<\/a>, PIL (aka Pillow<\/a>) and exifread<\/a> allow to perform various tasks of raw image processing in Python. This is particularly useful for batch processing and prototyping of new image processing algorithms. In the following a few demonstrative examples are shown how to use rawpy, PIL and exifread.<\/p>\n Load rawpy and some further useful Python packages first:<\/p>\n Read a raw image and extract some basic information about the image:<\/p>\n Extract and print EXIF meta-data of the raw file:<\/p>\n The embedded thumbnail image is extracted from a raw file next. The thumbnail is saved to disk and displayed. (Note that some raw formats have unusual bitmap thumbnails which may not be read correctly or not read at all.)<\/p>\n The next example shows how to process a raw image via rawpy to create an image that is suitable for display. Camera white balance settings are used.<\/p>\n A raw image is not suitable for display. The function [codesyntax\u00a0lang=”text”]<\/p>\n \u00a0<\/p>\n sensor. The fundamental element of a Bayer-sensor pattern consists of 2 times 2 pixels of 3 or of 4 different colors. The following steps are required to convert Bayer pixel data into RGB pixels:<\/p>\n The end result of this procedure is usable but looks rather dull and is lacking contrast. This can be fixed by further processing steps, e.g., the application of an S-shaped tone curve<\/a>.<\/p>\n A Jupyter notebook version of this blog post is available on GitHub<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"import os\nfrom io import BytesIO\nimport matplotlib.pyplot as plt\nimport rawpy\nimport exifread\nimport numpy as np\nfrom PIL import Image\n<\/pre>\n<\/div>\n
raw_filename = 'A1_07396.arw'\n \nwith rawpy.imread(raw_filename) as raw:\n print(f'raw type: {raw.raw_type}') # raw type (flat or stack, e.g., Foveon sensor)\n print(f'number of colors: {raw.num_colors}') # number of different color components, e.g., 3 for common RGB Bayer sensors with two green identical green sensors \n print(f'color description: {raw.color_desc}') # describes the various color components\n print(f'raw pattern: {raw.raw_pattern.tolist()}') # decribes the pattern of the Bayer sensor\n print(f'black levels: {raw.black_level_per_channel}') # black level correction\n print(f'white level: {raw.white_level}') # camera white level\n print(f'color matrix: {raw.color_matrix.tolist()}') # camera specific color matrix, usually obtained from a list in rawpy (not from the raw file)\n print(f'XYZ to RGB conversion matrix: {raw.rgb_xyz_matrix.tolist()}') # camera specific XYZ to camara RGB conversion matrix\n print(f'camera white balance: {raw.camera_whitebalance}') # the picture's white balance as determined by the camera\n print(f'daylight white balance: {raw.daylight_whitebalance}') # the camera's daylight white balance\n<\/pre>\nraw type: RawType.Flat\nnumber of colors: 3\ncolor description: b'RGBG'\nraw pattern: [[0, 1], [3, 2]]\nblack levels: [512, 512, 512, 512]\nwhite level: 16383\ncolor matrix: [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]\nXYZ to RGB conversion matrix: [[0.5972999930381775, -0.16949999332427979, -0.04190000146627426], [-0.38260000944137573, 1.1797000169754028, 0.22930000722408295], [-0.06390000134706497, 0.13979999721050262, 0.5788999795913696], [0.0, 0.0, 0.0]]\ncamera white balance: [2452.0, 1024.0, 2036.0, 1024.0]\ndaylight white balance: [2.836125135421753, 0.9383336305618286, 1.409664511680603, 0.0]\n<\/pre>\n
with open(raw_filename, 'rb') as f:\n tags = exifread.process_file(f)\n for key, value in tags.items():\n if key is not 'JPEGThumbnail': # do not print (uninteresting) binary thumbnail data\n print(f'{key}: {value}')\n<\/pre>\nImage SubfileType: Reduced-resolution image\nImage Compression: JPEG (old-style)\nImage ImageDescription: \nImage Make: SONY\nImage Model: ILCE-6300\nImage Orientation: Horizontal (normal)\nImage XResolution: 350\nImage YResolution: 350\nImage ResolutionUnit: Pixels\/Inch\nImage Software: ILCE-6300 v2.01\nImage DateTime: 2019:02:24 12:56:34\nImage Artist: Heiko Bauke\nImage Tag 0x014A: 145554\nImage JPEGInterchangeFormat: 146594\nImage JPEGInterchangeFormatLength: 454075\nImage YCbCrPositioning: Co-sited\nImage Copyright: Heiko Bauke\nImage ExifOffset: 484\nImage PrintIM: [80, 114, 105, 110, 116, 73, 77, 0, 48, 51, 48, 48, 0, 0, 3, 0, 2, 0, 1, 0, ... ]\nImage Tag 0xC634: [156, 201, 0, 0]\nThumbnail SubfileType: Reduced-resolution image\nThumbnail Compression: JPEG (old-style)\nThumbnail ImageDescription: \nThumbnail Make: SONY\nThumbnail Model: ILCE-6300\nThumbnail Orientation: Horizontal (normal)\nThumbnail XResolution: 72\nThumbnail YResolution: 72\nThumbnail ResolutionUnit: Pixels\/Inch\nThumbnail Software: ILCE-6300 v2.01\nThumbnail DateTime: 2019:02:24 12:56:34\nThumbnail Artist: Heiko Bauke\nThumbnail JPEGInterchangeFormat: 38906\nThumbnail JPEGInterchangeFormatLength: 11192\nThumbnail YCbCrPositioning: Co-sited\nThumbnail Copyright: Heiko Bauke\nEXIF ExposureTime: 1\/2500\nEXIF FNumber: 14\/5
EXIF ExposureProgram: Aperture Priority\nEXIF ISOSpeedRatings: 200\nEXIF SensitivityType: Recommended Exposure Index\nEXIF RecommendedExposureIndex: 200\nEXIF ExifVersion: 0230\nEXIF DateTimeOriginal: 2019:02:24 12:56:34\nEXIF DateTimeDigitized: 2019:02:24 12:56:34\nEXIF ComponentsConfiguration: YCbCr\nEXIF CompressedBitsPerPixel: 8\nEXIF BrightnessValue: 6547\/1280\nEXIF ExposureBiasValue: 0\nEXIF MaxApertureValue: 0\nEXIF MeteringMode: Pattern\nEXIF LightSource: Unknown\nEXIF Flash: Flash did not fire, compulsory flash mode\nEXIF FocalLength: 55\nEXIF MakerNote: [95, 0, 3, 16, 4, 0, 16, 0, 0, 0, 136, 8, 0, 0, 0, 32, 7, 0, 1, 0, ... ]\nEXIF UserComment: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\nEXIF FlashPixVersion: 0100\nEXIF ColorSpace: sRGB\nEXIF ExifImageWidth: 6000\nEXIF ExifImageLength: 4000\nInteroperability InteroperabilityIndex: R98\nInteroperability InteroperabilityVersion: [48, 49, 48, 48]\nEXIF InteroperabilityOffset: 38554\nEXIF FileSource: Digital Camera\nEXIF SceneType: Directly Photographed\nEXIF CustomRendered: Normal\nEXIF ExposureMode: Auto Exposure\nEXIF WhiteBalance: Auto\nEXIF DigitalZoomRatio: 1\nEXIF FocalLengthIn35mmFilm: 82\nEXIF SceneCaptureType: Standard\nEXIF Contrast: Normal\nEXIF Saturation: Normal\nEXIF Sharpness: Normal\nEXIF LensModel: Nikon AI-S Nikkor 55mm f\/2.8 Micro\n<\/pre>\nfilename, _ = os.path.splitext(raw_filename)\nwith rawpy.imread(raw_filename) as raw:\n try:\n thumb = raw.extract_thumb()\n except rawpy.LibRawNoThumbnailError:\n print('no thumbnail found')\n else:\n if thumb.format in [rawpy.ThumbFormat.JPEG, rawpy.ThumbFormat.BITMAP]:\n if thumb.format is rawpy.ThumbFormat.JPEG:\n thumb_filename = filename + '_thumb.jpg'\n with open(thumb_filename, 'wb') as f:\n f.write(thumb.data)\n thumb_rgb = Image.open(BytesIO(thumb.data))\n else:\n thumb_filename = filename + '_thumb.tiff'\n thumb_rgb = Image.fromarray(thumb.data)\n thumb_rgb.save(filename, 'tiff')\n plt.imshow(thumb_rgb)\n plt.axis('off')\n else:\n print('unknown thumbnail format')\n<\/pre>\n![\"\"](\"https:\/\/www.numbercrunch.de\/blog\/wp-content\/uploads\/2020\/12\/rawpy_demo_1.png\")
<\/a><\/p>\nwith rawpy.imread(raw_filename) as raw:\n image = raw.raw_image\n rgb = raw.postprocess(rawpy.Params(use_camera_wb=True))\n plt.imshow(rgb)\n plt.axis('off')\n<\/pre>\n![\"\"](\"https:\/\/www.numbercrunch.de\/blog\/wp-content\/uploads\/2020\/12\/rawpy_demo_2.png\")
<\/a><\/p>\npostprocess<\/code> was utilized before to turn a raw image into an image that can be displayed. In the following, a minimalistic raw conversion into sRGB is performed that yields an image that is suitable for display. The employed procedure is rather general, but it assumes that the camera features a Bayer-pattern<\/p>\n\u00a0<\/pre>\n
\n
with rawpy.imread(raw_filename) as raw:\n # get raw image data\n image = np.array(raw.raw_image, dtype=np.double)\n # subtract black levels and normalize to interval [0..1]\n black = np.reshape(np.array(raw.black_level_per_channel, dtype=np.double), (2, 2))\n black = np.tile(black, (image.shape[0]\/\/2, image.shape[1]\/\/2))\n image = (image - black) \/ (raw.white_level - black)\n # find the positions of the three (red, green and blue) or four base colors within the Bayer pattern\n n_colors = raw.num_colors\n colors = np.frombuffer(raw.color_desc, dtype=np.byte)\n pattern = np.array(raw.raw_pattern)\n index_0 = np.where(colors[pattern] == colors[0])\n index_1 = np.where(colors[pattern] == colors[1])\n index_2 = np.where(colors[pattern] == colors[2])\n index_3 = np.where(colors[pattern] == colors[3])\n # apply white balance, normalize white balance coefficients to the 2nd coefficient, which is ususally the coefficient for green\n wb_c = raw.camera_whitebalance \n wb = np.zeros((2, 2), dtype=np.double) \n wb[index_0] = wb_c[0] \/ wb_c[1]\n wb[index_1] = wb_c[1] \/ wb_c[1]\n wb[index_2] = wb_c[2] \/ wb_c[1]\n if n_colors == 4:\n wb[index_3] = wb_c[3] \/ wb_c[1]\n wb = np.tile(wb, (image.shape[0]\/\/2, image.shape[1]\/\/2))\n image_wb = np.clip(image * wb, 0, 1)\n # demosaic via downsampling\n image_demosaiced = np.empty((image_wb.shape[0]\/\/2, image_wb.shape[1]\/\/2, n_colors))\n if n_colors == 3:\n image_demosaiced[:, :, 0] = image_wb[index_0[0][0]::2, index_0[1][0]::2]\n image_demosaiced[:, :, 1] = (image_wb[index_1[0][0]::2, index_1[1][0]::2] + image_wb[index_1[0][1]::2, index_1[1][1]::2]) \/ 2\n image_demosaiced[:, :, 2] = image_wb[index_2[0][0]::2, index_2[1][0]::2]\n else: # n_colors == 4\n image_demosaiced[:, :, 0] = image_wb[index_0[0][0]::2, index_0[1][0]::2]\n image_demosaiced[:, :, 1] = image_wb[index_1[0][0]::2, index_1[1][0]::2]\n image_demosaiced[:, :, 2] = image_wb[index_2[0][0]::2, index_2[1][0]::2]\n image_demosaiced[:, :, 3] = image_wb[index_3[0][0]::2, index_3[1][0]::2]\n # convert to linear sRGB, calculate the matrix that transforms sRGB into the camera's primary color components and invert this matrix to perform the inverse transformation\n XYZ_to_cam = np.array(raw.rgb_xyz_matrix[0:n_colors, :], dtype=np.double)\n sRGB_to_XYZ = np.array([[0.4124564, 0.3575761, 0.1804375],\n [0.2126729, 0.7151522, 0.0721750],\n [0.0193339, 0.1191920, 0.9503041]], dtype=np.double)\n sRGB_to_cam = np.dot(XYZ_to_cam, sRGB_to_XYZ)\n norm = np.tile(np.sum(sRGB_to_cam, 1), (3, 1)).transpose()\n sRGB_to_cam = sRGB_to_cam \/ norm\n if n_colors == 3:\n cam_to_sRGB = np.linalg.inv(sRGB_to_cam)\n else: # n_colors == 4\n cam_to_sRGB = np.linalg.pinv(sRGB_to_cam)\n image_sRGB = np.einsum('ij,...j', cam_to_sRGB, image_demosaiced) # performs the matrix-vector product for each pixel\n # apply sRGB gamma curve\n i = image_sRGB < 0.0031308\n j = np.logical_not(i)\n image_sRGB[i] = 323 \/ 25 * image_sRGB[i]\n image_sRGB[j] = 211 \/ 200 * image_sRGB[j] ** (5 \/ 12) - 11 \/ 200\n image_sRGB = np.clip(image_sRGB, 0, 1)\n # show image\n plt.axis('off')\n plt.imshow(image_sRGB)\n<\/pre>\n![\"\"](\"https:\/\/www.numbercrunch.de\/blog\/wp-content\/uploads\/2020\/12\/rawpy_demo_3.png\")
<\/a><\/p>\n