def _source_roto_template(self, step_name, proj_format):
     """
     Prompts user if they want to import the set Roto template for the New File.
     """
     if step_name == "Roto":
         roto_template = nuke.ask(
             "Source the default Nuke template for the <i style='color:magenta'><b><br>SSVFX Roto</b></i> workflow?"
         )
         if not roto_template:
             pass
         else:
             tk = self.parent.engine.sgtk
             roto_template_script = tk.templates["workfile_templates"]
             fields = {}
             roto_template_script_path = os.path.normpath(
                 roto_template_script.apply_fields(fields) +
                 "\\pipeline_task\\roto\\roto_rgb_template.nk")
             roto_template_script_path = roto_template_script_path.replace(
                 "/", os.path.sep)
             if os.path.exists(roto_template_script_path):
                 nuke.tprint("Importing Roto template:",
                             roto_template_script_path)
                 nuke.scriptSource(roto_template_script_path)
                 nuke.zoom(0.0)
                 try:
                     nuke.Root().knob('format').setValue(proj_format)
                 except:
                     nuke.tprint("!!! No proj_format called %s" %
                                 proj_format)
예제 #2
0
def goToActiveNthNode(nth):
    av = nuke.activeViewer()
    if nth - 1 < 0:
        avn = av.node().input(9)
    else:
        avn = av.node().input(nth - 1)
    nuke.zoom(1, [avn.xpos(), avn.ypos()])
예제 #3
0
def listbookmarks():
    
    bm=[]
    zoomBy=1

    #find bookmark nodes
    for n in nuke.allNodes():
        n['selected'].setValue( False )
        if n['icon'].value() == 'bookmark.png':
            n['selected'].setValue( True )      #select nodes for clarity
            bmLabel=nuke.selectedNode()['label'].value() 

            if bmLabel:
                bm_name='"'+bmLabel+'"' # '"'<-lets it list correctly
            else:
                bm_name='"'+n.name()+'"' # '"'<-allows it to be sorted correctly with above
            bm.append(bm_name)
    if 0==len(bm):
        nuke.message('no bookmarks found')
    else:
        bookmarkList=str(sorted(bm))  

        #clean up list name
        pattern = re.compile('[\[\]\']')
        bookmarkList = pattern.sub('', bookmarkList)
        pattern = re.compile('[\,]')
        bookmarkList = pattern.sub(' ', bookmarkList)

           
        #let user choose bookmark
        panel = nuke.Panel ('BookMarks',200)     
        panel.addEnumerationPulldown('go to',bookmarkList)
        panel.addSingleLineInput('zoom',zoomBy)
        panel.addBooleanCheckBox('also open node', False)          
        panel.addButton("Cancel")
        panel.addButton("Zoom to")
        panel.addButton("Open")
        result=panel.show()

        if result:
            goto= panel.value('go to')
            zoomf= panel.value('zoom')
            alwaysOpen= panel.value('also open node')

            #select only relevent node
            for n in nuke.allNodes():
                if goto == n.name() or goto == n['label'].value():
                    n['selected'].setValue( True )
                else:
                    n['selected'].setValue( False )

            #set nuke to highlight chosen node, get xy pos and zoom into area and open if selected.
            if result ==1:                  
                nuke.zoom(float(zoomf),(nuke.selectedNode().xpos(),nuke.selectedNode().ypos()))
                if alwaysOpen:
                    nuke.show(nuke.selectedNode())
            elif result ==2:                  
                nuke.show(nuke.selectedNode())
            else:
                pass
예제 #4
0
    def process(self, context, plugin):

        # Get the errored instances
        failed = []
        for result in context.data["results"]:
            if (result["error"] is not None and result["instance"] is not None
                    and result["instance"] not in failed):
                failed.append(result["instance"])

        # Apply pyblish.logic to get the instances for the plug-in
        instances = pyblish.api.instances_by_plugin(failed, plugin)

        nodes_to_select = []
        for instance in instances:
            cls_instance = plugin()
            nodes_to_select.extend(cls_instance.get_plugin_nodes())

        # Deselect all nodes.
        for node in nuke.allNodes():
            node["selected"].setValue(False)

        # Selecting nodes
        for node in nodes_to_select:
            node["selected"].setValue(True)

        # Zoom to node
        xC = node.xpos() + node.screenWidth() / 2
        yC = node.ypos() + node.screenHeight() / 2
        nuke.zoom(3, [xC, yC])
예제 #5
0
def shuffleNameCollect():
    nodes = nuke.selectedNodes()
    info = []

    if nodes == []:
        pass

    elif nodes != []:
        for node in nodes:
            if node.Class() == "Shuffle1" or node.Class() == "Shuffle":
                info.append(node.knob("in").value())

        if info != []:
            node = nuke.selectedNode()
            path = node.metadata('input/filename')
            spliteado = (os.path.splitext(
                os.path.basename(path))[0]).split("_")
            killframes = spliteado.pop()
            newfilename = ("_").join(spliteado)

            sticky = nuke.nodes.StickyNote(
                label='#########' + newfilename + '#########' + '\n' +
                (', '
                 '\n'.join(info)),
                note_font_size=80,
            )
            nuke.show(sticky)
            nuke.zoom(0.5, [sticky.xpos(), sticky.ypos()])

        else:
            nuke.message("please select a shuffle node")
