Merge branch 'feature/PYPE-331-nks-lut-workflow_altered' into feature/PYPE-488-nk-loading-nks-lut-soft-effects

# Conflicts:
#	pype/plugins/nukestudio/publish/collect_effects.py

pype/plugins/nukestudio/publish/collect_clips.py

@@ -21,108 +21,113 @@ class CollectClips(api.ContextPlugin):
         projectdata = context.data["projectData"]
         version = context.data.get("version", "001")
         sequence = context.data.get("activeSequence")
-        instances_data = []
+        selection = context.data.get("selection")
 
-        # get all subTrackItems and add it to context
-        effects_on_tracks = []
-        sub_track_items = []
+        track_effects = dict()
 
-        # looop trough all tracks and search for subtreacks
+        # collect all trackItems as instances
         for track_index, video_track in enumerate(sequence.videoTracks()):
+            items = video_track.items()
             sub_items = video_track.subTrackItems()
-            if not sub_items:
-                continue
-            for si in sub_items:
-                selected_track = [(indx, vt) for indx, vt in enumerate(sequence.videoTracks())
-                                  if vt.name() in si[0].parentTrack().name()]
 
-                # if filtered track index is the same as \
-                # actual track there is match
-                if (selected_track[0][0] == track_index):
-                    sub_track_items += si
-                    if (track_index not in effects_on_tracks):
-                        effects_on_tracks.append(track_index)
-
-        # add it to context
-        context.data["subTrackUsedTracks"] = effects_on_tracks
-        context.data["subTrackItems"] = sub_track_items
-
-        for item in context.data.get("selection", []):
-            # Skip audio track items
-            # Try/Except is to handle items types, like EffectTrackItem
-            try:
-                media_type = "core.Hiero.Python.TrackItem.MediaType.kVideo"
-                if str(item.mediaType()) != media_type:
+            for item in items:
+                # compare with selection or if disabled
+                if item not in selection or not item.isEnabled():
                     continue
-            except Exception:
+
+                # Skip audio track items
+                # Try/Except is to handle items types, like EffectTrackItem
+                try:
+                    media_type = "core.Hiero.Python.TrackItem.MediaType.kVideo"
+                    if str(item.mediaType()) != media_type:
+                        continue
+                except Exception:
+                    continue
+
+                asset = item.name()
+                track = item.parent()
+                source = item.source().mediaSource()
+                source_path = source.firstpath()
+                effects = [f for f in item.linkedItems() if f.isEnabled()]
+
+                # If source is *.nk its a comp effect and we need to fetch the
+                # write node output. This should be improved by parsing the script
+                # rather than opening it.
+                if source_path.endswith(".nk"):
+                    nuke.scriptOpen(source_path)
+                    # There should noly be one.
+                    write_node = nuke.allNodes(filter="Write")[0]
+                    path = nuke.filename(write_node)
+
+                    if "%" in path:
+                        # Get start frame from Nuke script and use the item source
+                        # in/out, because you can have multiple shots covered with
+                        # one nuke script.
+                        start_frame = int(nuke.root()["first_frame"].getValue())
+                        if write_node["use_limit"].getValue():
+                            start_frame = int(write_node["first"].getValue())
+
+                        path = path % (start_frame + item.sourceIn())
+
+                    source_path = path
+                    self.log.debug(
+                        "Fetched source path \"{}\" from \"{}\" in "
+                        "\"{}\".".format(
+                            source_path, write_node.name(), source.firstpath()
+                        )
+                    )
+
+                try:
+                    head, padding, ext = os.path.basename(source_path).split(".")
+                    source_first_frame = int(padding)
+                except Exception:
+                    source_first_frame = 0
+
+                data = {"name": "{0}_{1}".format(track.name(), item.name()),
+                        "item": item,
+                        "source": source,
+                        "sourcePath": source_path,
+                        "track": track.name(),
+                        "trackIndex": track_index,
+                        "sourceFirst": source_first_frame,
+                        "effects": effects,
+                        "sourceIn": int(item.sourceIn()),
+                        "sourceOut": int(item.sourceOut()),
+                        "clipIn": int(item.timelineIn()),
+                        "clipOut": int(item.timelineOut()),
+                        "asset": asset,
+                        "family": "clip",
+                        "families": [],
+                        "handles": 0,
+                        "handleStart": projectdata.get("handles", 0),
+                        "handleEnd": projectdata.get("handles", 0),
+                        "version": int(version)}
+
+                instance = context.create_instance(**data)
+
+                self.log.info("Created instance: {}".format(instance))
+                self.log.debug(">> effects: {}".format(instance.data["effects"]))
+
+                context.data["assetsShared"][asset] = dict()
+
+            # from now we are collecting only subtrackitems on
+            # track with no video items
+            if len(items) > 0:
                 continue
 
-            track = item.parent()
-            source = item.source().mediaSource()
-            source_path = source.firstpath()
+            # create list in track key
+            # get all subTrackItems and add it to context
+            track_effects[track_index] = list()
 
