def update(self, container, representation): """Update the Loader's path Nuke automatically tries to reset some variables when changing the loader's path to a new file. These automatic changes are to its inputs: """ from avalon.nuke import ( update_container ) node = nuke.toNode(container['objectName']) root = api.get_representation_path(representation).replace("\\", "/") # Get start frame from version data version = io.find_one({ "type": "version", "_id": representation["parent"] }) # get all versions in list versions = io.find({ "type": "version", "parent": version["parent"] }).distinct('name') max_version = max(versions) updated_dict = {} updated_dict.update({ "representation": str(representation["_id"]), "frameEnd": version["data"].get("frameEnd"), "version": version.get("name"), "colorspace": version["data"].get("colorspace"), "source": version["data"].get("source"), "handles": version["data"].get("handles"), "fps": version["data"].get("fps"), "author": version["data"].get("author"), "outputDir": version["data"].get("outputDir"), }) # Update the imprinted representation update_container( node, updated_dict ) node["file"].setValue(root) # change color of node if version.get("name") not in [max_version]: node["tile_color"].setValue(int("0xd84f20ff", 16)) else: node["tile_color"].setValue(int("0xff0ff0ff", 16)) self.log.info("udated to version: {}".format(version.get("name")))
def update(self, container, representation): """Update the Loader's path Fusion automatically tries to reset some variables when changing the loader's path to a new file. These automatic changes are to its inputs: """ from avalon.nuke import ( viewer_update_and_undo_stop, ls_img_sequence, update_container ) log.info("this i can see") node = container["_tool"] # TODO: prepare also for other readers img/geo/camera assert node.Class() == "Reader", "Must be Reader" root = api.get_representation_path(representation) file = ls_img_sequence(os.path.dirname(root), one=True) # Get start frame from version data version = io.find_one({"type": "version", "_id": representation["parent"]}) start = version["data"].get("startFrame") if start is None: log.warning("Missing start frame for updated version" "assuming starts at frame 0 for: " "{} ({})".format(node['name'].value(), representation)) start = 0 with viewer_update_and_undo_stop(): # Update the loader's path whilst preserving some values with preserve_trim(node): with preserve_inputs(node, knobs=["file", "first", "last", "originfirst", "originlast", "frame_mode", "frame"]): node["file"] = file["path"] # Set the global in to the start frame of the sequence global_in_changed = loader_shift(node, start, relative=False) if global_in_changed: # Log this change to the user log.debug("Changed '{}' global in:" " {:d}".format(node['name'].value(), start)) # Update the imprinted representation update_container( node, {"representation": str(representation["_id"])} )
def update(self, container, representation): """Update the Loader's path Nuke automatically tries to reset some variables when changing the loader's path to a new file. These automatic changes are to its inputs: """ # get main variables # Get version from io version = io.find_one({ "type": "version", "_id": representation["parent"] }) # get corresponding node GN = nuke.toNode(container['objectName']) file = api.get_representation_path(representation).replace("\\", "/") name = container['name'] version_data = version.get("data", {}) vname = version.get("name", None) first = version_data.get("frameStart", None) last = version_data.get("frameEnd", None) namespace = container['namespace'] colorspace = version_data.get("colorspace", None) object_name = "{}_{}".format(name, namespace) add_keys = [ "frameStart", "frameEnd", "handleStart", "handleEnd", "source", "author", "fps" ] data_imprint = { "representation": str(representation["_id"]), "frameStart": first, "frameEnd": last, "version": vname, "colorspaceInput": colorspace, "objectName": object_name } for k in add_keys: data_imprint.update({k: version_data[k]}) # adding nodes to node graph # just in case we are in group lets jump out of it nuke.endGroup() with anlib.maintained_selection(): xpos = GN.xpos() ypos = GN.ypos() avalon_data = anlib.get_avalon_knob_data(GN) nuke.delete(GN) # add group from nk nuke.nodePaste(file) GN = nuke.selectedNode() anlib.set_avalon_knob_data(GN, avalon_data) GN.setXYpos(xpos, ypos) GN["name"].setValue(object_name) # get all versions in list versions = io.find({ "type": "version", "parent": version["parent"] }).distinct('name') max_version = max(versions) # change color of node if version.get("name") not in [max_version]: GN["tile_color"].setValue(int("0xd88467ff", 16)) else: GN["tile_color"].setValue(int(self.node_color, 16)) self.log.info("udated to version: {}".format(version.get("name"))) return update_container(GN, data_imprint)
def update(self, container, representation): """Update the Loader's path Nuke automatically tries to reset some variables when changing the loader's path to a new file. These automatic changes are to its inputs: """ from avalon.nuke import (update_container) # get main variables # Get version from io version = io.find_one({ "type": "version", "_id": representation["parent"] }) # get corresponding node GN = nuke.toNode(container['objectName']) file = api.get_representation_path(representation).replace("\\", "/") name = container['name'] version_data = version.get("data", {}) vname = version.get("name", None) first = version_data.get("frameStart", None) last = version_data.get("frameEnd", None) workfile_first_frame = int(nuke.root()["first_frame"].getValue()) namespace = container['namespace'] colorspace = version_data.get("colorspace", None) object_name = "{}_{}".format(name, namespace) add_keys = [ "frameStart", "frameEnd", "handleStart", "handleEnd", "source", "author", "fps" ] data_imprint = { "representation": str(representation["_id"]), "frameStart": first, "frameEnd": last, "version": vname, "colorspaceInput": colorspace, "objectName": object_name } for k in add_keys: data_imprint.update({k: version_data[k]}) # Update the imprinted representation update_container(GN, data_imprint) # getting data from json file with unicode conversion with open(file, "r") as f: json_f = { self.byteify(key): self.byteify(value) for key, value in json.load(f).iteritems() } # get correct order of nodes by positions on track and subtrack nodes_order = self.reorder_nodes(json_f["effects"]) # adding nodes to node graph # just in case we are in group lets jump out of it nuke.endGroup() # adding content to the group node with GN: # first remove all nodes [nuke.delete(n) for n in nuke.allNodes()] # create input node pre_node = nuke.createNode("Input") pre_node["name"].setValue("rgb") for ef_name, ef_val in nodes_order.items(): node = nuke.createNode(ef_val["class"]) for k, v in ef_val["node"].items(): if k in self.ignore_attr: continue try: node[k].value() except NameError as e: self.log.warning(e) continue if isinstance(v, list) and len(v) > 3: node[k].setAnimated() for i, value in enumerate(v): if isinstance(value, list): for ci, cv in enumerate(value): node[k].setValueAt( cv, (workfile_first_frame + i), ci) else: node[k].setValueAt(value, (workfile_first_frame + i)) else: node[k].setValue(v) node.setInput(0, pre_node) pre_node = node # create output node output = nuke.createNode("Output") output.setInput(0, pre_node) # try to place it under Viewer1 if not self.connect_active_viewer(GN): nuke.delete(GN) return # get all versions in list versions = io.find({ "type": "version", "parent": version["parent"] }).distinct('name') max_version = max(versions) # change color of node if version.get("name") not in [max_version]: GN["tile_color"].setValue(int("0xd84f20ff", 16)) else: GN["tile_color"].setValue(int("0x3469ffff", 16)) self.log.info("udated to version: {}".format(version.get("name")))
def update(self, container, representation): """Update the Loader's path Nuke automatically tries to reset some variables when changing the loader's path to a new file. These automatic changes are to its inputs: """ from avalon.nuke import (update_container) node = nuke.toNode(container['objectName']) assert node.Class() == "Read", "Must be Read" repr_cont = representation["context"] file = api.get_representation_path(representation) if not file: repr_id = representation["_id"] self.log.warning( "Representation id `{}` is failing to load".format(repr_id)) return file = file.replace("\\", "/") if "#" not in file: frame = repr_cont.get("frame") if frame: padding = len(frame) file = file.replace(frame, "#" * padding) # Get start frame from version data version = io.find_one({ "type": "version", "_id": representation["parent"] }) # get all versions in list versions = io.find({ "type": "version", "parent": version["parent"] }).distinct('name') max_version = max(versions) version_data = version.get("data", {}) self.first_frame = int(nuke.root()["first_frame"].getValue()) self.handle_start = version_data.get("handleStart", 0) self.handle_end = version_data.get("handleEnd", 0) first = version_data.get("frameStart") last = version_data.get("frameEnd") if first is None: self.log.warning("Missing start frame for updated version" "assuming starts at frame 0 for: " "{} ({})".format(node['name'].value(), representation)) first = 0 first -= self.handle_start last += self.handle_end # Update the loader's path whilst preserving some values with preserve_trim(node): node["file"].setValue(file) self.log.info("__ node['file']: {}".format(node["file"].value())) # Set the global in to the start frame of the sequence loader_shift(node, first, relative=True) node["origfirst"].setValue(int(first)) node["first"].setValue(int(first)) node["origlast"].setValue(int(last)) node["last"].setValue(int(last)) updated_dict = {} updated_dict.update({ "representation": str(representation["_id"]), "frameStart": str(first), "frameEnd": str(last), "version": str(version.get("name")), "colorspace": version_data.get("colorspace"), "source": version_data.get("source"), "handleStart": str(self.handle_start), "handleEnd": str(self.handle_end), "fps": str(version_data.get("fps")), "author": version_data.get("author"), "outputDir": version_data.get("outputDir"), }) # change color of node if version.get("name") not in [max_version]: node["tile_color"].setValue(int("0xd84f20ff", 16)) else: node["tile_color"].setValue(int("0x4ecd25ff", 16)) if version_data.get("retime", None): speed = version_data.get("speed", 1) time_warp_nodes = version_data.get("timewarps", []) self.make_retimes(node, speed, time_warp_nodes) # Update the imprinted representation update_container(node, updated_dict) self.log.info("udated to version: {}".format(version.get("name")))
def update(self, container, representation): """Update the Loader's path Nuke automatically tries to reset some variables when changing the loader's path to a new file. These automatic changes are to its inputs: """ from avalon.nuke import (update_container) read_node = nuke.toNode(container['objectName']) assert read_node.Class() == "Read", "Must be Read" file = self.fname if not file: repr_id = representation["_id"] self.log.warning( "Representation id `{}` is failing to load".format(repr_id)) return file = file.replace("\\", "/") # Get start frame from version data version = io.find_one({ "type": "version", "_id": representation["parent"] }) # get all versions in list versions = io.find({ "type": "version", "parent": version["parent"] }).distinct('name') max_version = max(versions) version_data = version.get("data", {}) orig_first = version_data.get("frameStart") orig_last = version_data.get("frameEnd") diff = orig_first - 1 # set first to 1 first = orig_first - diff last = orig_last - diff handles = version_data.get("handles", 0) handle_start = version_data.get("handleStart", 0) handle_end = version_data.get("handleEnd", 0) colorspace = version_data.get("colorspace") if first is None: self.log.warning(("Missing start frame for updated version" "assuming starts at frame 0 for: " "{} ({})").format(read_node['name'].value(), representation)) first = 0 # fix handle start and end if none are available if not handle_start and not handle_end: handle_start = handles handle_end = handles # create handles offset (only to last, because of mov) last += handle_start + handle_end # Update the loader's path whilst preserving some values with preserve_trim(read_node): read_node["file"].setValue(file) self.log.info("__ node['file']: {}".format( read_node["file"].value())) # Set the global in to the start frame of the sequence read_node["origfirst"].setValue(first) read_node["first"].setValue(first) read_node["origlast"].setValue(last) read_node["last"].setValue(last) # start at script start read_node['frame_mode'].setValue("start at") read_node['frame'].setValue(str(self.script_start)) if colorspace: read_node["colorspace"].setValue(str(colorspace)) preset_clrsp = get_imageio_input_colorspace(file) if preset_clrsp is not None: read_node["colorspace"].setValue(preset_clrsp) updated_dict = {} updated_dict.update({ "representation": str(representation["_id"]), "frameStart": str(first), "frameEnd": str(last), "version": str(version.get("name")), "colorspace": version_data.get("colorspace"), "source": version_data.get("source"), "handleStart": str(handle_start), "handleEnd": str(handle_end), "fps": str(version_data.get("fps")), "author": version_data.get("author"), "outputDir": version_data.get("outputDir") }) # change color of node if version.get("name") not in [max_version]: read_node["tile_color"].setValue(int("0xd84f20ff", 16)) else: read_node["tile_color"].setValue(int("0x4ecd25ff", 16)) # Update the imprinted representation update_container(read_node, updated_dict) self.log.info("udated to version: {}".format(version.get("name")))
def update(self, container, representation): """Update the Loader's path Nuke automatically tries to reset some variables when changing the loader's path to a new file. These automatic changes are to its inputs: """ from avalon.nuke import (update_container) node = nuke.toNode(container['objectName']) # TODO: prepare also for other Read img/geo/camera assert node.Class() == "Read", "Must be Read" file = api.get_representation_path(representation) # Get start frame from version data version = io.find_one({ "type": "version", "_id": representation["parent"] }) # get all versions in list versions = io.find({ "type": "version", "parent": version["parent"] }).distinct('name') max_version = max(versions) version_data = version.get("data", {}) orig_first = version_data.get("frameStart", None) orig_last = version_data.get("frameEnd", None) diff = orig_first - 1 # set first to 1 first = orig_first - diff last = orig_last - diff handles = version_data.get("handles", 0) handle_start = version_data.get("handleStart", 0) handle_end = version_data.get("handleEnd", 0) if first is None: log.warning("Missing start frame for updated version" "assuming starts at frame 0 for: " "{} ({})".format(node['name'].value(), representation)) first = 0 # fix handle start and end if none are available if not handle_start and not handle_end: handle_start = handles handle_end = handles # create handles offset (only to last, because of mov) last += handle_start + handle_end # offset should be with handles so it match orig frame range offset_frame = orig_first + handle_start # Update the loader's path whilst preserving some values with preserve_trim(node): node["file"].setValue(file["path"]) log.info("__ node['file']: {}".format(node["file"].value())) # Set the global in to the start frame of the sequence loader_shift(node, first, relative=True) node["origfirst"].setValue(first) node["first"].setValue(first) node["origlast"].setValue(last) node["last"].setValue(last) node["frame_mode"].setValue("start at") node["frame"].setValue(str(offset_frame)) updated_dict = {} updated_dict.update({ "representation": str(representation["_id"]), "frameStart": version_data.get("frameStart"), "frameEnd": version_data.get("frameEnd"), "version": version.get("name"), "source": version_data.get("source"), "handles": version_data.get("handles"), "handleStart": version_data.get("handleStart"), "handleEnd": version_data.get("handleEnd"), "fps": version_data.get("fps"), "author": version_data.get("author"), "outputDir": version_data.get("outputDir"), }) # change color of node if version.get("name") not in [max_version]: node["tile_color"].setValue(int("0xd84f20ff", 16)) else: node["tile_color"].setValue(int("0x4ecd25ff", 16)) # Update the imprinted representation update_container(node, updated_dict) log.info("udated to version: {}".format(version.get("name")))
def update(self, container, representation): """Update the Loader's path Nuke automatically tries to reset some variables when changing the loader's path to a new file. These automatic changes are to its inputs: """ from avalon.nuke import (update_container) node = nuke.toNode(container["objectName"]) frame_number = node["first"].value() assert node.Class() == "Read", "Must be Read" repr_cont = representation["context"] file = api.get_representation_path(representation) if not file: repr_id = representation["_id"] self.log.warning( "Representation id `{}` is failing to load".format(repr_id)) return file = file.replace("\\", "/") frame = repr_cont.get("frame") if frame: padding = len(frame) file = file.replace(frame, format(frame_number, "0{}".format(padding))) # Get start frame from version data version = io.find_one({ "type": "version", "_id": representation["parent"] }) # get all versions in list versions = io.find({ "type": "version", "parent": version["parent"] }).distinct('name') max_version = max(versions) version_data = version.get("data", {}) last = first = int(frame_number) # Set the global in to the start frame of the sequence node["file"].setValue(file) node["origfirst"].setValue(first) node["first"].setValue(first) node["origlast"].setValue(last) node["last"].setValue(last) updated_dict = {} updated_dict.update({ "representation": str(representation["_id"]), "frameStart": str(first), "frameEnd": str(last), "version": str(version.get("name")), "colorspace": version_data.get("colorspace"), "source": version_data.get("source"), "fps": str(version_data.get("fps")), "author": version_data.get("author"), "outputDir": version_data.get("outputDir"), }) # change color of node if version.get("name") not in [max_version]: node["tile_color"].setValue(int("0xd84f20ff", 16)) else: node["tile_color"].setValue(int("0x4ecd25ff", 16)) # Update the imprinted representation update_container(node, updated_dict) self.log.info("udated to version: {}".format(version.get("name")))
def update(self, container, representation): """ Called by Scene Inventory when look should be updated to current version. If any reference edits cannot be applied, eg. shader renamed and material not present, reference is unloaded and cleaned. All failed edits are highlighted to the user via message box. Args: container: object that has look to be updated representation: (dict): relationship data to get proper representation from DB and persisted data in .json Returns: None """ # Get version from io version = io.find_one({ "type": "version", "_id": representation["parent"] }) object_name = container['objectName'] # get corresponding node camera_node = nuke.toNode(object_name) # get main variables version_data = version.get("data", {}) vname = version.get("name", None) first = version_data.get("frameStart", None) last = version_data.get("frameEnd", None) fps = version_data.get("fps") or nuke.root()["fps"].getValue() # prepare data for imprinting # add additional metadata from the version to imprint to Avalon knob add_keys = ["source", "author", "fps"] data_imprint = { "representation": str(representation["_id"]), "frameStart": first, "frameEnd": last, "version": vname, "objectName": object_name } for k in add_keys: data_imprint.update({k: version_data[k]}) # getting file path file = api.get_representation_path(representation).replace("\\", "/") with anlib.maintained_selection(): camera_node = nuke.toNode(object_name) camera_node['selected'].setValue(True) # collect input output dependencies dependencies = camera_node.dependencies() dependent = camera_node.dependent() camera_node["frame_rate"].setValue(float(fps)) camera_node["file"].setValue(file) # workaround because nuke's bug is # not adding animation keys properly xpos = camera_node.xpos() ypos = camera_node.ypos() nuke.nodeCopy("%clipboard%") nuke.delete(camera_node) nuke.nodePaste("%clipboard%") camera_node = nuke.toNode(object_name) camera_node.setXYpos(xpos, ypos) # link to original input nodes for i, input in enumerate(dependencies): camera_node.setInput(i, input) # link to original output nodes for d in dependent: index = next((i for i, dpcy in enumerate(d.dependencies()) if camera_node is dpcy), 0) d.setInput(index, camera_node) # color node by correct color by actual version self.node_version_color(version, camera_node) self.log.info("udated to version: {}".format(version.get("name"))) return update_container(camera_node, data_imprint)