예제 #6
0
def activePointsTo3D():
    # Make a list of all PointsTo3D
    pt3_nodes = []
    active_viewer = nuke.activeViewer().activeInput()
    # Use opened panel to determine which PointsTo3D to affect
    for name in nuke.openPanels():
        node = nuke.toNode(name)
        if node.Class() == "PointsTo3D":
            pt3_nodes.append(node)
    # If there's no PointsTo3D properties open, check if viewer is looking at one
    if len(pt3_nodes) == 0:
        node = nuke.activeViewer().node().input(active_viewer)
        if node.Class() == "PointsTo3D":
            node.showControlPanel()
            pt3_nodes.append(node)
    # If there's still no eligible PointsTo3D, check selected nodes
    if len(pt3_nodes) == 0:
        for node in nuke.selectedNodes():
            if node.Class() == "PointsTo3D":
                node.showControlPanel()
                pt3_nodes.append(node)
    # At this point we're just gonna make one
    if len(pt3_nodes) == 0:
        node = nuke.nodes.PointsTo3D()
        node.setInput(0, nuke.activeViewer().node().input(active_viewer))
        node.showControlPanel()
        nuke.zoom(3, [node.xpos(), node.ypos()])
        pt3_nodes.append(node)

    # Return the PointsTo3D nodes list
    return pt3_nodes
예제 #7
0
    def reset(self):
        """Reset field."""
        for unit in self._units:
            unit.reset()

        # Zoom on the field
        nuke.zoom(0)
예제 #8
0
def jump_to_the_edge_node(place):

    print(place)
    edge_node = get_edge_node(place)
    if edge_node is None:
        return
    nuke.zoom(1, (float(edge_node.xpos()), float(edge_node.ypos())))
예제 #9
0
    def process(self, context, plugin):

        # Get the errored instances
        failed = []
        for result in context.data["results"]:
            if (result["error"] is not None and result["instance"] is not None
                    and result["instance"] not in failed):
                failed.append(result["instance"])

        # Apply pyblish.logic to get the instances for the plug-in
        instances = pyblish.api.instances_by_plugin(failed, plugin)

        all_xC = list()
        all_yC = list()

        # maintain selection
        with anlib.maintained_selection():
            # collect all failed nodes xpos and ypos
            for instance in instances:
                bdn = instance[0]
                xC = bdn.xpos() + bdn.screenWidth() / 2
                yC = bdn.ypos() + bdn.screenHeight() / 2

                all_xC.append(xC)
                all_yC.append(yC)

        self.log.info("all_xC: `{}`".format(all_xC))
        self.log.info("all_yC: `{}`".format(all_yC))

        # zoom to nodes in node graph
        nuke.zoom(2, [min(all_xC), min(all_yC)])
예제 #10
0
def jump_to_edge_node(which):
    # print "jump to edge node: {}".format(get_edge_node(which).name())
    edge_node = get_edge_node(which)

    if edge_node is None:
        return

    nuke.zoom(1, [float(edge_node.xpos()), float(edge_node.ypos())])
예제 #11
0
def centerOnTarget(selNode):
    for node in nuke.selectedNodes():
        node['selected'].setValue(0)
    selNode['selected'].setValue(True)
    x = selNode['xpos'].value()
    y = selNode['ypos'].value()
    nuke.zoom(1, (x, y))
    selNode['selected'].setValue(False)
예제 #12
0
def zoom(direction, factor=0.5):
    z = nuke.zoom()
    value = z * factor
    if direction == '+':
        v = z + value
    elif direction == '-':
        v = z - value
    nuke.zoom(v, nuke.center())
예제 #13
0
 def center_selected_node(self):
     selected_cell = QtWidgets.QTableWidget.selectedItems(self.read_files_list)
     selected_cell_text = selected_cell[0].text()
     selected_node = nuke.toNode(selected_cell_text)
     if selected_node != None:
         nuke.zoom(2, [float(selected_node.xpos()), float(selected_node.ypos())])
     else:
         nuke.message('Please select a NODE name.')
예제 #14
0
 def update(self):
     nuke.selectAll()
     nuke.invertSelection()
     a.nodeList[self.things.currentRow()].knob('selected').setValue(True)
     node = nuke.selectedNode()
     xC = node.xpos() + node.screenWidth()/2
     yC = node.ypos() + node.screenHeight()/2
     nuke.zoom( 2, [ xC, yC ])
예제 #15
0
 def update(self):
     nuke.selectAll()
     nuke.invertSelection()
     a.nodeList[self.things.currentRow()].knob('selected').setValue(True)
     node = nuke.selectedNode()
     xC = node.xpos() + node.screenWidth() / 2
     yC = node.ypos() + node.screenHeight() / 2
     nuke.zoom(2, [xC, yC])
예제 #16
0
파일: stamps.py 프로젝트: kuchinal/lamakaha
def wiredZoomAnchor():
    n = nuke.thisNode()
    if n.inputs():
        ni = n.input(0)
        nuke.zoom(nuke.zoom(), [
            ni.xpos() + ni.screenWidth() / 2,
            ni.ypos() + ni.screenHeight() / 2
        ])
