LUT concatenation in lut_to_lut

Author: mfe

lutLab/lut_to_lut.py

@@ -38,15 +38,15 @@ class LutToLutException(Exception):
     pass
 
 
-def lut_to_lut(inlutfile, out_type=None, out_format=None, outlutfile=None,
+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:
-        inlutfile (str): path to input LUT
+        lutfiles (str or [str]): path to a LUT or list of LUT paths
 
         out_type (str): 1D, 2D or 3D
 
@@ -98,26 +98,28 @@ def lut_to_lut(inlutfile, out_type=None, out_format=None, outlutfile=None,
                                                                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(inlutfile, ext)
+        outlutfile = get_default_out_path(inlutfiles, ext)
     elif os.path.isdir(outlutfile):
-        filename = os.path.splitext(ntpath.basename(inlutfile))[0] + ext
+        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(inlutfile,
+        print "{0} will be converted into {1}.".format(inlutfiles,
                                                        outlutfile)
         print "Final setting:\n{0}".format(presets.string_preset(preset))
-    processor = create_ocio_processor(inlutfile,
+    processor = create_ocio_processor(inlutfiles,
                                       interpolation=INTERP_LINEAR,
                                       inverse=inverse)
     # change interpolation if 3D LUT
-    if is_3d_lut(processor, inlutfile):
-        processor = create_ocio_processor(inlutfile,
+    if is_3d_lut(processor, inlutfiles[0]):
+        processor = create_ocio_processor(inlutfiles,
                                           interpolation=INTERP_TETRAHEDRAL,
                                           inverse=inverse)
     # write LUT
@@ -137,7 +139,7 @@ def __get_options():
     description = 'Convert a LUT into another format'
     parser = argparse.ArgumentParser(description=description)
     # input lut
-    add_inlutfile_option(parser)
+    add_inlutfile_option(parser, is_list=True)
     add_outlutfile_option(parser)
     # type, format, ranges,  out bit depth, out cube size
     add_export_lut_options(parser)
@@ -167,7 +169,7 @@ def __get_options():
     if not ARGS.preset is None:
         ARGS.preset = presets.get_presets_from_env()[ARGS.preset]
     try:
-        lut_to_lut(ARGS.inlutfile,
+        lut_to_lut(ARGS.inlutfiles,
                    ARGS.out_type,
                    ARGS.out_format,
                    ARGS.outlutfile,

test/lut_to_lut_test.py

@@ -108,6 +108,17 @@ def test_export_ascii(self):
         self.failUnlessRaises(AsciiHelperException, lut_to_lut, self.lut1d,
                               "1D", "lut", outlutfile, out_bit_depth=12)
 
+    def test_concatenate_luts(self):
+        """ Test concatenation
+
+        """
+        # contact in a 2D LUT
+        lut_to_lut([self.lut1d, self.lut3d], "2D", "lut", self.tmp_dir)
+        # concat in a 3D LUT
+        outlutfile = os.path.join(self.tmp_dir, "concat.csp")
+        lut_to_lut([self.lut3d, self.lut3d, self.lut1d],
+                   "3D", "csp", outlutfile)
+        lut_to_lut(outlutfile, "2D", "lut", self.tmp_dir)
     def tearDown(self):
         #Remove test directory
         shutil.rmtree(self.tmp_dir)

utils/export_tool_helper.py

@@ -37,17 +37,24 @@ class ExportLutException(Exception):
 # Argparse options
 
 
-def add_inlutfile_option(parser):
+def add_inlutfile_option(parser, is_list=False):
     """ Add inlutfile argument
 
     Args:
         parser (argparse.ArgumentParser): parser on which option will be add
 
     """
-    parser.add_argument("inlutfile",
-                        help=("path to a LUT.\n Available input formats : {0}"
-                              ).format(str(OCIO_LUTS_FORMATS)),
-                        type=str)
+    help_message = (" to LUTs.\n Available input formats : {0}"
+                    ).format(str(OCIO_LUTS_FORMATS))
+    if is_list:
+        parser.add_argument("inlutfiles",
+                            help="paths{0}".format(help_message),
+                            type=str,
+                            nargs='+')
+    else:
+        parser.add_argument("inlutfile",
+                            help="path{0}".format(help_message),
+                            type=str)
 
 
 def add_outlutfile_option(parser, required=False):

utils/lut_utils.py

@@ -44,15 +44,25 @@ def get_default_out_path(filepath, ext):
     """ Return a defaut output LUT path from an input LUT path
 
     Args:
-        filepath (str): input LUT file path
+        filepath (str or [str]): path to a LUT or list of LUT paths
         ext (str): output file extension
 
     Returns:
         .str
 
     """
-    split_filename = os.path.splitext(filepath)
-    return "{0}_export{1}".format(split_filename[0], ext)
+    if isinstance(filepath, (list, tuple)):
+        filepaths = filepath
+        new_filepath = None
+        for filepath in filepaths:
+            if not new_filepath:
+                new_filepath = os.path.splitext(filepath)[0]
+            else:
+                basename = os.path.splitext(ntpath.basename(filepath))[0]
+                new_filepath += "+{0}".format(basename)
+    else:
+        new_filepath = os.path.splitext(filepath)[0]
+    return "{0}_export{1}".format(new_filepath, ext)
 
 
 def get_3d_list_values(cubesize, processor, hexa_values=False):

utils/ocio_helper.py

@@ -25,12 +25,12 @@
                            - set(OCIO_1D_LUTS_FORMATS)))
 
 
-def create_ocio_processor(lutfile, interpolation=INTERP_LINEAR, inverse=False,
+def create_ocio_processor(lutfiles, interpolation=INTERP_LINEAR, inverse=False,
                           prelutfile=None, postlutfile=None):
     """Create an OpenColorIO processor for lutfile
 
     Args:
-        lutfile (str): path to a LUT
+        lutfiles (str or [str]): path to a LUT or list of LUT paths
 
         interpolation (int): can be INTERP_NEAREST, INTERP_LINEAR or
         INTERP_TETRAHEDRAL (only for 3D LUT)
@@ -53,15 +53,18 @@ def create_ocio_processor(lutfile, interpolation=INTERP_LINEAR, inverse=False,
     config = Config()
     # In colorspace (LUT)
     colorspace = ColorSpace(name='RawInput')
-    main_lut = FileTransform(lutfile, interpolation=interpolation,
-                            direction=direction)
     group = GroupTransform()
     # Prelut
     if prelutfile:
         prelut = FileTransform(prelutfile, interpolation=interpolation)
         group.push_back(prelut)
     # Mainlut
-    group.push_back(main_lut)
+    if not isinstance(lutfiles, (list, tuple)):
+        lutfiles = [lutfiles]
+    for lutfile in lutfiles:
+        main_lut = FileTransform(lutfile, interpolation=interpolation,
+                                 direction=direction)
+        group.push_back(main_lut)
     # Postlut
     if postlutfile:
         postlut = FileTransform(postlutfile, interpolation=interpolation)
@@ -72,7 +75,17 @@ def create_ocio_processor(lutfile, interpolation=INTERP_LINEAR, inverse=False,
     colorspace = ColorSpace(name='ProcessedOutput')
     config.addColorSpace(colorspace)
     # Create a processor corresponding to the LUT transformation
-    return config.getProcessor('RawInput', 'ProcessedOutput')
+    try:
+        return config.getProcessor('RawInput', 'ProcessedOutput')
+    except Exception, e:
+        # tetrahedral interpolation is only allowed with 3D LUT
+        # TODO set interpo mode by LUT
+        if "tetrahedral interpolation is not allowed" in str(e):
+            return create_ocio_processor(lutfiles, interpolation=INTERP_LINEAR,
+                                         inverse=inverse,
+                                         prelutfile=prelutfile,
+                                         postlutfile=postlutfile)
+        raise
 
 
 def is_3d_lut(processor, lutfile):