-            # If source is *.nk its a comp effect and we need to fetch the
-            # write node output. This should be improved by parsing the script
-            # rather than opening it.
-            if source_path.endswith(".nk"):
-                nuke.scriptOpen(source_path)
-                # There should noly be one.
-                write_node = nuke.allNodes(filter="Write")[0]
-                path = nuke.filename(write_node)
+            # collect all subtrack items
+            for sitem in sub_items:
+                # unwrap from tuple >> it is always tuple with one item
+                sitem = sitem[0]
+                # checking if not enabled
+                if not sitem.isEnabled():
+                    continue
 
-                if "%" in path:
-                    # Get start frame from Nuke script and use the item source
-                    # in/out, because you can have multiple shots covered with
-                    # one nuke script.
-                    start_frame = int(nuke.root()["first_frame"].getValue())
-                    if write_node["use_limit"].getValue():
-                        start_frame = int(write_node["first"].getValue())
+                track_effects[track_index].append(sitem)
 
-                    path = path % (start_frame + item.sourceIn())
-
-                source_path = path
-                self.log.debug(
-                    "Fetched source path \"{}\" from \"{}\" in "
-                    "\"{}\".".format(
-                        source_path, write_node.name(), source.firstpath()
-                    )
-                )
-
-            try:
-                head, padding, ext = os.path.basename(source_path).split(".")
-                source_first_frame = int(padding)
-            except Exception:
-                source_first_frame = 0
-
-            instances_data.append(
-                {
-                    "name": "{0}_{1}".format(track.name(), item.name()),
-                    "item": item,
-                    "source": source,
-                    "sourcePath": source_path,
-                    "track": track.name(),
-                    "sourceFirst": source_first_frame,
-                    "sourceIn": int(item.sourceIn()),
-                    "sourceOut": int(item.sourceOut()),
-                    "clipIn": int(item.timelineIn()),
-                    "clipOut": int(item.timelineOut())
-                }
-            )
-
-        for data in instances_data:
-            data.update(
-                {
-                    "asset": data["item"].name(),
-                    "family": "clip",
-                    "families": [],
-                    "handles": 0,
-                    "handleStart": projectdata.get("handles", 0),
-                    "handleEnd": projectdata.get("handles", 0),
-                    "version": int(version)
-                }
-            )
-            instance = context.create_instance(**data)
-            self.log.debug(
-                "Created instance with data: {}".format(instance.data)
-            )
-            context.data["assetsShared"][data["asset"]] = dict()
+        context.data["trackEffects"] = track_effects
+        self.log.debug(">> sub_track_items: `{}`".format(track_effects))

pype/plugins/nukestudio/publish/collect_effects.py

@@ -1,7 +1,7 @@
 import pyblish.api
-import hiero.core
 import re
 
+
 class CollectVideoTracksLuts(pyblish.api.InstancePlugin):
     """Collect video tracks effects into context."""
 
@@ -15,15 +15,57 @@ class CollectVideoTracksLuts(pyblish.api.InstancePlugin):
 
         # taking active sequence
         subset = instance.data["subset"]
-        sequence = instance.context.data['activeSequence']
-        effects_on_tracks = instance.context.data.get("subTrackUsedTracks")
-        sub_track_items = instance.context.data.get("subTrackItems")
-        track = instance.data["track"]
+        track_effects = instance.context.data.get("trackEffects", {})
+        track_index = instance.data["trackIndex"]
+        effects = instance.data["effects"]
 
+        # creating context attribute
+        self.effects = {"assignTo": subset, "effects": dict()}
+
+        for sitem in effects:
+            self.add_effect(instance, track_index, sitem)
+
+        for t_index, sitems in track_effects.items():
+            for sitem in sitems:
+                if not t_index > track_index:
+                    continue
+                self.log.debug(">> sitem: `{}`".format(sitem))
+                self.add_effect(instance, t_index, sitem)
+
+        instance.data["effectTrackItems"] = self.effects
+
+        if len(instance.data.get("effectTrackItems", {}).keys()) > 0:
+            instance.data["families"] += ["lut"]
+            self.log.debug("effects.keys: {}".format(instance.data.get("effectTrackItems", {}).keys()))
+            self.log.debug("effects: {}".format(instance.data.get("effectTrackItems", {})))
+
+    def add_effect(self, instance, track_index, item):
+        track = item.parentTrack().name()
+        # node serialization
+        node = item.node()
+        node_serialized = self.node_serialisation(instance, node)
+
+        # collect timelineIn/Out
+        effect_t_in = int(item.timelineIn())
+        effect_t_out = int(item.timelineOut())
+
+        node_name = item.name()
+        node_class = re.sub(r"\d+", "", node_name)
+
+        self.effects["effects"].update({node_name: {
+            "class": node_class,
+            "timelineIn": effect_t_in,
+            "timelineOut": effect_t_out,
+            "subTrackIndex": item.subTrackIndex(),
+            "trackIndex": track_index,
+            "track": track,
+            "node": node_serialized
+        }})
+
+    def node_serialisation(self, instance, node):
+        node_serialized = {}
         timeline_in_h = instance.data["clipInH"]
         timeline_out_h = instance.data["clipOutH"]