예제 #17
0
    def editorEvent(self, event, model, option, index):
        """

        :param event:
        :type event: QEvent
        :param model:
        :type model: NodeModel
        :param option:
        :type option: QStyleOptionViewItem
        :param index:
        :type index: QModelIndex
        :return:
        :rtype: bool
        """
        idx = index.model().mapToSource(index)
        item = model.sourceModel().itemFromIndex(idx)
        row = item.get_parent_row()

        if event.type() != QMouseEvent.MouseButtonRelease:
            return False

        if type(row) == ClassRow:
            if event.button() == Qt.MouseButton.LeftButton:
                if item.get_header() == 'Disable':
                    if 'disable' in row.get_node_rows()[0].get_node().knobs().keys():
                                                                # assuming if one child NodeRow has a disable knob
                                                                # all child rows for that ClassRow do as well
                        if item.checkState() == Qt.Checked:
                            check_state = Qt.Unchecked
                        else:
                            check_state = Qt.Checked
                        item.setCheckState(check_state)
                        for node_row in row.get_node_rows():
                            node_row.get_item('Disable').setCheckState(check_state)
                            node_row.get_node().knob('disable').setValue(check_state == Qt.Checked)

                    return True

        elif type(row) == NodeRow:
            if event.button() == Qt.MouseButton.LeftButton:
                if item.get_header() == 'Node':
                    node = item.get_parent_row().get_node()
                    nuke.zoom(3, (node.xpos() + (node.screenWidth()/2), node.ypos() + (node.screenHeight()/2)))

                    return True
                elif item.get_header() == 'Disable':
                    if 'disable' in row.get_node().knobs().keys():
                        if item.checkState() == Qt.Checked:
                            check_state = Qt.Unchecked
                        else:
                            check_state = Qt.Checked
                        item.setCheckState(check_state)
                        row.get_item('Disable').setCheckState(check_state)
                        row.get_node().knob('disable').setValue(check_state == Qt.Checked)

                    return True
        return False
예제 #18
0
def centerNodeInNodeGraph(node):
    try:
        xpos = node["xpos"].value()
        ypos = node["ypos"].value()
        factor = 1.0
        nukescripts.clear_selection_recursive()
        node["selected"].setValue(True)
        nuke.zoom(factor, (xpos, ypos))
    except:
        pass
예제 #19
0
 def import_pictures(self, sequence_dir, sep):
     all_read_file = [read_node['file'].getValue()
                      for read_node in nuke.allNodes('Read')]
     all_read_file = list(set(all_read_file))
     start_frame, end_frame = self.get_frame_range(sequence_dir, sep)
     read_file_name = self.get_frame_profile(sequence_dir, sep)
     if read_file_name:
         read_file_name = read_file_name.replace('\\', '/')
     if all((start_frame, end_frame)) and read_file_name not in all_read_file:
         read_node = nuke.nodes.Read(file=read_file_name)
         self.fix_read_node(read_node, start_frame, end_frame)
         nuke.zoom(1, [read_node.xpos(), read_node.ypos()])
예제 #20
0
 def go_node(self):
     # init the sender
     sender = self.sender()
     # get the node name
     nodeName = sender.property("nodeName")
     # point into the node
     node = nuke.toNode(nodeName)
     # get the xC and yC values
     xC = node.xpos() + node.screenWidth() / 2
     yC = node.ypos() + node.screenHeight() / 2
     # focus on the node (distance 2)
     nuke.zoom(2, [xC, yC])
예제 #21
0
def load_dag_pos(preset):
    # Load dag zoom and position from specified preset number
    viewer = nuke.activeViewer()
    if not viewer:
        nuke.message('Error: please create a viewer to store the dag positions on...')
        return
    viewer = viewer.node()
    if 'dagpos' not in viewer.knobs():
        nuke.message('No preset positions created yet...')
        return
    dagpos_knob = viewer['dagpos']
    dagpos_vals = dagpos_knob.getValue().split(':')[preset-1]
    zoom, xpos, ypos = dagpos_vals.split(',')
    nuke.zoom(float(zoom), [float(xpos), float(ypos)])
예제 #22
0
파일: menu.py 프로젝트: movalex/Nuke_prefs
def jopsBookmarkRestore(index):
    zoomNameString  = "jops_bookmark_"+str(index)+"_zoom"
    posNameString   = "jops_bookmark_"+str(index)+"_pos"
 
    try:
        z = nuke.root()[zoomNameString]
        p = nuke.root()[posNameString]
        if z.enabled():
            zoom = z.getValue()
            xpos = p.x()
            ypos = p.y()
            pos = [xpos, ypos]
            nuke.zoom(zoom, pos)
    except (SyntaxError, NameError):
        pass
예제 #23
0
def sb_loadDagPosition(num):

    ''' Read value from knob and focus DAG. '''

    if num<1 or num>10:
        nuke.message("Currently support for position 1-10.")
        return

    try:
        dagKnob = nuke.root()["sb_dagPosition"]
        dagPosValues = dagKnob.value().split(";")[num-1]
        zoom, xpos, ypos = dagPosValues.split(",")
        nuke.zoom(float(zoom), [float(xpos), float(ypos)])
    except Exception as e:
        nuke.message("sb DAGPosition couldn't load position values.\n\nERROR: {0}.".format(e))
예제 #24
0
def save_dag_pos(preset):
    # Save current dag zoom and position as a preset on the active viewer
    zoom = nuke.zoom()
    pos = nuke.center()
    viewer = nuke.activeViewer()
    if not viewer:
        nuke.message(
            'Error: please create a viewer to store the dag positions on...')
        return
    else:
        viewer = viewer.node()
    if 'dagpos' not in viewer.knobs():
        viewer.addKnob(
            nuke.String_Knob(
                'dagpos', 'dagpos',
                '0,0,0:0,0,0:0,0,0:0,0,0:0,0,0:0,0,0:0,0,0:0,0,0:0,0,0:0,0,0'))
        dagpos_knob = viewer['dagpos']
        dagpos_knob.setFlag(nuke.STARTLINE)
        dagpos_knob.setEnabled(False)
    else:
        dagpos_knob = viewer['dagpos']
    dagpos_vals = dagpos_knob.getValue().split(':')
    dagpos_vals.pop(preset - 1)
    new_dagpos = ','.join([str(zoom), str(pos[0]), str(pos[1])])
    dagpos_vals.insert(preset - 1, new_dagpos)
    dagpos_knob.setValue(':'.join(dagpos_vals))
예제 #25
0
def cyclebookmarks(prt=False):
    '''Cycles between existent bookmarks'''

    global bookmarks
    if prt:
        print bookmarks

    if bookmarks is None:
        bookmarks = iter([
            n for n in nuke.allNodes() if n['icon'].value() == 'bookmark.png'
        ])
        if prt:
            print bookmarks

    try:
        n = bookmarks.next()
        n['selected'].setValue(True)
        if prt:
            print n['label'].value()

    except:
        bookmarks = iter([
            n for n in nuke.allNodes() if n['icon'].value() == 'bookmark.png'
        ])

    goTo = nuke.zoom(1, (n.xpos(), n.ypos()))
예제 #26
0
파일: zooom.py 프로젝트: vfxwiki/nuke
def zooomTo(item):
    '''
    zooom to item
    '''
    try:
        zooomLevel=item.split(",")
        zooomLevel[3] = zooomLevel[3].replace("\n", "")
        nuke.zoom(float(zooomLevel[1]), [float(zooomLevel[2]), float(zooomLevel[3])])
        
        print "zooom to %s" % zooomLevel[0] 
        print zooomLevel[1]
        print zooomLevel[2]
        print zooomLevel[3]

    except Exception, e:
        pass
예제 #27
0
파일: stamps.py 프로젝트: kuchinal/lamakaha
def wiredZoomNext(anchor_name=""):
    if anchor_name == "":
        anchor_name = nuke.thisNode().knob("anchor").value()
    anchor = nuke.toNode(anchor_name)
    showing_knob = anchor.knob("showing")
    showing_value = showing_knob.value()
    i = 0
    for ni in nuke.allNodes("NoOp"):
        if ni.knob("identifier") and ni.knob("anchor"):
            if ni.knob("identifier").value() == "wired" and ni.knob(
                    "anchor").value() == anchor_name:
                if i == showing_value:
                    nuke.zoom(nuke.zoom(), [ni.xpos(), ni.ypos()])
                    showing_knob.setValue(i + 1)
                    return
                i += 1
    showing_knob.setValue(0)
    nuke.message("Couldn't find any more similar wired stamps.")
예제 #28
0
    def zoomToNode(self):

        log("zoomToNode '%s'" % self.zoomTargetNode)

        if (not self.zoomTargetNode):
            return

        node = nuke.toNode(self.zoomTargetNode)
        if (not node):
            return

        x = node['xpos'].value()
        y = node['ypos'].value()
        log("    target x %g y %g" % (x, y))
        if (abs(x) < 10000 and abs(y) < 10000):
            nuke.zoom(nuke.zoom(), [x, y])

        self.zoomTargetNode = None
예제 #29
0
파일: rvNuke.py 프로젝트: hradec/pipeVFX
    def zoomToNode (self) :

        log ("zoomToNode '%s'" % self.zoomTargetNode)

        if (not self.zoomTargetNode) :
            return

        node = nuke.toNode(self.zoomTargetNode)
        if (not node) :
            return

        x = node['xpos'].value()
        y = node['ypos'].value()
        log ("    target x %g y %g" % (x, y))
        if (abs(x) < 10000 and abs(y) < 10000) :
            nuke.zoom (nuke.zoom(), [x, y])

        self.zoomTargetNode = None
예제 #30
0
def node_under_cursor():
	dag_widget = get_DAG_widget()
	dag_center = QtCore.QPoint(*nuke.center())
	cursor_pos = QtGui.QCursor().pos()
	dag_widget_center = QtCore.QPoint((dag_widget.size().width()/ 2), (dag_widget.size().height()/2) )
	cursor_pos_in_dag = dag_widget.mapFromGlobal(cursor_pos)

	new_node_pos = ((cursor_pos_in_dag - dag_widget_center) / nuke.zoom() + dag_center)

	return list(new_node_pos.toTuple())
예제 #31
0
def singleClick():
    global currentRow
    currentRow = widget.ui.nuke_write_table.currentRow()
    n = widget.ui.nuke_write_table.currentItem()
    nodename = widget.ui.nuke_write_table.item(currentRow, 1).text()
    print nodename
    deselect()
    nuke.toNode(nodename)['selected'].setValue(True)
    node = nuke.selectedNode()
    nuke.zoom(1, [node.xpos(), node.ypos()])
    nuke.show(node)

    if widget.ui.nuke_write_table.currentColumn() == 0:
        disable = QtGui.QTableWidgetItem()
        if n.text() == "on":
            disable.setIcon(nukecrossicon)
            disable.setText("off")
            nuke.toNode(nodename)['disable'].setValue(True)

        elif n.text() == "off":
            disable.setIcon(nukecheckicon)
            disable.setText("on")
            nuke.toNode(nodename)['disable'].setValue(False)

        widget.ui.nuke_write_table.setItem(currentRow, 0, disable)

    elif widget.ui.nuke_write_table.currentColumn() == 1:
        global previousName
        previousName = widget.ui.nuke_write_table.currentItem().text()
    elif widget.ui.nuke_write_table.currentColumn() == 2:
        filename = widget.ui.job_name.text()
        pathname = widget.ui.image_folder.text()
        nodepath = pathname + "/" + nodename
        nodepath = nodepath.replace("/", "\\")
        if os.path.isdir(nodepath) is False:
            os.makedirs(nodepath)
예제 #32
0
    def run(self):
        # Store the current dag size and zoom
        original_zoom = nuke.zoom()
        original_center = nuke.center()
        # Calculate the total size of the DAG
        min_x, min_y, max_x, max_y = self.bbox
        zoom = self.zoom
        min_x -= int(self.margins / zoom)
        min_y -= int(self.margins / zoom)
        max_x += int(self.margins / zoom)
        max_y += int(self.margins / zoom)

        # Get the Dag Widget
        dag = self.dag

        # Check the size of the current widget, excluding the right side (because of minimap)
        capture_width = dag.width() - self.ignore_right
        capture_height = dag.height()

        # Calculate the number of tiles required to cover all
        image_width = int((max_x - min_x) * zoom)
        image_height = int((max_y - min_y) * zoom)
        horizontal_tiles = int(ceil(image_width / float(capture_width)))
        vertical_tiles = int(ceil(image_height / float(capture_height)))
        # Create a pixmap to store the results
        pixmap = QtGui.QPixmap(image_width, image_height)
        painter = QtGui.QPainter(pixmap)
        painter.setCompositionMode(painter.CompositionMode_SourceOver)
        # Move the dag so that the top left corner is in the top left corner, screenshot, paste in the pixmap, repeat
        for tile_x in range(horizontal_tiles):
            center_x = (min_x + capture_width / zoom * tile_x
                        ) + (capture_width + self.ignore_right) / zoom / 2
            for tile_y in range(vertical_tiles):
                center_y = (min_y + capture_height / zoom *
                            tile_y) + capture_height / zoom / 2
                nuke.executeInMainThread(nuke.zoom,
                                         (zoom, (center_x, center_y)))
                time.sleep(self.delay)
                nuke.executeInMainThread(grab_dag,
                                         (dag, painter, capture_width * tile_x,
                                          capture_height * tile_y))
        time.sleep(self.delay)
        painter.end()
        nuke.executeInMainThread(nuke.zoom, (original_zoom, original_center))
        save_sucessful = pixmap.save(self.path)
        if not save_sucessful:
            raise IOError("Failed to save PNG: %s" % self.path)
        self.successful = True
예제 #33
0
def sb_saveDagPosition(num):

    ''' Save DAG position in a text knob (Root node).'''

    if num<1 or num>10:
        nuke.message("Currently support for position 1-10.")
        return

    try:
        n = nuke.selectedNodes()[0]
    except IndexError:
        nuke.message("Select a node.")
        return

    zoom = nuke.zoom()
    xpos = n["xpos"].value()
    ypos = n["ypos"].value()

    try:
        dagKnob = nuke.root()["sb_dagPosition"]
    except NameError:
        conf = nuke.ask("sb DAGPosition needs to save position data in the Root node. Click Yes to continue.\n\nNote: This dialog will only pop up the first time you save a position.")
        if not conf:
            return

        dagKnob = nuke.String_Knob("sb_dagPosition", "sb DAGPosition")
        nuke.root().addKnob(dagKnob)
        dagKnob.setValue("0,0,0;0,0,0;0,0,0;0,0,0;0,0,0;0,0,0;0,0,0;0,0,0;0,0,0;0,0,0")
        dagKnob.setFlag(nuke.STARTLINE)
        dagKnob.setEnabled(False)
        nuke.root()["name"].setFlag(0)

    try:
        dagValues = dagKnob.value().split(";")
        dagValues.pop(num-1)
        newVal = ",".join( [str(zoom), str(xpos), str(ypos)] )
        dagValues.insert(num-1, newVal)
        dagKnob.setValue(";".join(dagValues))
    except Exception as e:
        nuke.message("sb DAGPosition couldn't save position values.\n\nERROR: {0}.".format(e))
        return False
예제 #34
0
def cyclebookmarks( prt=False ):
    
    '''Cycles between existent bookmarks'''
    
    global bookmarks
    if prt:
        print bookmarks
    
    if bookmarks is None:
        bookmarks = iter([n for n in nuke.allNodes() if n['icon'].value() == 'bookmark.png'])
        if prt:
            print bookmarks
    
    try:
        n = bookmarks.next()
        n['selected'].setValue( True )
        if prt:
            print n['label'].value()

    except:
        bookmarks = iter([n for n in nuke.allNodes() if n['icon'].value() == 'bookmark.png'])
    
    goTo = nuke.zoom(1,(n.xpos(),n.ypos()))
예제 #35
0
파일: zooom.py 프로젝트: vfxwiki/nuke
def registerPos(description):
    '''
    write item into nuke.ZOOOMDATA
    item must be next to last item which is the keyword for ending zooomdata 
    ''' 
    
    description=description.replace(" ", "_")
    
    if description !="":
        x = nuke.center()[0]
        y = nuke.center()[1]
        zooom = nuke.zoom()
        #format new zooomItem for nuke.ZOOOMDATA
        newZooomItem = "#"+description+",%d" % zooom +",%d" % x+",%d"% y +"\n" 
        
        #create start and end if not set yet
        if len(nuke.ZOOOMDATA)==0:
            nuke.ZOOOMDATA.append(zooomStart+"\n")
            nuke.ZOOOMDATA.append(zooomEnd)
        
        nuke.ZOOOMDATA.insert( (len(nuke.ZOOOMDATA)-1), newZooomItem)
    else:
        pass
예제 #36
0
def quickSave(slot):
    z = nuke.zoom()
    x = nuke.center()[0]
    y = nuke.center()[1]
    quickSaves[slot] = [z, x, y]
예제 #37
0
    def knobChanged( self, knob ): 
     
        #update
        if knob.name()=="update":
            
            #reset
            for btn in nuke.errors_footageBtn:
                self.removeKnob(btn)

            nuke.errors_footageBtn=[]
            errors=[]
            nuke.errors_nodes=[]
            nuke.errors_missingFrames=[]
            
            with nuke.root():
                all = nuke.allNodes()
                for n in all: 
                    if n.Class()!="Read":
                        if n.hasError():    
                            errors.append(n.name())
                            if n not in nuke.errors_nodes:
                                nuke.errors_nodes.append(n)
                    else:
                        for frame in range(int(n["first"].getValue()), int(n["last"].getValue())+1):
                            try:
                                f = nukescripts.replaceHashes(n['file'].value() ) % (frame)
                            except:
                                f = ""
                            if not os.path.isfile(f):
                                errors.append(f)
                                if f not in nuke.errors_missingFrames:
                                    nuke.errors_missingFrames.append(f)
                                if n not in nuke.errors_nodes:
                                    nuke.errors_nodes.append(n)

            for errorNode in nuke.errors_nodes:
                self.en = nuke.PyScript_Knob(errorNode.name(), errorNode.name())
                self.addKnob(self.en)   
                nuke.errors_footageBtn.append(self.en) 
            
            nuke.errors_lenErrors=len(errors)
           
            if nuke.errors_lenErrors==0:
                col="green"
            else:
                col="red"
            countErrors = '<span style="color:{col}">{countErr}</span>'.format(col=col, countErr=nuke.errors_lenErrors)
            self.errorCount.setValue(countErrors)
         
        #write
        if knob.name()=="write":
            if self.outputPath.getValue()!="":
                try:
                    script = os.path.basename(nuke.root().name())
                    output= os.path.dirname(self.outputPath.getValue()) + "/errorReport_%s" % script.replace(".nk",".txt")

                    errorOutput = open(output,'w')
                    date = time.strftime("%d-%m-%Y %H:%M:%S", time.gmtime())
                    header="error report \nscript name: {scriptname}\nscript path: {scriptPath}\ndate: {date}\nnumber of errors: {countErrors}\n------------------------------".format(scriptname=script, scriptPath=nuke.root().name(), date=date, countErrors=nuke.errors_lenErrors)
                    errorOutput.write(header)

                    #all read nodes
                    errorOutput.write("\nread nodes\n\n")
                    for n in nuke.errors_nodes:
                        if n.Class()=="Read":
                            errorOutput.write("read node: %s\n" % n.name())
                    #all missing frames
                    errorOutput.write("\n----------\nmissing frames\n\n")
                    for f in nuke.errors_missingFrames:
                        errorOutput.write("missing frame: %s\n" % f)
                    #all other nodes
                    errorOutput.write("\n----------\nother nodes\n\n")
                    for n in nuke.errors_nodes:
                        if n.Class()!="Read":
                            errorOutput.write("node: %s\n" % n.name())

                    nuke.message("successfully written error report to:\n\n%s" % output)
                except:
                    nuke.message("some error occured. The report could not be written.")
            else:
                nuke.message("Please enter a output path for the error report.")
         
        #all other error nodes   
        else:
            allNodes=nuke.allNodes()
            pKnob=knob.name()
            for n in allNodes:
                if n.name() == pKnob: 
                    nuke.zoom( 1, [ n.xpos(), n.ypos() ])
                    nukescripts.clear_selection_recursive()
                    n.setSelected(True)
예제 #38
0
def quickRestore(slot):
    try:
        nuke.zoom(quickSaves[slot][0],
                  [quickSaves[slot][1], quickSaves[slot][2]])
    except:
        return
예제 #39
0
def createNukeCornerPinNode(coordinatesArray):

    global frameHeight

    global frameOffset

    cornerPinNode = nuke.nodes.CornerPin2D(label='imported_Mocha-AE_Track')

    cornerPinNode['enable1'].setValue('true')
    cornerPinNode['enable2'].setValue('true')
    cornerPinNode['enable3'].setValue('true')
    cornerPinNode['enable4'].setValue('true')

    # LOWER LEFT

    track1 = cornerPinNode['to1']
    track1.setAnimated()
    track1keysX = []
    track1keysY = []

    for j in coordinatesArray[0]:
        tFrame = int(j[0]) + frameOffset
        tX = float(j[1])
        tY = frameHeight - float(j[2])

        track1keysX.append((tFrame, tX))
        track1keysY.append((tFrame, tY))

    #print "track1keysX: %s" % len(track1keysX)
    #print "track1keysY: %s" % len(track1keysY)

    # LOWER RIGHT

    track2 = cornerPinNode['to2']
    track2.setAnimated()
    track2keysX = []
    track2keysY = []

    for j in coordinatesArray[1]:
        tFrame = int(j[0]) + frameOffset
        tX = float(j[1])
        tY = frameHeight - float(j[2])

        track2keysX.append((tFrame, tX))
        track2keysY.append((tFrame, tY))

    #print "track2keysX: %s" % len(track1keysX)
    #print "track2keysY: %s" % len(track1keysY)

    # UPPER RIGHT

    track3 = cornerPinNode['to3']
    track3.setAnimated()
    track3keysX = []
    track3keysY = []

    for j in coordinatesArray[3]:
        tFrame = int(j[0]) + frameOffset
        tX = float(j[1])
        tY = frameHeight - float(j[2])

        track3keysX.append((tFrame, tX))
        track3keysY.append((tFrame, tY))

    #print "track3keysX: %s" % len(track3keysX)
    #print "track3keysY: %s" % len(track3keysY)

    # UPPER LEFT

    track4 = cornerPinNode['to4']
    track4.setAnimated()
    track4keysX = []
    track4keysY = []

    for j in coordinatesArray[2]:
        tFrame = int(j[0]) + frameOffset
        tX = float(j[1])
        tY = frameHeight - float(j[2])

        track4keysX.append((tFrame, tX))
        track4keysY.append((tFrame, tY))

    #print "track4keysX: %s" % len(track4keysX)
    #print "track4keysY: %s" % len(track4keysY)

    track1animX = track1.animation(0)
    track1animX.addKey(
        [nuke.AnimationKey(frame, value) for (frame, value) in track1keysX])

    track1animY = track1.animation(1)
    track1animY.addKey(
        [nuke.AnimationKey(frame, value) for (frame, value) in track1keysY])

    track2animX = track2.animation(0)
    track2animX.addKey(
        [nuke.AnimationKey(frame, value) for (frame, value) in track2keysX])

    track2animY = track2.animation(1)
    track2animY.addKey(
        [nuke.AnimationKey(frame, value) for (frame, value) in track2keysY])

    track3animX = track3.animation(0)
    track3animX.addKey(
        [nuke.AnimationKey(frame, value) for (frame, value) in track3keysX])

    track3animY = track3.animation(1)
    track3animY.addKey(
        [nuke.AnimationKey(frame, value) for (frame, value) in track3keysY])

    track4animX = track4.animation(0)
    track4animX.addKey(
        [nuke.AnimationKey(frame, value) for (frame, value) in track4keysX])

    track4animY = track4.animation(1)
    track4animY.addKey(
        [nuke.AnimationKey(frame, value) for (frame, value) in track4keysY])

    nuke.show(cornerPinNode)

    nuke.zoom(1, (cornerPinNode.xpos(), cornerPinNode.ypos()))

    return
