def setUp(self):
test_dir = os.path.join(os.path.dirname(__file__), 'test_files')
self.tmp_dir = os.path.join(tempfile.gettempdir(), 'testCoPipe')
if not os.path.exists(self.tmp_dir):
os.mkdir(self.tmp_dir)
# create OCIO processor
lut1d = os.path.join(test_dir, 'CineonToLin_1D.csp')
lut3d = os.path.join(test_dir, 'saturation.3dl')
self.processor_1d = create_ocio_processor(lut1d,
interpolation=INTERP_LINEAR)
self.processor_3d = create_ocio_processor(lut3d,
interpolation=INTERP_TETRAHEDRAL)
self.helpers_1d_to_test = [
(CUBE_HELPER, '.cube'),
[SPI_HELPER, '.spi1d'],
(CSP_HELPER, '.csp'),
]
self.helpers_3d_to_test = [
(CUBE_HELPER, '.cube', True),
[SPI_HELPER, '.spi3d', True],
(CSP_HELPER, '.csp', True),
(THREEDL_HELPER, '.3dl', True),
(CLCC_HELPER, '.cc', False),
(JSON_HELPER, '.json', False)
]
def plot_that_lut(lutfile, plot_type=None, count=None, inverse=False,
prelutfile=None, postlutfile=None):
"""Plot a lut depending on its type and/or args
Args:
lutfile (str): path to a color transformation file (lut, matrix...)
kwargs:
plot_type (str): possible values are 'curve' or 'cube'
count: possible values are curve size or curve samples count or 'auto'
prelutfile (str): path to a pre LUT
postlutfile (str): path to a post LUT
Raises:
PlotThatLutException
Exception from OpenColorIO binding
"""
set_matplotlib_backend()
# check if LUT format is supported
fileext = os.path.splitext(lutfile)[1]
if not fileext:
raise PlotThatLutException((
"Error: Couldn't extract extension in this\n"
"path : {0}"
).format(lutfile))
if fileext not in OCIO_LUTS_FORMATS:
raise PlotThatLutException("Error: {0} file aren't supported.\n{1}"
.format(fileext, supported_formats()))
# create OCIO processor
processor = create_ocio_processor(lutfile, 0, inverse,
prelutfile, postlutfile)
# init args
if not plot_type or plot_type == 'auto':
if is_3d_lut(processor, lutfile):
plot_type = 'cube'
else:
plot_type = 'curve'
if not count or count == 'auto':
# set plot_type from the command line and init default count
if plot_type == 'curve':
count = DEFAULT_SAMPLE
else:
count = DEFAULT_CUBE_SIZE
# plot
print "Plotting a {0} with {1} samples...".format(plot_type, count)
if plot_type == 'curve':
return plot_curve(lutfile, count, processor)
elif plot_type == 'cube':
return plot_cube(lutfile, count, processor)
else:
raise PlotThatLutException((
"Unknown plot type : {0}\n"
"Plot type should be curve or cube.\n"
).format(plot_type))
def test_float_luts(self):
""" Test float LUT transparency
"""
helpers_float_to_test = [(CSP_HELPER, '.csp'),
(SPI_HELPER, '.spi1d')]
colorspace_to_test = [REC709, SGAMUTSLOG, ALEXALOGCV3]
delta = 0.00001
for helper, ext in helpers_float_to_test:
for colorspace in colorspace_to_test:
# define file name
name = colorspace.__class__.__name__
encode_filename = "linTo{0}_1D{1}".format(name, ext)
decode_filename = "{0}ToLin_1D{1}".format(name, ext)
encode_filepath = os.path.join(self.tmp_dir, encode_filename)
decode_filepath = os.path.join(self.tmp_dir, decode_filename)
# set preset
args_1d = CSP_HELPER.get_default_preset()
args_1d[presets.OUT_BITDEPTH] = 16
decode_min = colorspace.decode_gradation(0)
decode_max = colorspace.decode_gradation(1)
args_1d[presets.IN_RANGE] = get_input_range(colorspace,
"encode",
10)
# write encode LUT
helper.write_2d_lut(colorspace.encode_gradation,
encode_filepath,
args_1d)
# write decode LUT
args_1d[presets.IN_RANGE] = get_input_range(colorspace,
"decode",
10)
helper.write_2d_lut(colorspace.decode_gradation,
decode_filepath,
args_1d)
# test transparency
proc = create_ocio_processor(encode_filepath,
postlutfile=decode_filepath,
interpolation=INTERP_LINEAR)
test_values = [[decode_min] * 3,
[decode_max] * 3,
[0] * 3,
[0.5] * 3,
[1] * 3]
for rgb in test_values:
res = proc.applyRGB(rgb)
abs_value = abs(rgb[0] - res[0])
self.assert_(abs_value < delta,
"{0} transparency test failed : {1:8f} >"
" acceptable delta ({2:8f})".format(name,
abs_value,
delta)
)
def test_convert_from_preset(self):
"""Read a preset file and write a LUT
"""
preset = presets.read_preset(self.sample_preset)
outlutfile = os.path.join(self.tmp_dir, 'test_preset.cube')
lut_to_lut(self.lut3d, preset=preset, outlutfile=outlutfile)
proc = create_ocio_processor(outlutfile, interpolation=INTERP_LINEAR)
proc.applyRGB([0, 0, 0])
proc.applyRGB([1, 1, 1])
if DISPLAY:
import plot_that_lut
plot_that_lut.plot_that_lut(outlutfile)
def test_default_3d_lut(self):
""" Test a default 3d LUT export
"""
for helper, ext, ocio_compatible in self.helpers_3d_to_test:
outlutfile = os.path.join(self.tmp_dir, "default_3D" + ext)
args_3d = helper.get_default_preset()
helper.write_3d_lut(self.processor_3d.applyRGB,
outlutfile,
args_3d)
if ocio_compatible:
# create a processor and try it
proc = create_ocio_processor(outlutfile,
interpolation=INTERP_LINEAR)
proc.applyRGB([0, 0, 0])
proc.applyRGB([1, 1, 1])
if DISPLAY:
import plot_that_lut
plot_that_lut.plot_that_lut(outlutfile)
def test_default_1d_lut(self):
""" Test a default 1d LUT export
"""
outlutfiles = []
for helper, ext in self.helpers_1d_to_test:
outlutfile = os.path.join(self.tmp_dir, "default_1D" + ext)
args_1d = helper.get_default_preset()
helper.write_1d_lut(self.processor_1d.applyRGB, outlutfile,
args_1d)
# create a processor and try it
proc = create_ocio_processor(outlutfile,
interpolation=INTERP_LINEAR)
proc.applyRGB([0, 0, 0])
proc.applyRGB([1, 1, 1])
outlutfiles.append(outlutfile)
if DISPLAY:
import plot_that_lut
plot_that_lut.plot_that_lut(outlutfiles)
def lut_to_lut(inlutfile, outlutfile=None, type='1D_CUBE',
lutsize=16):
"""Extract the tone mapping curve of a 3D LUT
Args:
inlutfile (str): an input 3D LUT
Kwargs:
outlutfile (str): the output 1D LUT. If not define, LUT is written in
the input LUT directory and post-fixed with "_export"
type (str): specify output LUT format. For now only 2D csp and 2D cube
are available.
lutsize (int): out LUT bit precision. Ex : 16 (bits)
"""
samples_count = pow(2, lutsize)
if type == '1D_CUBE':
ext = ".cube"
write_function = write_2d_cube_lut
elif type == '1D_CSP':
ext = ".csp"
write_function = write_2d_csp_lut
else:
raise LutToLutException("Unsupported export format!")
if not outlutfile:
outlutfile = get_default_out_path(inlutfile, ext)
processor = create_ocio_processor(inlutfile)
# init vars
max_value = samples_count - 1.0
red_values = []
green_values = []
blue_values = []
# process color values
for n in range(0, samples_count):
x = n/max_value
res = processor.applyRGB([x, x, x])
red_values.append(res[0])
green_values.append(res[1])
blue_values.append(res[2])
# write
write_function(outlutfile, red_values, green_values, blue_values)
def lut_to_lut(inlutfile, outlutfile=None, type='1D_CUBE', lutsize=16):
"""Extract the tone mapping curve of a 3D LUT
Args:
inlutfile (str): an input 3D LUT
Kwargs:
outlutfile (str): the output 1D LUT. If not define, LUT is written in
the input LUT directory and post-fixed with "_export"
type (str): specify output LUT format. For now only 2D csp and 2D cube
are available.
lutsize (int): out LUT bit precision. Ex : 16 (bits)
"""
samples_count = pow(2, lutsize)
if type == '1D_CUBE':
ext = ".cube"
write_function = write_2d_cube_lut
elif type == '1D_CSP':
ext = ".csp"
write_function = write_2d_csp_lut
else:
raise LutToLutException("Unsupported export format!")
if not outlutfile:
outlutfile = get_default_out_path(inlutfile, ext)
processor = create_ocio_processor(inlutfile)
# init vars
max_value = samples_count - 1.0
red_values = []
green_values = []
blue_values = []
# process color values
for n in range(0, samples_count):
x = n / max_value
res = processor.applyRGB([x, x, x])
red_values.append(res[0])
green_values.append(res[1])
blue_values.append(res[2])
# write
write_function(outlutfile, red_values, green_values, blue_values)
def plot_that_lut(lutfiles,
plot_type=None,
count=None,
inverse=False,
prelutfile=None,
postlutfile=None,
display_markers=False):
"""Plot a lut depending on its type and/or args
Args:
lutfiles (str): pathes to color transformation files (lut, matrix...)
kwargs:
plot_type (str): possible values are 'curve' or 'cube'
count: possible values are curve size or curve samples count or 'auto'
prelutfile (str): path to a pre LUT
postlutfile (str): path to a post LUT
display_markers (bool): should display markers on curve
Raises:
PlotThatLutException
Exception from OpenColorIO binding
"""
if not isinstance(lutfiles, list):
lutfiles = [lutfiles]
mplh.set_matplotlib_backend()
processors = []
for lutfile in lutfiles:
# check if LUT format is supported
fileext = os.path.splitext(lutfile)[1]
if not fileext:
raise PlotThatLutException(
("Error: Couldn't extract extension in this\n"
"path : {0}").format(lutfile))
if fileext not in OCIO_LUTS_FORMATS:
raise PlotThatLutException(
"Error: {0} file aren't supported.\n{1}".format(
fileext, supported_formats()))
# create OCIO processor
processors.append(
create_ocio_processor(lutfile, INTERP_LINEAR, inverse, prelutfile,
postlutfile))
# init args
if not plot_type or plot_type == 'auto':
# deduce plot type considering first lutfile
if is_3d_lut(processors[0], lutfiles[0]):
plot_type = 'cube'
else:
plot_type = 'curve'
if not count or count == 'auto':
# set plot_type from the command line and init default count
if 'curve' in plot_type:
count = DEFAULT_SAMPLE
else:
count = DEFAULT_CUBE_SIZE
# plot
print "Plotting a {0} with {1} samples...".format(plot_type, count)
if 'curve' in plot_type:
draw_red_curve = True
draw_green_curve = True
draw_blue_curve = True
if 'red' in plot_type:
#red_curve option
draw_green_curve = False
draw_blue_curve = False
elif 'green' in plot_type:
#green_curve option
draw_red_curve = False
draw_blue_curve = False
elif 'blue' in plot_type:
#blue_curve option
draw_red_curve = False
draw_green_curve = False
return plot_curve(lutfiles,
count,
processors,
draw_red_curve=draw_red_curve,
draw_green_curve=draw_green_curve,
draw_blue_curve=draw_blue_curve,
display_markers=display_markers)
elif plot_type == 'cube':
# TODO support multiple cubes display
return plot_cube(lutfiles[0], count, processors[0])
else:
raise PlotThatLutException(
("Unknown plot type : {0}\n"
"Plot type should be curve or cube.\n").format(plot_type))
def plot_that_lut(lutfiles, plot_type=None, count=None, inverse=False,
prelutfile=None, postlutfile=None, display_markers=False):
"""Plot a lut depending on its type and/or args
Args:
lutfiles (str): pathes to color transformation files (lut, matrix...)
kwargs:
plot_type (str): possible values are 'curve' or 'cube'
count: possible values are curve size or curve samples count or 'auto'
prelutfile (str): path to a pre LUT
postlutfile (str): path to a post LUT
display_markers (bool): should display markers on curve
Raises:
PlotThatLutException
Exception from OpenColorIO binding
"""
if not isinstance(lutfiles, list):
lutfiles = [lutfiles]
mplh.set_matplotlib_backend()
processors = []
for lutfile in lutfiles:
# check if LUT format is supported
fileext = os.path.splitext(lutfile)[1]
if not fileext:
raise PlotThatLutException((
"Error: Couldn't extract extension in this\n"
"path : {0}"
).format(lutfile))
if fileext not in OCIO_LUTS_FORMATS:
raise PlotThatLutException("Error: {0} file aren't supported.\n{1}"
.format(fileext, supported_formats()))
# create OCIO processor
processors.append(create_ocio_processor(lutfile, INTERP_LINEAR,
inverse, prelutfile,
postlutfile))
# init args
if not plot_type or plot_type == 'auto':
# deduce plot type considering first lutfile
if is_3d_lut(processors[0], lutfiles[0]):
plot_type = 'cube'
else:
plot_type = 'curve'
if not count or count == 'auto':
# set plot_type from the command line and init default count
if 'curve' in plot_type:
count = DEFAULT_SAMPLE
else:
count = DEFAULT_CUBE_SIZE
# plot
print "Plotting a {0} with {1} samples...".format(plot_type, count)
if 'curve' in plot_type:
draw_red_curve = True
draw_green_curve = True
draw_blue_curve = True
if 'red' in plot_type:
#red_curve option
draw_green_curve = False
draw_blue_curve = False
elif 'green' in plot_type:
#green_curve option
draw_red_curve = False
draw_blue_curve = False
elif 'blue' in plot_type:
#blue_curve option
draw_red_curve = False
draw_green_curve = False
return plot_curve(lutfiles, count, processors,
draw_red_curve=draw_red_curve,
draw_green_curve=draw_green_curve,
draw_blue_curve=draw_blue_curve,
display_markers=display_markers)
elif plot_type == 'cube':
# TODO support multiple cubes display
return plot_cube(lutfiles[0], count, processors[0])
else:
raise PlotThatLutException((
"Unknown plot type : {0}\n"
"Plot type should be curve or cube.\n"
).format(plot_type))
def lut_to_lut(inlutfile,
outlutfile=None,
lut_type='1D_CUBE',
lutsize=16,
cubesize=17,
inverse=False):
"""Extract the tone mapping curve of a 3D LUT
Args:
inlutfile (str): an input 3D LUT
Kwargs:
outlutfile (str): the output 1D LUT. If not define, LUT is written in
the input LUT directory and post-fixed with "_export"
lut_type (str): specify output LUT format. For now only 2D/3D csp and
2D cube are available.
lutsize (int): out LUT bit precision for 1D. Ex : 16 (bits)
"""
samples_count = pow(2, lutsize)
if lut_type == '1D_CUBE':
ext = ".cube"
write_function = write_2d_cube_lut
interp = INTERP_LINEAR
elif lut_type == '3D_CUBE':
ext = ".cube"
write_function = write_3d_cube_lut
interp = INTERP_TETRAHEDRAL
elif lut_type == '1D_CSP':
ext = ".csp"
write_function = write_2d_csp_lut
interp = INTERP_LINEAR
elif lut_type == '3D_JSON':
ext = ".json"
write_function = write_3d_json_file
interp = INTERP_TETRAHEDRAL
elif lut_type == '3D_CLCC':
ext = ".cc"
write_function = write_3d_clcc_lut
interp = INTERP_TETRAHEDRAL
else:
raise LutToLutException("Unsupported export format!")
if not outlutfile:
outlutfile = get_default_out_path(inlutfile, ext)
processor = create_ocio_processor(inlutfile,
interpolation=interp,
inverse=inverse)
# init vars
max_value = samples_count - 1.0
red_values = []
green_values = []
blue_values = []
if "1D" in lut_type:
# process color values
for code_value in range(0, samples_count):
norm_value = code_value / max_value
res = processor.applyRGB([norm_value, norm_value, norm_value])
red_values.append(res[0])
green_values.append(res[1])
blue_values.append(res[2])
# write
write_function(outlutfile, red_values, green_values, blue_values)
elif "3D" in lut_type:
# write
write_function(outlutfile, cubesize, processor)
print "{0} was converted into {1}.".format(inlutfile, outlutfile)
def lut_to_lut(inlutfiles,
out_type=None,
out_format=None,
outlutfile=None,
input_range=None,
output_range=None,
out_bit_depth=None,
inverse=False,
out_cube_size=None,
verbose=False,
smooth_size=None,
preset=None,
overwrite_preset=False):
""" Concert a LUT in another LUT
Arguments testing are delegated to LUT helpers
Args:
lutfiles (str or [str]): path to a LUT or list of LUT paths
out_type (str): 1D, 2D or 3D
out_format (str): '3dl', 'csp', 'cube', 'lut', 'spi', 'clcc', 'json'...
Kwargs:
outlutfile (str): path to output LUT
input_range ([int/float, int/float]): input range.
Ex: [0.0, 1.0] or [0, 4095]
output_range ([int/float, int/float]): output range.
Ex: [0.0, 1.0] or [0, 4095]
out_bit_depth (int): output lut bit precision (1D only).
Ex : 10, 16, 32.
inverse (bool): inverse input LUT (1D only)
out_cube_size (int): output cube size (3D only). Ex : 17, 32.
verbose (bool): print log if true
smooth_size (int): smooth exported LUT (1D only).
Specify how many points are computed.
A first subsampled curve is first processed and then resample with
a smooth to fit input lutsize.
So the smaller this value is, the smoother the curve will be.
Ex: 10, 20,...
preset (dict): lut generic and sampling informations
"""
if preset:
write_function = get_write_function(preset, overwrite_preset, out_type,
out_format, input_range,
output_range, out_bit_depth,
out_cube_size, verbose)
elif out_type is None or out_format is None:
raise LutToLutException("Specify out_type/out_format or a preset.")
else:
preset, write_function = get_preset_and_write_function(
out_type, out_format, input_range, output_range, out_bit_depth,
out_cube_size)
ext = preset[presets.EXT]
if not isinstance(inlutfiles, (list, tuple)):
inlutfiles = [inlutfiles]
if not outlutfile:
outlutfile = get_default_out_path(inlutfiles, ext)
elif os.path.isdir(outlutfile):
filename = os.path.splitext(ntpath.basename(inlutfiles[0]))[0] + ext
outlutfile = os.path.join(outlutfile, filename)
else:
check_extension(outlutfile, ext)
# smooth
if smooth_size:
preset[presets.SMOOTH] = smooth_size
if verbose:
print "{0} will be converted into {1}.".format(inlutfiles, outlutfile)
print "Final setting:\n{0}".format(presets.string_preset(preset))
processor = create_ocio_processor(inlutfiles,
interpolation=INTERP_LINEAR,
inverse=inverse)
# change interpolation if 3D LUT
if is_3d_lut(processor, inlutfiles[0]):
processor = create_ocio_processor(inlutfiles,
interpolation=INTERP_TETRAHEDRAL,
inverse=inverse)
# write LUT
message = write_function(processor.applyRGB, outlutfile, preset)
if verbose:
print_success_message(message)
def lut_to_lut(inlutfiles, out_type=None, out_format=None, outlutfile=None,
input_range=None, output_range=None, out_bit_depth=None,
inverse=False, out_cube_size=None, verbose=False,
smooth_size=None, preset=None, overwrite_preset=False):
""" Concert a LUT in another LUT
Arguments testing are delegated to LUT helpers
Args:
lutfiles (str or [str]): path to a LUT or list of LUT paths
out_type (str): 1D, 2D or 3D
out_format (str): '3dl', 'csp', 'cube', 'lut', 'spi', 'clcc', 'json'...
Kwargs:
outlutfile (str): path to output LUT
input_range ([int/float, int/float]): input range.
Ex: [0.0, 1.0] or [0, 4095]
output_range ([int/float, int/float]): output range.
Ex: [0.0, 1.0] or [0, 4095]
out_bit_depth (int): output lut bit precision (1D only).
Ex : 10, 16, 32.
inverse (bool): inverse input LUT (1D only)
out_cube_size (int): output cube size (3D only). Ex : 17, 32.
verbose (bool): print log if true
smooth_size (int): smooth exported LUT (1D only).
Specify how many points are computed.
A first subsampled curve is first processed and then resample with
a smooth to fit input lutsize.
So the smaller this value is, the smoother the curve will be.
Ex: 10, 20,...
preset (dict): lut generic and sampling informations
"""
if preset:
write_function = get_write_function(preset, overwrite_preset,
out_type, out_format,
input_range,
output_range,
out_bit_depth,
out_cube_size,
verbose)
elif out_type is None or out_format is None:
raise LutToLutException("Specify out_type/out_format or a preset.")
else:
preset, write_function = get_preset_and_write_function(out_type,
out_format,
input_range,
output_range,
out_bit_depth,
out_cube_size)
ext = preset[presets.EXT]
if not isinstance(inlutfiles, (list, tuple)):
inlutfiles = [inlutfiles]
if not outlutfile:
outlutfile = get_default_out_path(inlutfiles, ext)
elif os.path.isdir(outlutfile):
filename = os.path.splitext(ntpath.basename(inlutfiles[0]))[0] + ext
outlutfile = os.path.join(outlutfile, filename)
else:
check_extension(outlutfile, ext)
# smooth
if smooth_size:
preset[presets.SMOOTH] = smooth_size
if verbose:
print "{0} will be converted into {1}.".format(inlutfiles,
outlutfile)
print "Final setting:\n{0}".format(presets.string_preset(preset))
processor = create_ocio_processor(inlutfiles,
interpolation=INTERP_LINEAR,
inverse=inverse)
# change interpolation if 3D LUT
if is_3d_lut(processor, inlutfiles[0]):
processor = create_ocio_processor(inlutfiles,
interpolation=INTERP_TETRAHEDRAL,
inverse=inverse)
# write LUT
message = write_function(processor.applyRGB, outlutfile, preset)
if verbose:
print_success_message(message)
def extract_1d_lut(inlutfile, lutsize, outlutfile=None, smooth=False,
smooth_size=17, display=False):
"""Extract the tone mapping curve of a 3D LUT
Args:
inlutfile (str): an input 3D LUT
lutsize (int): out 1D LUT bit precision. Ex : 16 (bits)
Kwargs:
outlutfile (str): the output 1D lut. If not define, LUT is written in
the input LUT directory and post-fixed with "_export"
smooth (bool): smooth the resulting curve with a bicubic monotonic
interpolation. See also smooth_size.
smooth_size (int): only used when smooth is true. Specify how many
points are sampled using OpenColorIO processor. The result curve is then
smoothed and resample to fit input lutsize.
So the smaller this value is, the smoother the curve will be.
"""
if not outlutfile:
outlutfile = get_default_out_path(inlutfile, ".csp")
# create OCIO processor
processor = create_ocio_processor(inlutfile)
if not is_3d_lut(processor, inlutfile):
raise Ext1DLutException("Input lut must be a 3D LUT !")
# init vars
if smooth:
# subsample OCIO processed curve
count = smooth_size
else:
count = pow(2, lutsize)
max_value = count - 1.0
red_values = []
green_values = []
blue_values = []
for n in range(0, count):
x = n/max_value
res = processor.applyRGB([x, x, x])
red_values.append(res[0])
green_values.append(res[1])
blue_values.append(res[2])
if smooth:
# get full range
xnew = numpy.arange(0, max_value, float(count-1)/(pow(2, lutsize)))
# get a monotonic cubic function from subsampled curve
red_cubic_monotonic_func = PchipInterpolator(numpy.arange(0, count),
red_values)
green_cubic_monotonic_func = PchipInterpolator(numpy.arange(0, count),
green_values)
blue_cubic_monotonic_func = PchipInterpolator(numpy.arange(0, count),
blue_values)
# sample on the full range
reds = red_cubic_monotonic_func(xnew)
greens = green_cubic_monotonic_func(xnew)
blues = blue_cubic_monotonic_func(xnew)
else:
reds = red_values
greens = green_values
blues = blue_values
write_2d_csp_lut(outlutfile, reds, greens, blues)
if display:
try:
# init plot
from matplotlib.pyplot import (title, plot, grid,
figure, show)
except:
raise Ext1DLutException("Install matplotlib to use display option")
fig = figure()
fig.canvas.set_window_title('Plot That 1D LUT')
title("Compare")
grid(True)
# plot curves
plot(reds, 'r-', label='numpy', linewidth=1)
plot(greens, 'g-', label='numpy', linewidth=1)
plot(blues, 'b-', label='numpy', linewidth=1)
show()
def extract_1d_lut(inlutfile, lutsize, outlutfile=None, smooth=False,
smooth_size=17, display=False):
"""Extract the tone mapping curve of a 3D LUT
Args:
inlutfile (str): an input 3D LUT
lutsize (int): out 1D LUT bit precision. Ex : 16 (bits)
Kwargs:
outlutfile (str): the output 1D lut. If not define, LUT is written in
the input LUT directory and post-fixed with "_export"
smooth (bool): smooth the resulting curve with a bicubic monotonic
interpolation. See also smooth_size.
smooth_size (int): only used when smooth is true. Specify how many
points are sampled using OpenColorIO processor.
The result curve is then smoothed and resample to fit input lutsize.
So the smaller this value is, the smoother the curve will be.
"""
if not outlutfile:
outlutfile = get_default_out_path(inlutfile, ".csp")
# create OCIO processor
processor = create_ocio_processor(inlutfile)
if not is_3d_lut(processor, inlutfile):
raise Ext1DLutException("Input lut must be a 3D LUT !")
# init vars
if smooth:
# subsample OCIO processed curve
count = smooth_size
else:
count = pow(2, lutsize)
max_value = count - 1.0
red_values = []
green_values = []
blue_values = []
for code_value in range(0, count):
norm_value = code_value / max_value
res = processor.applyRGB([norm_value, norm_value, norm_value])
red_values.append(res[0])
green_values.append(res[1])
blue_values.append(res[2])
if smooth:
# get full range
xnew = numpy.arange(0, max_value, float(count - 1) / (pow(2, lutsize)))
# get a monotonic cubic function from subsampled curve
red_cubic_monotonic_func = PchipInterpolator(numpy.arange(0, count),
red_values)
green_cubic_monotonic_func = PchipInterpolator(numpy.arange(0, count),
green_values)
blue_cubic_monotonic_func = PchipInterpolator(numpy.arange(0, count),
blue_values)
# sample on the full range
reds = red_cubic_monotonic_func(xnew)
greens = green_cubic_monotonic_func(xnew)
blues = blue_cubic_monotonic_func(xnew)
else:
reds = red_values
greens = green_values
blues = blue_values
write_2d_csp_lut(outlutfile, reds, greens, blues)
if display:
try:
# init plot
from matplotlib.pyplot import (title, plot, grid,
figure, show)
except:
raise Ext1DLutException("Install matplotlib to use display option")
fig = figure()
fig.canvas.set_window_title('Plot That 1D LUT')
title("Compare")
grid(True)
# plot curves
plot(reds, 'r-', label='numpy', linewidth=1)
plot(greens, 'g-', label='numpy', linewidth=1)
plot(blues, 'b-', label='numpy', linewidth=1)
show()
def lut_to_lut(inlutfile, outlutfile=None, lut_type='1D_CUBE',
lutsize=16, cubesize=17, inverse=False):
"""Extract the tone mapping curve of a 3D LUT
Args:
inlutfile (str): an input 3D LUT
Kwargs:
outlutfile (str): the output 1D LUT. If not define, LUT is written in
the input LUT directory and post-fixed with "_export"
lut_type (str): specify output LUT format. For now only 2D/3D csp and
2D cube are available.
lutsize (int): out LUT bit precision for 1D. Ex : 16 (bits)
"""
samples_count = pow(2, lutsize)
if lut_type == '1D_CUBE':
ext = ".cube"
write_function = write_2d_cube_lut
interp = INTERP_LINEAR
elif lut_type == '3D_CUBE':
ext = ".cube"
write_function = write_3d_cube_lut
interp = INTERP_TETRAHEDRAL
elif lut_type == '1D_CSP':
ext = ".csp"
write_function = write_2d_csp_lut
interp = INTERP_LINEAR
elif lut_type == '3D_JSON':
ext = ".json"
write_function = write_3d_json_file
interp = INTERP_TETRAHEDRAL
elif lut_type == '3D_CLCC':
ext = ".cc"
write_function = write_3d_clcc_lut
interp = INTERP_TETRAHEDRAL
else:
raise LutToLutException("Unsupported export format!")
if not outlutfile:
outlutfile = get_default_out_path(inlutfile, ext)
processor = create_ocio_processor(inlutfile, interpolation=interp,
inverse=inverse)
# init vars
max_value = samples_count - 1.0
red_values = []
green_values = []
blue_values = []
if "1D" in lut_type:
# process color values
for code_value in range(0, samples_count):
norm_value = code_value / max_value
res = processor.applyRGB([norm_value, norm_value, norm_value])
red_values.append(res[0])
green_values.append(res[1])
blue_values.append(res[2])
# write
write_function(outlutfile, red_values, green_values, blue_values)
elif "3D" in lut_type:
# write
write_function(outlutfile, cubesize, processor)
print "{0} was converted into {1}.".format(inlutfile, outlutfile)