-        timeline_in = instance.data["clipIn"]
-        timeline_out = instance.data["clipOut"]
 
         # adding ignoring knob keys
         _ignoring_keys = ['invert_mask', 'help', 'mask',
@@ -33,81 +75,21 @@ class CollectVideoTracksLuts(pyblish.api.InstancePlugin):
                           'postage_stamp_frame', 'maskChannel', 'export_cc',
                           'select_cccid', 'mix', 'version']
 
-        # creating context attribute
-        effects = {"assignTo": subset, "effects": dict()}
-
-        for subtrack_item in sub_track_items:
-            sub_track = subtrack_item.parentTrack().name()
-
-            # ignore anything not EffectTrackItem
-            if not isinstance(subtrack_item, hiero.core.EffectTrackItem):
-                continue
-            et_item = subtrack_item
-
-            # ignore item if not enabled
-            if not et_item.isEnabled():
+        # loop trough all knobs and collect not ignored
+        # and any with any value
+        for knob in node.knobs().keys():
+            # skip nodes in ignore keys
+            if knob in _ignoring_keys:
                 continue
 
-            node = et_item.node()
-            node_serialized = {}
-            # loop trough all knobs and collect not ignored
-            # and any with any value
-            for knob in node.knobs().keys():
-                # skip nodes in ignore keys
-                if knob in _ignoring_keys:
-                    continue
+            # get animation if node is animated
+            if node[knob].isAnimated():
+                # grab animation including handles
+                knob_anim = [node[knob].getValueAt(i)
+                             for i in range(timeline_in_h, timeline_out_h + 1)]
 
-                # get animation if node is animated
-                if node[knob].isAnimated():
-                    # grab animation including handles
-                    knob_anim = [node[knob].getValueAt(i)
-                                 for i in range(timeline_in_h, timeline_out_h + 1)]
+                node_serialized[knob] = knob_anim
+            else:
+                node_serialized[knob] = node[knob].value()
 
-                    node_serialized[knob] = knob_anim
-                else:
-                    node_serialized[knob] = node[knob].value()
-
-            # pick track index from subTrackItem
-            pick_sub_track = [indx for indx, vt
-                              in enumerate(sequence.videoTracks())
-                              if vt.name() in sub_track]
-            # pick track index from trackItem
-            pick_track = [indx for indx, vt in enumerate(sequence.videoTracks())
-                          if vt.name() in track]
-            # collect timelineIn/Out
-            effect_t_in = int(et_item.timelineIn())
-            effect_t_out = int(et_item.timelineOut())
-
-            # controle if parent track has video trackItems
-            items_check = et_item.parent().items()
-
-            node_name = et_item.name()
-            node_class = re.sub(r"\d+", "", node_name)
-            # filter out all track items under any track with effects
-            # also filter out track item bellow
-            if (pick_track[0] in effects_on_tracks) and (pick_sub_track[0] >= pick_track[0]):
-                if (effect_t_in == timeline_in) and (effect_t_out == timeline_out):
-                    effects["effects"].update({node_name: {
-                        "class": node_class,
-                        "timelineIn": effect_t_in,
-                        "timelineOut": effect_t_out,
-                        "subTrackIndex": et_item.subTrackIndex(),
-                        "trackIndex": pick_track[0],
-                        "node": node_serialized
-                    }})
-                # for subTrackItem on track without any trackItems
-                elif len(items_check) == 0:
-                    effects["effects"].update({node_name: {
-                        "class": node_class,
-                        "timelineIn": effect_t_in,
-                        "timelineOut": effect_t_out,
-                        "subTrackIndex": et_item.subTrackIndex(),
-                        "trackIndex": pick_track[0],
-                        "node": node_serialized
-                    }})
-
-        instance.data["effectTrackItems"] = effects
-        if len(instance.data.get("effectTrackItems", {}).keys()) > 0:
-            instance.data["families"] += ["lut"]
-            self.log.debug("effects.keys: {}".format(instance.data.get("effectTrackItems", {}).keys()))
-            self.log.debug("effects: {}".format(instance.data.get("effectTrackItems", {})))
+        return node_serialized

pype/plugins/nukestudio/publish/collect_selection.py

@@ -14,12 +14,4 @@ class CollectSelection(pyblish.api.ContextPlugin):
 
         self.log.debug("selection: {}".format(selection))
 
-        # if not selection:
-        #     self.log.debug(
-        #         "Nothing is selected. Collecting all items from sequence "
-        #         "\"{}\"".format(hiero.ui.activeSequence())
-        #     )
-        #     for track in hiero.ui.activeSequence().items():
-        #         selection.extend(track.items())
-
         context.data["selection"] = selection