def createNukeCornerPinNode(coordinatesArray):
    
    global frameHeight
    
    global frameOffset
    
    cornerPinNode = nuke.nodes.CornerPin2D(label='imported_Mocha-AE_Track')
    
    cornerPinNode['enable1'].setValue('true')
    cornerPinNode['enable2'].setValue('true')
    cornerPinNode['enable3'].setValue('true')
    cornerPinNode['enable4'].setValue('true')
    
    # LOWER LEFT
    
    track1 = cornerPinNode['to1']
    track1.setAnimated()
    track1keysX = []
    track1keysY = []
    
    for j in coordinatesArray[0]:
        tFrame = int(j[0]) + frameOffset
        tX = float(j[1])
        tY = frameHeight - float(j[2])
        
        track1keysX.append( (tFrame,tX) )
        track1keysY.append( (tFrame,tY) )
    
    #print "track1keysX: %s" % len(track1keysX)
    #print "track1keysY: %s" % len(track1keysY)
      
    # LOWER RIGHT
        
    track2 = cornerPinNode['to2']
    track2.setAnimated()
    track2keysX = []
    track2keysY = []
    
    for j in coordinatesArray[1]:
        tFrame = int(j[0]) + frameOffset
        tX = float(j[1])
        tY = frameHeight - float(j[2])
        
        track2keysX.append( (tFrame,tX) )
        track2keysY.append( (tFrame,tY) )
    
    #print "track2keysX: %s" % len(track1keysX)
    #print "track2keysY: %s" % len(track1keysY)
       
    # UPPER RIGHT
        
    track3 = cornerPinNode['to3']
    track3.setAnimated()
    track3keysX = []
    track3keysY = []
    
    for j in coordinatesArray[3]:
        tFrame = int(j[0]) + frameOffset
        tX = float(j[1])
        tY = frameHeight - float(j[2])
        
        track3keysX.append( (tFrame,tX) )
        track3keysY.append( (tFrame,tY) )
    
    #print "track3keysX: %s" % len(track3keysX)
    #print "track3keysY: %s" % len(track3keysY)
    
    # UPPER LEFT
        
    track4 = cornerPinNode['to4']
    track4.setAnimated()
    track4keysX = []
    track4keysY = []
    
    for j in coordinatesArray[2]:
        tFrame = int(j[0]) + frameOffset
        tX = float(j[1])
        tY = frameHeight - float(j[2])
        
        track4keysX.append( (tFrame,tX) )
        track4keysY.append( (tFrame,tY) )
    
    #print "track4keysX: %s" % len(track4keysX)
    #print "track4keysY: %s" % len(track4keysY)
    
    
    
    track1animX = track1.animation(0)
    track1animX.addKey([nuke.AnimationKey(frame, value) for (frame,value) in track1keysX])
    
    track1animY = track1.animation(1)
    track1animY.addKey([nuke.AnimationKey(frame, value) for (frame,value) in track1keysY])
    
    track2animX = track2.animation(0)
    track2animX.addKey([nuke.AnimationKey(frame, value) for (frame,value) in track2keysX])
    
    track2animY = track2.animation(1)
    track2animY.addKey([nuke.AnimationKey(frame, value) for (frame,value) in track2keysY])
    
    track3animX = track3.animation(0)
    track3animX.addKey([nuke.AnimationKey(frame, value) for (frame,value) in track3keysX])
    
    track3animY = track3.animation(1)
    track3animY.addKey([nuke.AnimationKey(frame, value) for (frame,value) in track3keysY])
    
    track4animX = track4.animation(0)
    track4animX.addKey([nuke.AnimationKey(frame, value) for (frame,value) in track4keysX])
    
    track4animY = track4.animation(1)
    track4animY.addKey([nuke.AnimationKey(frame, value) for (frame,value) in track4keysY])
    
    nuke.show(cornerPinNode)
    
    
    nuke.zoom(1, (cornerPinNode.xpos(), cornerPinNode.ypos() ) )
    
    return
예제 #41
0
def jopsBookmarkSave(index, mode='dag'):
    tabNameString   = "DAG_Bookmarks"
    try:
        nuke.root()[tabNameString]
    except (SyntaxError, NameError):
        nuke.root().addKnob(nuke.Tab_Knob(tabNameString))
        for ind in range(1,10):
            zoomNameString  = "jops_bookmark_"+str(ind)+"_zoom"
            posNameString   = "jops_bookmark_"+str(ind)+"_pos"
            xyKnob   = nuke.XY_Knob(posNameString, str(ind))
            zoomKnob = nuke.Double_Knob(zoomNameString, "")
            zoomKnob.setFlag(nuke.NO_ANIMATION)
            zoomKnob.setFlag(nuke.DISABLED)
            xyKnob.setFlag(nuke.NO_ANIMATION)
            xyKnob.setFlag(nuke.DISABLED)
            zoomKnob.clearFlag(nuke.STARTLINE)
            nuke.root().addKnob(xyKnob)
            nuke.root().addKnob(zoomKnob)
        nuke.root().addKnob(nuke.Text_Knob("j_ops_bookmarks_note", "", "<i>DAG bookmarks are part of the J_Ops toolset available on Nukepedia</i>"))
    
    xpos = 0.0
    ypos = 0.0
    zoom = 0.0
    selectedList = []

    if mode == 'node':
        if nuke.selectedNodes():
            xposList = []
            yposList = []
            for anode in nuke.selectedNodes():
                xposList.append(anode["xpos"].getValue())
                yposList.append(anode["ypos"].getValue())
            xpos = sum(xposList, 0.0) / len(xposList)
            ypos = sum(yposList, 0.0) / len(yposList)
        else:
            return
    else:
        if nuke.selectedNodes():
            for anode in nuke.selectedNodes():
                selectedList.append(anode)
                anode["selected"].setValue(0.0)

        tempNode = nuke.createNode("Dot", inpanel=False)
        xpos = tempNode["xpos"].getValue()
        ypos = tempNode["ypos"].getValue()
        nuke.delete(tempNode)
    
    zoom = nuke.zoom()
    
    zoomNameString  = "jops_bookmark_"+str(index)+"_zoom"
    posNameString   = "jops_bookmark_"+str(index)+"_pos"
        
    nuke.root()[zoomNameString].clearFlag(nuke.DISABLED)
    nuke.root()[zoomNameString].setValue(zoom)
    nuke.root()[posNameString].clearFlag(nuke.DISABLED)
    nuke.root()[posNameString].setValue(xpos,0)
    nuke.root()[posNameString].setValue(ypos,1)
    
    if selectedList:
        for anode in selectedList:
            anode["selected"].setValue(1.0)