Skip to content

Instantly share code, notes, and snippets.

@stollcri

stollcri/c41

Last active Jun 16, 2021
Embed
What would you like to do?
A Python script to develop scans of C-41 film negatives into color-corrected positive images
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import argparse
import logging
import math
import os
import statistics
import sys
from argparse import RawTextHelpFormatter
from halo import Halo
from wand.api import library
from wand.color import Color
from wand.compat import nested
from wand.image import Image
BLACK_POINT_PRESETS = {
"lomography-color-tiger": {
"exposure_gamma_correction": 1.0,
"r_shift": 379.4375,
"g_shift": 13485.75390625,
"b_shift": 32497.3515625,
"is_black_and_white": False,
"shift_color_channels": True,
},
"kodak-portra-800": {
"exposure_gamma_correction": 1.0,
"r_shift": 6156.09765625,
"g_shift": 27330.96875,
"b_shift": 46130.76953125,
"is_black_and_white": False,
"shift_color_channels": False,
}
}
class Film(object):
def __init__(
self,
negative,
positive,
blackref_preset,
blackref,
save_blackref,
border_size,
ignore_border_left,
ignore_border_right,
ignore_border_top,
ignore_border_bottom,
contrast,
save_jpeg,
save_flip,
save_flop,
shift_channels,
verbose,
):
self.negative = negative
self.positive = positive
self.blackref = blackref
self.save_blackref = save_blackref
self.border_size = border_size
self.use_left_border = not ignore_border_left
self.use_right_border = not ignore_border_right
self.use_top_border = not ignore_border_top
self.use_bottom_border = not ignore_border_bottom
self.contrast = contrast
self.save_jpeg = save_jpeg
self.save_flip = save_flip
self.save_flop = save_flop
self.shift_color_channels = shift_channels
if self.save_jpeg:
positive_no_extension = os.path.splitext(self.positive)[0]
self.positive = f"{positive_no_extension}.jpg"
if (
(not self.use_left_border)
and (not self.use_right_border)
and (not self.use_top_border)
and (not self.use_bottom_border)
):
self.use_left_border = True
self.use_right_border = True
self.use_top_border = True
self.use_bottom_border = True
self.temp_blackref_image = "_blackref.jpg"
self.image_channel = "gray"
self.exposure_gamma_correction = 1.0
self.r_shift = 0.0
self.g_shift = 0.0
self.b_shift = 0.0
if verbose:
logging.basicConfig(format="%(message)s", level=logging.INFO)
else:
logging.basicConfig(format="%(message)s", level=logging.WARNING)
self.color_stdev = None
self.black_color = None
self.is_black_and_white = False
self.black_point_preset = blackref_preset
def copy_into(self, source_image, l, t, r, b, target_image, x, y):
with Image(source_image) as source_image_copy:
source_image_copy.crop(l, t, r, b)
target_image.composite_channel(
"default_channels",
source_image_copy,
"over",
x,
y,
)
target_image.merge_layers("flatten")
return target_image
def move_kernel(self, image_size, source_image, l, t, r, b, target_image, x, y):
if y >= image_size:
raise ValueError
target_image = self.copy_into(source_image, l, t, r, b, target_image, x, y)
if x >= (image_size - self.border_size):
y += self.border_size
x = 0
else:
x += self.border_size
return l, t, r, b, target_image, x, y
def create_black_reference(self):
with Image(filename=self.negative, resolution=300) as negative_image_container:
with Image(negative_image_container.sequence[0]) as negative_image:
use_sides_count = 0
if self.use_left_border:
use_sides_count += 1
if self.use_right_border:
use_sides_count += 1
use_topbot_count = 0
if self.use_top_border:
use_topbot_count += 1
if self.use_bottom_border:
use_topbot_count += 1
w, h = negative_image.size
square_count = (math.floor(w / self.border_size) * use_topbot_count) + (
(math.floor(h / self.border_size) - 2) * use_sides_count
)
image_size = int(math.sqrt(square_count)) * self.border_size
with Image(width=image_size, height=image_size) as new_image:
negative_image_left = 0
negative_image_top = 0
negative_image_right = negative_image_left + self.border_size
negative_image_bottom = negative_image_top + self.border_size
new_image_col = 0
new_image_row = 0
if self.use_top_border:
for idx in range(0, (w - self.border_size), self.border_size):
negative_image_left = idx
negative_image_top = 0
negative_image_right = (
negative_image_left + self.border_size
)
negative_image_bottom = (
negative_image_top + self.border_size
)
try:
(
negative_image_left,
negative_image_top,
negative_image_right,
negative_image_bottom,
new_image,
new_image_col,
new_image_row,
) = self.move_kernel(
image_size,
negative_image,
negative_image_left,
negative_image_top,
negative_image_right,
negative_image_bottom,
new_image,
new_image_col,
new_image_row,
)
except ValueError:
break
if self.use_left_border:
for idx in range(
self.border_size, (h - self.border_size), self.border_size
):
negative_image_left = 0
negative_image_top = idx
negative_image_right = (
negative_image_left + self.border_size
)
negative_image_bottom = (
negative_image_top + self.border_size
)
try:
(
negative_image_left,
negative_image_top,
negative_image_right,
negative_image_bottom,
new_image,
new_image_col,
new_image_row,
) = self.move_kernel(
image_size,
negative_image,
negative_image_left,
negative_image_top,
negative_image_right,
negative_image_bottom,
new_image,
new_image_col,
new_image_row,
)
except ValueError:
break
if self.use_right_border:
for idx in range(
self.border_size, (h - self.border_size), self.border_size
):
negative_image_left = w - self.border_size
negative_image_top = idx
negative_image_right = (
negative_image_left + self.border_size
)
negative_image_bottom = (
negative_image_top + self.border_size
)
try:
(
negative_image_left,
negative_image_top,
negative_image_right,
negative_image_bottom,
new_image,
new_image_col,
new_image_row,
) = self.move_kernel(
image_size,
negative_image,
negative_image_left,
negative_image_top,
negative_image_right,
negative_image_bottom,
new_image,
new_image_col,
new_image_row,
)
except ValueError as e:
break
if self.use_bottom_border:
for idx in range(0, w, self.border_size):
negative_image_left = idx
negative_image_top = h - self.border_size
negative_image_right = (
negative_image_left + self.border_size
)
negative_image_bottom = (
negative_image_top + self.border_size
)
try:
(
negative_image_left,
negative_image_top,
negative_image_right,
negative_image_bottom,
new_image,
new_image_col,
new_image_row,
) = self.move_kernel(
image_size,
negative_image,
negative_image_left,
negative_image_top,
negative_image_right,
negative_image_bottom,
new_image,
new_image_col,
new_image_row,
)
except ValueError:
break
new_image.save(filename=self.temp_blackref_image)
return self.temp_blackref_image
def calculate_gamma_correction(self, blackref_image):
img_minima, img_maxima = blackref_image.range_channel(self.image_channel)
img_maxima = img_maxima / blackref_image.quantum_range
img_mean, img_stdev = blackref_image.mean_channel(self.image_channel)
exposure_mid = img_mean / (blackref_image.quantum_range * 2)
exposure_gamma_correction = math.log(img_maxima - exposure_mid) / math.log(
exposure_mid
)
if img_maxima >= 1:
logging.warning("Negative seems to be overexposed")
return exposure_gamma_correction
def calculate_shift(self, blackref_image, channel):
img_minima, img_maxima = blackref_image.range_channel(channel)
return img_minima
def calculate_rgb_shifts(self, blackref_image):
blackref_image.gamma(self.exposure_gamma_correction)
blackref_image.negate()
r_shift = self.calculate_shift(blackref_image, "red")
g_shift = self.calculate_shift(blackref_image, "green")
b_shift = self.calculate_shift(blackref_image, "blue")
return r_shift, g_shift, b_shift
def check_black_and_white(self, blackref_image):
if blackref_image.colorspace == "gray":
return True
blackref_image.resize(1, 1)
color = blackref_image[0, 0]
self.color_stdev = statistics.stdev(
[
color.red / (color.red + color.green + color.blue),
color.green / (color.red + color.green + color.blue),
color.blue / (color.red + color.green + color.blue),
]
)
# # finding std.dev of all grey-looking colors, so we know what the cutoff should be
# # from: http://www.imagemagick.org/script/color.php
# for color_name in ['snow', 'snow1', 'snow2', 'snow3', 'snow4', 'LavenderBlush3', 'LavenderBlush4', 'thistle', 'thistle3', 'thistle4', 'lavender', 'LightSteelBlue', 'SlateGray1', 'SlateGray4', 'LightSlateGrey', 'SlateGrey', 'AliceBlue', 'honeydew', 'honeydew1', 'honeydew2', 'honeydew3']:
# color = Color(color_name)
# color_stdev = statistics.stdev(
# [
# color.red / (color.red + color.green + color.blue),
# color.green / (color.red + color.green + color.blue),
# color.blue / (color.red + color.green + color.blue),
# ]
# )
# print(f"{color_name} = {color_stdev}")
if self.color_stdev < 0.05:
return True
return False
def analyze_black_reference(self):
with Image(filename=self.blackref) as blackref_image:
if blackref_image.colorspace not in ["srgb", "gray"]:
logging.warning(
f" Colorspace '{blackref_image.colorspace}' is neither srgb nor gray"
)
self.is_black_and_white = self.check_black_and_white(blackref_image)
if not self.is_black_and_white:
# set any black or white pixels to transparent
with nested(Color('white'), Color('transparent')) as (target, fill):
library.MagickOpaquePaintImage(blackref_image.wand,
target.resource,
fill.resource,
blackref_image.quantum_range * 0.10, # -fuzz 10%
False)
with nested(Color('black'), Color('transparent')) as (target, fill):
library.MagickOpaquePaintImage(blackref_image.wand,
target.resource,
fill.resource,
blackref_image.quantum_range * 0.10, # -fuzz 10%
False)
# average the colors
blackref_image.resize(1, 1)
# remove transparency caused by hiding black and white pixels
blackref_image.evaluate(operator='set', value=int(65535 * 1.0), channel='alpha')
self.black_color = blackref_image[0, 0]
self.exposure_gamma_correction = self.calculate_gamma_correction(
blackref_image
)
self.r_shift, self.g_shift, self.b_shift = self.calculate_rgb_shifts(
blackref_image
)
if self.is_black_and_white:
# shifting color channels for a black and white image
# makes no sense and in fact produces poor results
self.shift_color_channels = False
if not self.save_blackref:
os.remove(self.blackref)
def calculate_black_point(self, spinner):
if (
self.black_point_preset is not None
and self.black_point_preset in BLACK_POINT_PRESETS
):
logging.info(f"Using preset black point {self.black_point_preset}")
self.exposure_gamma_correction = BLACK_POINT_PRESETS[
self.black_point_preset
]["exposure_gamma_correction"]
self.r_shift = BLACK_POINT_PRESETS[self.black_point_preset]["r_shift"]
self.g_shift = BLACK_POINT_PRESETS[self.black_point_preset]["g_shift"]
self.b_shift = BLACK_POINT_PRESETS[self.black_point_preset]["b_shift"]
self.is_black_and_white = BLACK_POINT_PRESETS[self.black_point_preset][
"is_black_and_white"
]
self.shift_color_channels = BLACK_POINT_PRESETS[self.black_point_preset][
"shift_color_channels"
]
else:
if self.blackref is None:
sides_used = []
if self.use_left_border:
sides_used.append('left')
if self.use_right_border:
sides_used.append('right')
if self.use_top_border:
sides_used.append('top')
if self.use_bottom_border:
sides_used.append('bottom')
using_sides = ', '.join(sides_used)
logging.info(f" Using sides {using_sides}")
spinner.start("Creating black point reference")
self.blackref = self.create_black_reference()
spinner.succeed("Black point reference created")
spinner.start("Analyzing black point reference")
self.analyze_black_reference()
spinner.succeed("Black point analysis complete")
logging.info(f" · black color {self.black_color}")
logging.info(f" · red {self.black_color.red}")
logging.info(f" · green {self.black_color.green}")
logging.info(f" · blue {self.black_color.blue}")
logging.info(f" · std.dev {self.color_stdev}")
logging.info(f" · exposure gamma correction {self.exposure_gamma_correction}")
logging.info(f" · red shift {self.r_shift}")
logging.info(f" · green shift {self.g_shift}")
logging.info(f" · blue shift {self.b_shift}")
logging.info(f" · black and white {self.is_black_and_white}")
logging.info(f" · shift color channels {self.shift_color_channels}")
def calculate_color_gammas(self, negative_image):
with Image(negative_image) as negative_image_copy:
negative_image_copy.resize(1, 1)
img_minima_r, img_maxima_r = negative_image_copy.range_channel("red")
img_minima_g, img_maxima_g = negative_image_copy.range_channel("green")
img_minima_b, img_maxima_b = negative_image_copy.range_channel("blue")
img_maxima_r = img_maxima_r / negative_image_copy.quantum_range
img_maxima_g = img_maxima_g / negative_image_copy.quantum_range
img_maxima_b = img_maxima_b / negative_image_copy.quantum_range
gamma_g = 0
if img_maxima_g > 0:
gamma_g = math.log(1 / img_maxima_g) / math.log(1 / img_maxima_r)
gamma_b = 0
if img_maxima_b > 0:
gamma_b = math.log(1 / img_maxima_b) / math.log(1 / img_maxima_r)
return gamma_g, gamma_b
def calculate_color_factors(self, negative_image):
with Image(negative_image) as negative_image_copy:
negative_image_copy.resize(1, 1)
img_minima_r, img_maxima_r = negative_image_copy.range_channel("red")
img_minima_g, img_maxima_g = negative_image_copy.range_channel("green")
img_minima_b, img_maxima_b = negative_image_copy.range_channel("blue")
img_maxima_r = img_maxima_r / negative_image_copy.quantum_range
img_maxima_g = img_maxima_g / negative_image_copy.quantum_range
img_maxima_b = img_maxima_b / negative_image_copy.quantum_range
factor_g = 0
if img_maxima_g > 0:
factor_g = math.log(img_maxima_g) / math.log(img_maxima_r)
factor_b = 0
if img_maxima_b > 0:
factor_b = math.log(img_maxima_b) / math.log(img_maxima_r)
return factor_g, factor_b
def adjust_and_save_negative(self):
with Image(filename=self.negative, resolution=300) as negative_image_container:
with Image(negative_image_container.sequence[0]) as negative_image:
if not self.is_black_and_white:
# remove black and white pixels
# for color negatives, these are scanning artifacts
with nested(Color('white'), self.black_color) as (target, fill):
library.MagickOpaquePaintImage(negative_image.wand,
target.resource,
fill.resource,
negative_image.quantum_range * 0.10, # -fuzz 10%
False)
with nested(Color('black'), self.black_color) as (target, fill):
library.MagickOpaquePaintImage(negative_image.wand,
target.resource,
fill.resource,
negative_image.quantum_range * 0.10, # -fuzz 10%
False)
negative_image.gamma(self.exposure_gamma_correction)
negative_image.negate()
if self.shift_color_channels:
negative_image.evaluate(
operator="subtract", value=self.r_shift, channel="red"
)
negative_image.normalize(channel="red")
if self.shift_color_channels:
negative_image.evaluate(
operator="subtract", value=self.g_shift, channel="green"
)
negative_image.normalize(channel="green")
if self.shift_color_channels:
negative_image.evaluate(
operator="subtract", value=self.b_shift, channel="blue"
)
negative_image.normalize(channel="blue")
negative_image.evaluate(operator="multiply", value=0.99)
negative_image.evaluate(operator="add", value=100)
gamma_g, gamma_b = self.calculate_color_gammas(negative_image)
negative_image.gamma(gamma_g, channel="green")
negative_image.gamma(gamma_b, channel="blue")
negative_image.gamma(self.contrast)
negative_image.negate()
negative_image.gamma(self.contrast)
negative_image.negate()
factor_g, factor_b = self.calculate_color_factors(negative_image)
negative_image.gamma(factor_g, channel="green")
negative_image.gamma(factor_b, channel="blue")
img_minima, img_maxima = negative_image.range_channel(
self.image_channel
)
img_mean, img_stdev = negative_image.mean_channel(self.image_channel)
final_gamma = math.log(img_maxima) / math.log(img_mean)
negative_image.gamma(final_gamma)
if self.save_flip:
negative_image.flip()
if self.save_flop:
negative_image.flop()
if self.is_black_and_white:
negative_image.type = "grayscale"
if self.save_jpeg:
negative_image.format = "jpeg"
negative_image.compression_quality = 100
negative_image.save(filename=self.positive)
def invert(self):
if os.path.isfile(self.negative):
try:
spinner = Halo(spinner="dots")
self.calculate_black_point(spinner)
spinner.start("Adjusting negative")
self.adjust_and_save_negative()
spinner.succeed("Positive saved")
except Exception as e:
logging.error(f" ERROR: {e}")
else:
logging.error(f"File does not exist: {self.negative}")
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description="Convert image of a film negative to positive\n\n"
+ " When automatically generating the black reference,\n"
+ " it is assumed that the negative is surrounded by a\n"
+ " narrow strip of unexposed film without sprocket holes,\n"
+ " so the negative should be cropped to look like this:\n"
+ "\n"
+ " +-----------------------------+\n"
+ " | frame border |\n"
+ " | +-------------------+ |\n"
+ " | | /\_ | |\n"
+ " | | _/\/ \ | |\n"
+ " | | __/ \_ \/\ | |\n"
+ " | |__/ \__/ \ | |\n"
+ " | | negative image \| |\n"
+ " | +-------------------+ |\n"
+ " | |\n"
+ " +-----------------------------+\n"
+ "\n"
+ " For certain negative types and/or scanning techniques,\n"
+ " exposing too much of the negative border or sprocket\n"
+ " holes can cause problems with the automatic adjustment\n"
+ " of the image. This script automatically adjusts exposure.\n"
+ " Excessive black pixels in the border region changes the\n"
+ " historgam,which can prevent setting proper exposure for\n"
+ " the actualframe of the image. Similar can happen with\n"
+ " the blank area of the sprocket holes.",
formatter_class=RawTextHelpFormatter,
)
parser.add_argument("negative", metavar="negative", help="negative image file")
parser.add_argument("positive", metavar="positive", help="positive image file")
parser.add_argument(
"--preset",
dest="black_reference_preset",
default=None,
help="use preset black reference information, options are: \n"
+ "\n".join([f" - {k}" for k in BLACK_POINT_PRESETS.keys()]),
)
parser.add_argument(
"--blackref",
dest="black_reference_image",
default=None,
help="use black reference image instead of the frame border,\n"
+ "useful if the frame is not completely surrounded by an\n"
+ "empty border (when there are sprocket holes or with\n"
+ "the first frame of the roll)",
)
parser.add_argument(
"--border-size",
dest="border_size",
type=int,
default=13,
help="size of frame border, default = 13\n"
+ "(when automatically generating black reference image)",
)
parser.add_argument(
"--ignore-border-left",
dest="ignore_border_left",
action="store_true",
help="ignore the left border when generating black reference",
)
parser.add_argument(
"--ignore-border-right",
dest="ignore_border_right",
action="store_true",
help="ignore the right border when generating black reference",
)
parser.add_argument(
"--ignore-border-top",
dest="ignore_border_top",
action="store_true",
help="ignore the top border when generating black reference",
)
parser.add_argument(
"--ignore-border-bottom",
dest="ignore_border_bottom",
action="store_true",
help="ignore the bottom border when generating black reference",
)
parser.add_argument(
"--contrast",
dest="contrast",
type=float,
default=0.75,
help="final contrast adjustment, default = 0.75\n",
)
parser.add_argument(
"--jpeg",
dest="save_jpeg",
action="store_true",
help="force JPEG output, when input is not JPEG\n"
+ "also force quality to be 100%%, rather than same as input\n"
+ "(positive image file extension will be set to jpg)",
)
parser.add_argument(
"--flip",
dest="save_flip",
action="store_true",
help="flip final image vertically",
)
parser.add_argument(
"--flop",
dest="save_flop",
action="store_true",
help="flip final image horizontally",
)
parser.add_argument(
"--shift-color-channels",
dest="shift_color_channels",
action="store_true",
help="shift colors by channel to balance them\n",
)
parser.add_argument(
"--save-blackref",
dest="save_blackref",
action="store_true",
help="do not remove generated black reference image swatch\n"
+ "(when automatically generating black reference image)",
)
parser.add_argument(
"-v", "--verbose", dest="verbose", action="store_true", help="verbose output"
)
args = parser.parse_args()
save_blackref = args.save_blackref
# don't delete user supplied blackref images
if args.black_reference_image is not None:
save_blackref = True
if args.negative and args.positive:
Film(
args.negative,
args.positive,
args.black_reference_preset,
args.black_reference_image,
save_blackref,
args.border_size,
args.ignore_border_left,
args.ignore_border_right,
args.ignore_border_top,
args.ignore_border_bottom,
args.contrast,
args.save_jpeg,
args.save_flip,
args.save_flop,
args.shift_color_channels,
args.verbose,
).invert()
else:
parser.print_usage()
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment