Exemple #1
0
    def set_frame_range(self,
                        start_frame=1,
                        end_frame=100,
                        adjust_frame_range=False):
        """sets the frame range
        """
        # --------------------------------------------
        # set the timeline
        current_frame = hou.frame()
        if current_frame < start_frame:
            hou.setFrame(start_frame)
        elif current_frame > end_frame:
            hou.setFrame(end_frame)

        # for now use hscript, the python version is not implemented yet
        hou.hscript('tset `(' + str(start_frame) + '-1)/$FPS` `' +
                    str(end_frame) + '/$FPS`')

        # --------------------------------------------
        # Set the render nodes frame ranges if any
        # get the out nodes
        output_nodes = self.get_output_nodes()

        for output_node in output_nodes:
            output_node.setParms({
                'trange': 0,
                'f1': start_frame,
                'f2': end_frame,
                'f3': 1
            })
Exemple #2
0
    def testParticlePrimitive(self):
        obj = hou.node("/obj")
        geo = obj.createNode("geo", run_init_scripts=False)
        popnet = geo.createNode("popnet")
        location = popnet.createNode("location")
        detailAttr = popnet.createOutputNode("attribcreate",
                                             exact_type_name=True)
        detailAttr.parm("name").set("float3detail")
        detailAttr.parm("class").set(0)  # detail
        detailAttr.parm("type").set(0)  # float
        detailAttr.parm("size").set(3)  # 3 elements
        detailAttr.parm("value1").set(1)
        detailAttr.parm("value2").set(2)
        detailAttr.parm("value3").set(3)
        pointAttr = detailAttr.createOutputNode("attribcreate",
                                                exact_type_name=True)
        pointAttr.parm("name").set("float3point")
        pointAttr.parm("class").set(2)  # point
        pointAttr.parm("type").set(0)  # float
        pointAttr.parm("size").set(3)  # 3 elements
        pointAttr.parm("value1").set(1)
        pointAttr.parm("value2").set(2)
        pointAttr.parm("value3").set(3)

        hou.setFrame(5)
        converter = IECoreHoudini.FromHoudiniPolygonsConverter(pointAttr)
        self.assertRaises(RuntimeError, converter.convert)

        add = pointAttr.createOutputNode("add")
        add.parm("keep").set(1)  # deletes primitive and leaves points

        m = IECoreHoudini.FromHoudiniPolygonsConverter(add).convert()
        self.failUnless(isinstance(m, IECoreScene.MeshPrimitive))
        self.assertEqual(m, IECoreScene.MeshPrimitive())
Exemple #3
0
	def houGetExternalFiles(self):
		hou.setFrame(hou.playbar.playbackRange()[0])
		whitelist = ['$HIP/$OS-bounce.rat', '$HIP/$OS-fill.rat', '$HIP/$OS-key.rat', '$HIP/$OS-rim.rat']
		houdeps = hou.fileReferences()
		extFiles = []
		extFilesSource = []
		for x in houdeps:
			if "/Redshift/Plugins/Houdini/" in x[1]:
				continue

			if x[0] is None:
				continue

			if x[1] in whitelist:
				continue

			if not os.path.isabs(hou.expandString(x[1])):
				continue

			if os.path.splitext(hou.expandString(x[1]))[1] == "":
				continue

			if x[0] is not None and x[0].name() in ["RS_outputFileNamePrefix", "vm_picture"]:
				continue

			if x[0] is not None and x[0].name() in ["filename", "dopoutput", "copoutput", "sopoutput"] and x[0].node().type().name() in ["rop_alembic", "rop_dop", "rop_comp", "rop_geometry"]:
				continue

			extFiles.append(hou.expandString(x[1]).replace("\\", "/"))
			extFilesSource.append(x[0])

		#return [extFiles, extFilesSource]
		return extFiles
	def testMultipleParticlePrimitives( self ) :
		
		obj = hou.node("/obj")
		geo = obj.createNode( "geo", run_init_scripts=False )
		popnet = geo.createNode( "popnet" )
		fireworks = popnet.createNode( "fireworks" )
		
		hou.setFrame( 15 )
		converter = IECoreHoudini.FromHoudiniPointsConverter( popnet )
		points = converter.convert()
		
		self.assertEqual( type(points), IECore.PointsPrimitive )
		self.assertEqual( points.variableSize( IECore.PrimitiveVariable.Interpolation.Vertex ), 24 )
		self.assertEqual( points["accel"].interpolation, IECore.PrimitiveVariable.Interpolation.Vertex )
		self.assertEqual( type(points["accel"].data), IECore.V3fVectorData )
		self.assertEqual( points["accel"].data.getInterpretation(), IECore.GeometricData.Interpretation.Vector )
		self.assertEqual( points["nextid"].interpolation, IECore.PrimitiveVariable.Interpolation.Constant )
		self.assertEqual( points["nextid"].data, IECore.IntData( 25 ) )
		self.assertTrue( points.arePrimitiveVariablesValid() )
		
		add = popnet.createOutputNode( "add" )
		add.parm( "keep" ).set( 1 ) # deletes primitive and leaves points
		
		converter = IECoreHoudini.FromHoudiniPointsConverter( add )
		points2 = converter.convert()
		# showing that prim attribs don't get converted because the interpolation size doesn't match
		self.assertEqual( points2, points )
def setFrameRangeData():

    start_frame = float(os.getenv('FS'))
    end_frame = float(os.getenv('FE'))
    shot_id = os.getenv('FTRACK_SHOTID')
    shot = ftrack.Shot(id=shot_id)
    fps = shot.get('fps')
    if 'handles' in shot.keys():
        handles = float(shot.get('handles'))
    else:
        handles = 0.0

    print 'setting timeline to %s %s ' % (start_frame, end_frame)

    # add handles to start and end frame
    hsf = (start_frame - 1) - handles
    hef = end_frame + handles

    hou.setFps(fps)
    hou.setFrame(start_frame)

    try:
        if start_frame != end_frame:
            hou.hscript("tset {0} {1}".format((hsf) / fps, hef / fps))
            hou.playbar.setPlaybackRange(start_frame, end_frame)
    except IndexError:
        pass
	def testPrimitiveGroupModeWithTransformAttribute( self ) :
		cache = self.cacheSop( file="test/IECoreHoudini/data/torusWithVertexNormals.bgeo" )
		cache.parm( "groupingMode" ).set( 0 )
		hou.parm( "/obj/geo1/group1/entity" ).set( 0 )
		hou.setFrame( 2 )
		orig = IECoreHoudini.FromHoudiniPolygonsConverter( cache ).convert()
		cache.parm( "transformAttribute" ).set( "transform" )
		result = IECoreHoudini.FromHoudiniPolygonsConverter( cache ).convert()
		self.assertNotEqual( orig, result )
		self.assertNotEqual( orig['P'], result['P'] )
		self.assertNotEqual( orig['N'], result['N'] )
		self.assertEqual( orig['P'].data.size(), result['P'].data.size() )
		self.assertEqual( orig['N'].data.size(), result['N'].data.size() )
		self.assertEqual( orig['Cs'], result['Cs'] )
		self.assertEqual( orig['pointId'], result['pointId'] )
		
		i = IECore.InterpolatedCache( cache.parm( "cacheSequence" ).eval(), IECore.InterpolatedCache.Interpolation.Linear, IECore.OversamplesCalculator( 24, 1 ) )
		matrix = i.read( 2, "torus", "transform" ).value.transform
		origP = orig["P"].data
		origN = orig["N"].data
		resultP = result["P"].data
		resultN = result["N"].data
		for i in range( 0, origP.size() ) :
			self.assertNotEqual( resultP[i], origP[i] )
			self.assertNotEqual( resultN[i], origN[i] )
			self.assertEqual( resultP[i], matrix.multVecMatrix( origP[i] ) )
			self.failUnless( resultN[i].equalWithAbsError( matrix.multDirMatrix( origN[i] ), 1e-6 ) )
	def testPrimitiveGroupModeWithMultipleObjects( self ) :
		hou.setFrame( 3 )
		cache = self.cacheSop( file="test/IECoreHoudini/data/torusWithVertexNormals.bgeo" )
		cache.parm( "groupingMode" ).set( 0 )
		hou.parm( "/obj/geo1/group1/entity" ).set( 0 )
		torus = cache.parent().createNode( "file" )
		torus.parm( "file" ).set( "test/IECoreHoudini/data/torusWithVertexNormals.bgeo" )
		group = torus.createOutputNode( "group" )
		group.parm( "crname" ).set( "torus2" )
		merge = cache.inputs()[0].createOutputNode( "merge" )
		merge.setInput( 1, group )
		cache.setInput( 0, merge )
		result = IECoreHoudini.FromHoudiniPolygonsConverter( cache ).convert()
		numTorusPoints = len(torus.geometry().points())
		for key in [ "P", "Cs" ] :
			self.assert_( key in result )
			self.assertEqual( result[key].data.size(), 2 * numTorusPoints )
		
		for i in range( 0, numTorusPoints ) :
			self.assertNotEqual( result['P'].data[i], result['P'].data[numTorusPoints+i] )
			self.assertEqual( result['Cs'].data[i], result['Cs'].data[numTorusPoints+i] )
		
		numTorusVerts = sum( [ len(x.vertices()) for x in torus.geometry().prims() ] )
		self.assert_( "N" in result )
		self.assertEqual( result["N"].data.size(), 2 * numTorusVerts )
		for i in range( 0, numTorusVerts ) :
			self.assertNotEqual( result['N'].data[i], result['N'].data[numTorusPoints+i] )
	def testPrimitiveGroupModeWithVertexAttribs( self ) :
		
		# N defaults to a Point attrib
		hou.setFrame( 4 )
		cache = self.cacheSop()
		self.failUnless( isinstance( cache.geometry().findPointAttrib( "N" ), hou.Attrib ) )
		self.failUnless( cache.geometry().findVertexAttrib( "N" ) is None )
		result = IECoreHoudini.FromHoudiniPolygonsConverter( cache ).convert()
		self.failUnless( "N" in result.keys() )
		self.assertEqual( result["N"].interpolation, IECore.PrimitiveVariable.Interpolation.Vertex )
		self.assertEqual( len(result["N"].data), result.variableSize( IECore.PrimitiveVariable.Interpolation.Vertex ) )
		
		# Since N actually has more values than points should, N becomes a Vertex attrib if we use PrimitiveGroup mode
		group = hou.node( "/obj/geo1/group1" )
		group.parm( "entity" ).set( 0 )
		cache.parm( "groupingMode" ).set( 0 )
		self.failUnless( cache.geometry().findPointAttrib( "N" ) is None )
		self.failUnless( isinstance( cache.geometry().findVertexAttrib( "N" ), hou.Attrib ) )
		result = IECoreHoudini.FromHoudiniPolygonsConverter( cache ).convert()
		self.failUnless( "N" in result.keys() )
		self.assertEqual( result["N"].interpolation, IECore.PrimitiveVariable.Interpolation.FaceVarying )
		self.assertEqual( len(result["N"].data), result.variableSize( IECore.PrimitiveVariable.Interpolation.FaceVarying ) )
		
		# Even if we create N as a Point attrib before the cache, it remains a Vertex attrib since the sizes do not match
		facet = group.createOutputNode( "facet" )
		facet.parm( "postnml" ).set( True )
		cache.setInput( 0, facet )
		self.failUnless( isinstance( facet.geometry().findPointAttrib( "N" ), hou.Attrib ) )
		self.failUnless( facet.geometry().findVertexAttrib( "N" ) is None )
		self.failUnless( cache.geometry().findPointAttrib( "N" ) is None )
		self.failUnless( isinstance( cache.geometry().findVertexAttrib( "N" ), hou.Attrib ) )
		result = IECoreHoudini.FromHoudiniPolygonsConverter( cache ).convert()
		self.failUnless( "N" in result.keys() )
		self.assertEqual( result["N"].interpolation, IECore.PrimitiveVariable.Interpolation.FaceVarying )
		self.assertEqual( len(result["N"].data), result.variableSize( IECore.PrimitiveVariable.Interpolation.FaceVarying ) )
    def _onNewHoudiniFile(self, name: str,
                          file_dialog: re_project_manager.NewFileDialogUI):
        default_ext = HoudiniProjectManagerUI.getExtension()
        if not name.lower().endswith(default_ext):
            name = name + default_ext

        new_file_name = Path(name)

        if new_file_name.exists():
            QtWidgets.QMessageBox.question(
                self, "File already exists!",
                "File with this name already exists!",
                QtWidgets.QMessageBox.Ok)
        else:
            hou.hipFile.clear()
            hou.hipFile.setName(new_file_name.as_posix())

            hou.hscript("set -g HRES={}".format(
                re_project.get_project_default_rez()['x']))
            hou.hscript("set -g VRES={}".format(
                re_project.get_project_default_rez()['y']))

            hou.setFps(re_project.get_project_default_fps())

            if file_dialog.asset_type == re_project_manager.NewFileDialogUI.ASSET_TYPE_SHOT:
                hou.playbar.setFrameRange(1001, 1200)
                hou.playbar.setPlaybackRange(1001, 1200)
                hou.setFrame(1001)

            hou.hscript("set -g NAME={}".format(file_dialog.asset_main_name))

            hou.hipFile.save()
            self.statusBar.showMessage("New Houdini file {} created".format(
                new_file_name.name))
    def testPrimitiveGroupModeWithMultipleObjects(self):
        hou.setFrame(3)
        cache = self.cacheSop(
            file="test/IECoreHoudini/data/torusWithVertexNormals.bgeo")
        cache.parm("groupingMode").set(0)
        hou.parm("/obj/geo1/group1/entity").set(0)
        torus = cache.parent().createNode("file")
        torus.parm("file").set(
            "test/IECoreHoudini/data/torusWithVertexNormals.bgeo")
        group = torus.createOutputNode("group")
        group.parm("crname").set("torus2")
        merge = cache.inputs()[0].createOutputNode("merge")
        merge.setInput(1, group)
        cache.setInput(0, merge)
        result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
        numTorusPoints = len(torus.geometry().points())
        for key in ["P", "Cs"]:
            self.assert_(key in result)
            self.assertEqual(result[key].data.size(), 2 * numTorusPoints)

        for i in range(0, numTorusPoints):
            self.assertNotEqual(result['P'].data[i],
                                result['P'].data[numTorusPoints + i])
            self.assertEqual(result['Cs'].data[i],
                             result['Cs'].data[numTorusPoints + i])

        numTorusVerts = sum(
            [len(x.vertices()) for x in torus.geometry().prims()])
        self.assert_("N" in result)
        self.assertEqual(result["N"].data.size(), 2 * numTorusVerts)
        for i in range(0, numTorusVerts):
            self.assertNotEqual(result['N'].data[i],
                                result['N'].data[numTorusPoints + i])
    def testPrimitiveGroupModeWithTransformAttribute(self):
        cache = self.cacheSop(
            file="test/IECoreHoudini/data/torusWithVertexNormals.bgeo")
        cache.parm("groupingMode").set(0)
        hou.parm("/obj/geo1/group1/entity").set(0)
        hou.setFrame(2)
        orig = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
        cache.parm("transformAttribute").set("transform")
        result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
        self.assertNotEqual(orig, result)
        self.assertNotEqual(orig['P'], result['P'])
        self.assertNotEqual(orig['N'], result['N'])
        self.assertEqual(orig['P'].data.size(), result['P'].data.size())
        self.assertEqual(orig['N'].data.size(), result['N'].data.size())
        self.assertEqual(orig['Cs'], result['Cs'])
        self.assertEqual(orig['pointId'], result['pointId'])

        i = IECore.InterpolatedCache(
            cache.parm("cacheSequence").eval(),
            IECore.InterpolatedCache.Interpolation.Linear,
            IECore.OversamplesCalculator(24, 1))
        matrix = i.read(2, "torus", "transform").value.transform
        origP = orig["P"].data
        origN = orig["N"].data
        resultP = result["P"].data
        resultN = result["N"].data
        for i in range(0, origP.size()):
            self.assertNotEqual(resultP[i], origP[i])
            self.assertNotEqual(resultN[i], origN[i])
            self.assertEqual(resultP[i], matrix.multVecMatrix(origP[i]))
            self.failUnless(resultN[i].equalWithAbsError(
                matrix.multDirMatrix(origN[i]), 1e-6))
Exemple #12
0
def play_scrub(multiplier):
    import time
    from PySide2.QtGui import QCursor

    mouse_last = hou.getenv("mouse", "0")
    mouse_last = float(mouse_last)
    mouse_now = QCursor().pos()

    time_now = time.time()
    time_last = hou.getenv("time", "0")
    time_last = float(time_last)
    time_diff = time_now - time_last

    mouse_now = round(mouse_now.x() / 10)

    if time_diff > 0.1:
        mouse_last = mouse_now

    skip = mouse_last - mouse_now
    skip = skip * multiplier
    if abs(skip) > 20:
        skip = skip * 2

    frame_now = hou.frame()
    frame_now = hou.frame() - skip
    hou.setFrame(frame_now)

    hou.putenv("mouse", str(mouse_now))
    hou.putenv("time", str(time_now))
	def testNoFileForFrame( self ) :
		cache = self.cacheSop()
		cache.parm( "cacheSequence" ).set( "test/IECoreHoudini/data/torusVertCache.####.fio" )
		hou.setFrame( 5 )
		cache.cook( force=True )
		self.failUnless( cache.warnings() )
		self.assertEqual( len(cache.geometry().points()), 0 )
Exemple #14
0
    def set_frame_range(self, start_frame=1, end_frame=100, adjust_frame_range=False):
        """sets the frame range
        """
        # --------------------------------------------
        # set the timeline
        current_frame = hou.frame()
        if current_frame < start_frame:
            hou.setFrame(start_frame)
        elif current_frame > end_frame:
            hou.setFrame(end_frame)

        # for now use hscript, the python version is not implemented yet
        hou.hscript(
            'tset `(' + str(start_frame) + '-1)/$FPS` `' + str(
                end_frame) + '/$FPS`'
        )

        # --------------------------------------------
        # Set the render nodes frame ranges if any
        # get the out nodes
        output_nodes = self.get_output_nodes()

        for output_node in output_nodes:
            output_node.setParms(
                {'trange': 0, 'f1': start_frame, 'f2': end_frame, 'f3': 1}
            )
Exemple #15
0
def processMesh(nodes, nodePieces, numPieces):
    PARMS = ["tx", "ty", "tz", "rx", "ry", "rz", "px", "py", "pz"]
    RFSTART = int(hou.expandString('$RFSTART'))
    RFEND = int(hou.expandString('$RFEND'))

    initialParmData = []

    #GET INITIAL TRANSFORMS
    hou.setFrame(frame)
    for objectToProcess in range(0, len(numPieces)):
        initialParmData.append(objectToProcess)

        for index in range(0, numPieces[objectToProcess]):
            initialParmData[objectToProcess].append(index)

            for index_parm in range(0, 3):
                #Get original tx,ty,tz
                initialParmData[objectToProcess][index].append(
                    nodes[objectToProcess].points()[index].attribValue(
                        'P')[index_parm])

            for index_parm in range(0, 3):
                #Get original rx,ry,rz
                initialParmData[objectToProcess][index].append(
                    nodes[objectToProcess].points()[index].attribValue(
                        'R')[index_parm])
	def testParticlePrimitive( self ) :
		obj = hou.node("/obj")
		geo = obj.createNode( "geo", run_init_scripts=False )
		popnet = geo.createNode( "popnet" )
		location = popnet.createNode( "location" )
		detailAttr = popnet.createOutputNode( "attribcreate", exact_type_name=True )
		detailAttr.parm("name").set( "float3detail" )
		detailAttr.parm("class").set( 0 ) # detail
		detailAttr.parm("type").set( 0 ) # float
		detailAttr.parm("size").set( 3 ) # 3 elements
		detailAttr.parm("value1").set( 1 )
		detailAttr.parm("value2").set( 2 )
		detailAttr.parm("value3").set( 3 )
		pointAttr = detailAttr.createOutputNode( "attribcreate", exact_type_name=True )
		pointAttr.parm("name").set( "float3point" )
		pointAttr.parm("class").set( 2 ) # point
		pointAttr.parm("type").set( 0 ) # float
		pointAttr.parm("size").set( 3 ) # 3 elements
		pointAttr.parm("value1").set( 1 )
		pointAttr.parm("value2").set( 2 )
		pointAttr.parm("value3").set( 3 )
		
		hou.setFrame( 5 )
		converter = IECoreHoudini.FromHoudiniPolygonsConverter( pointAttr )
		self.assertRaises( RuntimeError, converter.convert )
		
		add = pointAttr.createOutputNode( "add" )
		add.parm( "keep" ).set( 1 ) # deletes primitive and leaves points
		
		m = IECoreHoudini.FromHoudiniPolygonsConverter( add ).convert()
		self.failUnless( isinstance( m, IECore.MeshPrimitive ) )
		self.assertEqual( m, IECore.MeshPrimitive() )
Exemple #17
0
	def testMultipleParticlePrimitives( self ) :
		
		obj = hou.node("/obj")
		geo = obj.createNode( "geo", run_init_scripts=False )
		popnet = geo.createNode( "popnet" )
		fireworks = popnet.createNode( "fireworks" )
		
		hou.setFrame( 15 )
		converter = IECoreHoudini.FromHoudiniPointsConverter( popnet )
		points = converter.convert()
		
		self.assertEqual( type(points), IECore.PointsPrimitive )
		self.assertEqual( points.variableSize( IECore.PrimitiveVariable.Interpolation.Vertex ), 24 )
		self.assertEqual( points["accel"].interpolation, IECore.PrimitiveVariable.Interpolation.Vertex )
		self.assertEqual( type(points["accel"].data), IECore.V3fVectorData )
		self.assertEqual( points["accel"].data.getInterpretation(), IECore.GeometricData.Interpretation.Vector )
		self.assertEqual( points["nextid"].interpolation, IECore.PrimitiveVariable.Interpolation.Constant )
		self.assertEqual( points["nextid"].data, IECore.IntData( 25 ) )
		self.assertTrue( points.arePrimitiveVariablesValid() )
		
		add = popnet.createOutputNode( "add" )
		add.parm( "keep" ).set( 1 ) # deletes primitive and leaves points
		
		converter = IECoreHoudini.FromHoudiniPointsConverter( add )
		points2 = converter.convert()
		# showing that prim attribs don't get converted because the interpolation size doesn't match
		self.assertEqual( points2, points )
Exemple #18
0
    def render(self, preview=True):
        renderFolder = hou.getenv('HIP') + '/render'
        if not os.path.exists(renderFolder):
            os.makedirs(renderFolder)

        prevFrame = hou.frame()
        prevDelay = self.pane.delay()
        prevUpdateTime = self.pane.updateTime()
        prevPreview = self.pane.isPreviewOn()

        self.pane.setDelay(0)
        self.pane.setUpdateTime(0.2)
        self.pane.setPreview(preview)

        start = self.frames[0]
        end = self.frames[1] + 1
        inc = self.frames[2]

        for frame in range(start, end, inc):
            hou.setFrame(frame)
            self.pane.resumeRender()
            time.sleep(self.renderTime)
            self.pane.pauseRender()
            self.saveFrame(frame)

        hou.setFrame(prevFrame)
        self.pane.setDelay(prevDelay)
        self.pane.setUpdateTime(prevUpdateTime)
        self.pane.setPreview(prevPreview)
Exemple #19
0
def bakeObjectToWorld(startFrame, endFrame):
    selectedNode = hou.selectedNodes()
    selectedNodeName = selectedNode[0].name()
    parent = selectedNode[0].parent()
    bakeNode = hou.copyNodesTo(selectedNode, parent)
    bakeNode[0].setName(selectedNodeName + "_bake")
    bakeNode[0].parm("keeppos").set(0)
    fetchNode = hou.node(parent.path()).createNode("fetch",
                                                   "fetch_" + selectedNodeName)
    hou.node(fetchNode.path()).parm("fetchobjpath").set(selectedNode[0].path())
    hou.node(fetchNode.path()).parm("useinputoffetched").set(1)
    nullNode = hou.node(parent.path()).createNode("null")
    nullNode.setFirstInput(fetchNode)
    nullNodeName = nullNode.name()

    parms = ["tx", "ty", "tz", "rx", "ry", "rz"]
    constant = ["TX", "TY", "TZ", "RX", "RY", "RZ"]

    bakeNode[0].setInput(0, None)

    #delete expresssion in parms and set to 0
    for p in parms:
        bakeNode[0].parm(p).deleteAllKeyframes()
        hou.hscript('objextractpretransform ' + bakeNode[0].path())
        bakeNode[0].parm(p).set(0)

    for p, c in zip(parms, constant):
        #bakeNode[0].parm(p).deleteAllKeyframes()
        hou.node(bakeNode[0].path()).parm(p).setExpression('origin("","../' +
                                                           nullNodeName +
                                                           '",' + c + ')')

    #add dict for hou.Keyframe and values
    key = dict([(x, hou.Keyframe()) for x in parms])
    values = dict([(x, []) for x in constant])

    #bake time range
    timeRange = xrange(startFrame, endFrame + 1)

    #fill values dict
    for t in timeRange:
        hou.setFrame(t)
        for v, p in zip(constant, parms):
            values[v].append(bakeNode[0].parm(p).eval())

    for p in parms:
        bakeNode[0].parm(p).deleteAllKeyframes()
        bakeNode[0].parm(p).set(0)

    #set key by keyframes

    for t in timeRange:
        hou.setFrame(t)
        for v, p, k in zip(constant, parms, key):
            key[k].setValue(values[v][t - startFrame])
            bakeNode[0].parm(p).setKeyframe(key[k])

    fetchNode.destroy()
    nullNode.destroy()
	def testExpressions( self ) :
		
		obj = hou.node( "/obj" )
		geo = obj.createNode( "geo", run_init_scripts=False )
		node = geo.createNode( "attribcreate", exact_type_name=True )
		node.parm( "class" ).setExpression( "$F" )
		node.parm( "writevalues" ).setExpression( "$F" )
		node.parm( "size" ).setExpression( "$F+1" )
		node.parm( "default1" ).setExpression( "$FF*5" )
		node.parm( "string" ).setExpression( 'opfullpath( "." )' )
		nodePath = node.path()
		
		context = IECoreHoudini.TemporaryParameterValues(
			{
				nodePath + "/class" : 3,
				nodePath + "/writevalues" : False,
				nodePath + "/size" : 3,
				nodePath + "/default1" : 20.5,
				nodePath + "/string" : "bye",
			}
		)

		hou.setFrame( 1 )
		
		self.assertEqual( node.parm( "class" ).eval(), 1 )
		self.assertEqual( node.parm( "writevalues" ).eval(), True )
		self.assertEqual( node.parm( "size" ).eval(), 2 )
		self.assertEqual( node.parm( "default1" ).eval(), 5.0 )
		self.assertEqual( node.parm( "string" ).eval(), nodePath )
		
		with context :

			self.assertEqual( node.parm( "class" ).eval(), 3 )
			self.assertEqual( node.parm( "writevalues" ).eval(), False )
			self.assertEqual( node.parm( "size" ).eval(), 3 )
			self.assertEqual( node.parm( "default1" ).eval(), 20.5 )
			self.assertEqual( node.parm( "string" ).eval(), "bye" )
		
		self.assertEqual( node.parm( "class" ).eval(), 1 )
		self.assertEqual( node.parm( "writevalues" ).eval(), True )
		self.assertEqual( node.parm( "size" ).eval(), 2 )
		self.assertEqual( node.parm( "default1" ).eval(), 5.0 )
		self.assertEqual( node.parm( "string" ).eval(), nodePath )
		
		hou.setFrame( 0 )
		
		with context :

			self.assertEqual( node.parm( "class" ).eval(), 3 )
			self.assertEqual( node.parm( "writevalues" ).eval(), False )
			self.assertEqual( node.parm( "size" ).eval(), 3 )
			self.assertEqual( node.parm( "default1" ).eval(), 20.5 )
			self.assertEqual( node.parm( "string" ).eval(), "bye" )
		
		self.assertEqual( node.parm( "class" ).eval(), 0 )
		self.assertEqual( node.parm( "writevalues" ).eval(), False )
		self.assertEqual( node.parm( "size" ).eval(), 1 )
		self.assertEqual( node.parm( "default1" ).eval(), 0.0 )
		self.assertEqual( node.parm( "string" ).eval(), nodePath )
Exemple #21
0
def set_stock_timeLine(node):
    """ get frame in frame out from shotgun"""
    in_frame = float(node.parm('start_s_frame').evalAsString())
    out_frame = float(node.parm('end_s_frame').evalAsString())
    """ set the timeline """
    hou.hscript("tset `((%s-1)/$FPS)` `(%s/$FPS)`" % (in_frame, out_frame))
    hou.playbar.setPlaybackRange(in_frame, out_frame)
    hou.setFrame(in_frame)
	def testLongP( self ) :
		hou.setFrame( 3 )
		cache = self.cacheSop()
		group = cache.inputs()[0]
		group.parm( "crname" ).set( "badObject" )
		cache.parm( "attributeFixes1" ).set( "long" )
		cache.cook( force=True )
		self.failUnless( "Geometry/Cache mismatch" in cache.warnings() )
	def testWrongP( self ) :
		hou.setFrame( 3 )
		cache = self.cacheSop()
		group = cache.inputs()[0]
		group.parm( "crname" ).set( "badObject" )
		cache.parm( "attributeFixes1" ).set( "wrong" )
		result = IECoreHoudini.FromHoudiniPolygonsConverter( cache ).convert()
		self.assert_( "P" in result )
Exemple #24
0
def init_setup_the_scene(fps, in_frame, out_frame):
    """ set the scene in Manual """
    hou.setUpdateMode(hou.updateMode.Manual)
    """ set the timeline """
    hou.setFps(fps)
    hou.hscript("tset `((%s-1)/$FPS)` `(%s/$FPS)`" % (in_frame, out_frame))
    hou.playbar.setPlaybackRange(in_frame, out_frame)
    hou.setFrame(in_frame)
 def testNoFileForFrame(self):
     cache = self.cacheSop()
     cache.parm("cacheSequence").set(
         "test/IECoreHoudini/data/torusVertCache.####.fio")
     hou.setFrame(5)
     cache.cook(force=True)
     self.failUnless(cache.warnings())
     self.assertEqual(len(cache.geometry().points()), 0)
 def testLongP(self):
     hou.setFrame(3)
     cache = self.cacheSop()
     group = cache.inputs()[0]
     group.parm("crname").set("badObject")
     cache.parm("attributeFixes1").set("long")
     cache.cook(force=True)
     self.failUnless("Geometry/Cache mismatch" in cache.warnings())
 def testWrongP(self):
     hou.setFrame(3)
     cache = self.cacheSop()
     group = cache.inputs()[0]
     group.parm("crname").set("badObject")
     cache.parm("attributeFixes1").set("wrong")
     result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
     self.assert_("P" in result)
Exemple #28
0
 def points(self):
     points = self.geo().createNode("popnet")
     points.createNode("location")
     color = points.createOutputNode("color")
     color.parm("colortype").set(2)
     name = color.createOutputNode("name")
     name.parm("name1").set("pointsGroup")
     hou.setFrame(50)
     return name
	def testTimeDependency( self ) :
		cache = self.cacheSop()
		orig = IECoreHoudini.FromHoudiniPolygonsConverter( cache ).convert()
		hou.setFrame( 1.5 )
		result = IECoreHoudini.FromHoudiniPolygonsConverter( cache ).convert()
		self.assertNotEqual( orig, result )
		self.assertNotEqual( orig['P'], result['P'] )
		self.assertNotEqual( orig['Cs'], result['Cs'] )
		self.assertEqual( orig['pointId'], result['pointId'] )
	def points( self ) :
		points = self.geo().createNode( "popnet" )
		points.createNode( "location" )
		color = points.createOutputNode( "color" )
		color.parm( "colortype" ).set( 2 )
		name = color.createOutputNode( "name" )
		name.parm( "name1" ).set( "pointsGroup" )
		hou.setFrame( 50 )
		return name
 def testTimeDependency(self):
     cache = self.cacheSop()
     orig = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
     hou.setFrame(1.5)
     result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
     self.assertNotEqual(orig, result)
     self.assertNotEqual(orig['P'], result['P'])
     self.assertNotEqual(orig['Cs'], result['Cs'])
     self.assertEqual(orig['pointId'], result['pointId'])
    def testParticlePrimitive(self):
        obj = hou.node("/obj")
        geo = obj.createNode("geo", run_init_scripts=False)
        popnet = geo.createNode("popnet")
        location = popnet.createNode("location")
        detailAttr = popnet.createOutputNode("attribcreate",
                                             exact_type_name=True)
        detailAttr.parm("name").set("float3detail")
        detailAttr.parm("class").set(0)  # detail
        detailAttr.parm("type").set(0)  # float
        detailAttr.parm("size").set(3)  # 3 elements
        detailAttr.parm("value1").set(1)
        detailAttr.parm("value2").set(2)
        detailAttr.parm("value3").set(3)
        pointAttr = detailAttr.createOutputNode("attribcreate",
                                                exact_type_name=True)
        pointAttr.parm("name").set("float3point")
        pointAttr.parm("class").set(2)  # point
        pointAttr.parm("type").set(0)  # float
        pointAttr.parm("size").set(3)  # 3 elements
        pointAttr.parm("value1").set(1)
        pointAttr.parm("value2").set(2)
        pointAttr.parm("value3").set(3)

        hou.setFrame(5)
        converter = IECoreHoudini.FromHoudiniPointsConverter(pointAttr)
        points = converter.convert()

        self.assertEqual(type(points), IECore.PointsPrimitive)
        self.assertEqual(
            points.variableSize(IECore.PrimitiveVariable.Interpolation.Vertex),
            21)
        self.assertEqual(points["float3detail"].interpolation,
                         IECore.PrimitiveVariable.Interpolation.Constant)
        self.assertEqual(type(points["float3detail"].data), IECore.V3fData)
        self.assert_(points["float3detail"].data.value.equalWithRelError(
            IECore.V3f(1, 2, 3), 1e-10))
        self.assertEqual(type(points["float3point"].data),
                         IECore.V3fVectorData)
        self.assertEqual(points["float3point"].interpolation,
                         IECore.PrimitiveVariable.Interpolation.Vertex)
        for p in points["float3point"].data:
            self.assert_(p.equalWithRelError(IECore.V3f(1, 2, 3), 1e-10))

        self.assert_(points.arePrimitiveVariablesValid())

        add = pointAttr.createOutputNode("add")
        add.parm("keep").set(1)  # deletes primitive and leaves points

        converter = IECoreHoudini.FromHoudiniPointsConverter(add)
        points2 = converter.convert()
        del points['generator']
        del points['generatorIndices']
        del points['born']
        del points['source']
        self.assertEqual(points2, points)
    def test_bake_values_sets_right_values(self):
        parm = self.geo.parm('rx')
        values = [1.0, 3.0, 5.0, 3.0, 7.0, 5.0, 9.0, 1.0]

        for k, frame in enumerate(values):
            bakeparm.bake_values(1, len(values) + 1, parm, values)

        for i in range(len(values) + 1):
            hou.setFrame(i)
            self.assertAlmostEqual(values[i - 1], parm.eval())
    def _set_frame_range(self, frame_range_start, frame_range_end):
        """Set the Houdini frame range and playback range to the input data."""

        # set the frame range to frameRangeStart - frameRangeEnd
        hou.playbar.setFrameRange(frame_range_start, frame_range_end)

        # set the playback range to frameRangeStart - frameRangeEnd
        hou.playbar.setPlaybackRange(frame_range_start, frame_range_end)

        # set the timeline to the first frame
        hou.setFrame(frame_range_start)
 def startElement(self, _name, _attrs):
     # this is important the characters method may be called many times so we
     # clear the char data each start element then append each time we read it
     self.m_charData = ""
     # if we have a vertex start tag process and extract the offset
     if _name == "Vertex":
         self.m_offset = int(_attrs.get("number"))
     # if we have the Frame we grab the number attribute
     elif _name == "Frame":
         hou.setFrame(int(_attrs.get("number")))
         self.m_currentFrame = int(_attrs.get("number"))
Exemple #36
0
 def testAnimatingGeometry(self):
     curves = self.createCurves(4)
     mountain = curves.createOutputNode("mountain")
     mountain.parm("offset1").setExpression("$FF")
     converter = IECoreHoudini.FromHoudiniCurvesConverter(mountain)
     hou.setFrame(1)
     result1 = converter.convert()
     hou.setFrame(2)
     converter = IECoreHoudini.FromHoudiniCurvesConverter(mountain)
     result2 = converter.convert()
     self.assertNotEqual(result1["P"].data, result2["P"].data)
     self.assertNotEqual(result1, result2)
	def testAnimatingGeometry( self ) :
		curves = self.createCurves( 4 )
		mountain = curves.createOutputNode( "mountain" )
		mountain.parm("offset1").setExpression( "$FF" )
		converter = IECoreHoudini.FromHoudiniCurvesConverter( mountain )
		hou.setFrame( 1 )
		result1 = converter.convert()
		hou.setFrame( 2 )
		converter = IECoreHoudini.FromHoudiniCurvesConverter( mountain )
		result2 = converter.convert()
		self.assertNotEqual( result1["P"].data, result2["P"].data )
		self.assertNotEqual( result1, result2 )
Exemple #38
0
	def testProceduralReloadParameters(self):
		sphere = IECoreHoudini.FnProceduralHolder.create( "cortex_sphere", "sphereProcedural", 1 )

		# check the reload button doesn't clear expressions
		sphere.parm("parm_radius").setExpression("sin($FF)")
		hou.setFrame(0)
		rad = sphere.evalParm("parm_radius")
		self.assert_( rad > 0 )
		hou.setFrame(100)
		rad = sphere.evalParm("parm_radius")
		self.assert_( rad > 0.984 )
		self.assert_( rad < 0.985 )
		sphere.parm( "__classReloadButton" ).pressButton()
		rad = sphere.evalParm("parm_radius")
		self.assert_( rad > 0.984 )
		self.assert_( rad < 0.985 )
		self.assertEqual( sphere.parm("parm_radius").expression(), "sin($FF)" )
		hou.setFrame(0)
		rad = sphere.evalParm("parm_radius")
		self.assert_( rad > 0 )

		# now change the version to v2 and check things are still ok
		sphere.parm( "__classVersion" ).set( "2" )
		# if we're changing the menu programatically then we need to call pressButton()!!
		sphere.parm( "__classVersion" ).pressButton()
		self.assert_( not sphere.evalParm("parm_extra") )
		sphere.parm("parm_extra").set(True)
		self.failUnless( sphere.evalParm("parm_extra") )
		rad = sphere.evalParm("parm_radius")
		self.assert_( rad < 0.015 )
		hou.setFrame(100)
		rad = sphere.evalParm("parm_radius")
		self.assert_( rad > 0.984 )
		self.assert_( rad < 0.985 )
Exemple #39
0
    def testProceduralReloadParameters(self):
        sphere = IECoreHoudini.FnProceduralHolder.create(
            "cortex_sphere", "sphereProcedural", 1)

        # check the reload button doesn't clear expressions
        sphere.parm("parm_radius").setExpression("sin($FF)")
        hou.setFrame(0)
        rad = sphere.evalParm("parm_radius")
        self.assert_(rad > 0)
        hou.setFrame(100)
        rad = sphere.evalParm("parm_radius")
        self.assert_(rad > 0.984)
        self.assert_(rad < 0.985)
        sphere.parm("__classReloadButton").pressButton()
        rad = sphere.evalParm("parm_radius")
        self.assert_(rad > 0.984)
        self.assert_(rad < 0.985)
        self.assertEqual(sphere.parm("parm_radius").expression(), "sin($FF)")
        hou.setFrame(0)
        rad = sphere.evalParm("parm_radius")
        self.assert_(rad > 0)

        # now change the version to v2 and check things are still ok
        sphere.parm("__classVersion").set("2")
        # if we're changing the menu programatically then we need to call pressButton()!!
        sphere.parm("__classVersion").pressButton()
        self.assert_(not sphere.evalParm("parm_extra"))
        sphere.parm("parm_extra").set(True)
        self.failUnless(sphere.evalParm("parm_extra"))
        rad = sphere.evalParm("parm_radius")
        self.assert_(rad < 0.015)
        hou.setFrame(100)
        rad = sphere.evalParm("parm_radius")
        self.assert_(rad > 0.984)
        self.assert_(rad < 0.985)
    def testPrimitiveGroupModeWithVertexAttribs(self):

        # N defaults to a Point attrib
        hou.setFrame(4)
        cache = self.cacheSop()
        self.failUnless(
            isinstance(cache.geometry().findPointAttrib("N"), hou.Attrib))
        self.failUnless(cache.geometry().findVertexAttrib("N") is None)
        result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
        self.failUnless("N" in result.keys())
        self.assertEqual(result["N"].interpolation,
                         IECore.PrimitiveVariable.Interpolation.Vertex)
        self.assertEqual(
            len(result["N"].data),
            result.variableSize(IECore.PrimitiveVariable.Interpolation.Vertex))

        # Since N actually has more values than points should, N becomes a Vertex attrib if we use PrimitiveGroup mode
        group = hou.node("/obj/geo1/group1")
        group.parm("entity").set(0)
        cache.parm("groupingMode").set(0)
        self.failUnless(cache.geometry().findPointAttrib("N") is None)
        self.failUnless(
            isinstance(cache.geometry().findVertexAttrib("N"), hou.Attrib))
        result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
        self.failUnless("N" in result.keys())
        self.assertEqual(result["N"].interpolation,
                         IECore.PrimitiveVariable.Interpolation.FaceVarying)
        self.assertEqual(
            len(result["N"].data),
            result.variableSize(
                IECore.PrimitiveVariable.Interpolation.FaceVarying))

        # Even if we create N as a Point attrib before the cache, it remains a Vertex attrib since the sizes do not match
        facet = group.createOutputNode("facet")
        facet.parm("postnml").set(True)
        cache.setInput(0, facet)
        self.failUnless(
            isinstance(facet.geometry().findPointAttrib("N"), hou.Attrib))
        self.failUnless(facet.geometry().findVertexAttrib("N") is None)
        self.failUnless(cache.geometry().findPointAttrib("N") is None)
        self.failUnless(
            isinstance(cache.geometry().findVertexAttrib("N"), hou.Attrib))
        result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
        self.failUnless("N" in result.keys())
        self.assertEqual(result["N"].interpolation,
                         IECore.PrimitiveVariable.Interpolation.FaceVarying)
        self.assertEqual(
            len(result["N"].data),
            result.variableSize(
                IECore.PrimitiveVariable.Interpolation.FaceVarying))
	def testParticlePrimitive( self ) :
		obj = hou.node("/obj")
		geo = obj.createNode( "geo", run_init_scripts=False )
		popnet = geo.createNode( "popnet" )
		location = popnet.createNode( "location" )
		detailAttr = popnet.createOutputNode( "attribcreate", exact_type_name=True )
		detailAttr.parm("name").set( "float3detail" )
		detailAttr.parm("class").set( 0 ) # detail
		detailAttr.parm("type").set( 0 ) # float
		detailAttr.parm("size").set( 3 ) # 3 elements
		detailAttr.parm("value1").set( 1 )
		detailAttr.parm("value2").set( 2 )
		detailAttr.parm("value3").set( 3 )
		pointAttr = detailAttr.createOutputNode( "attribcreate", exact_type_name=True )
		pointAttr.parm("name").set( "float3point" )
		pointAttr.parm("class").set( 2 ) # point
		pointAttr.parm("type").set( 0 ) # float
		pointAttr.parm("size").set( 3 ) # 3 elements
		pointAttr.parm("value1").set( 1 )
		pointAttr.parm("value2").set( 2 )
		pointAttr.parm("value3").set( 3 )
		
		hou.setFrame( 5 )
		converter = IECoreHoudini.FromHoudiniGeometryConverter.create( pointAttr )
		self.assert_( converter.isInstanceOf( IECore.TypeId( IECoreHoudini.TypeId.FromHoudiniPointsConverter ) ) )
		points = converter.convert()
		
		self.assertEqual( type(points), IECore.PointsPrimitive )
		self.assertEqual( points.variableSize( IECore.PrimitiveVariable.Interpolation.Vertex ), 21 )
		self.assertEqual( points["float3detail"].interpolation, IECore.PrimitiveVariable.Interpolation.Constant )
		self.assertEqual( type(points["float3detail"].data), IECore.V3fData )
		self.assert_( points["float3detail"].data.value.equalWithRelError( IECore.V3f( 1, 2, 3 ), 1e-10 ) )
		self.assertEqual( type(points["float3point"].data), IECore.V3fVectorData )
		self.assertEqual( points["float3point"].interpolation, IECore.PrimitiveVariable.Interpolation.Vertex )
		for p in points["float3point"].data :
			self.assert_( p.equalWithRelError( IECore.V3f( 1, 2, 3 ), 1e-10 ) )
		
		self.assert_( points.arePrimitiveVariablesValid() )
		
		add = pointAttr.createOutputNode( "add" )
		add.parm( "keep" ).set( 1 ) # deletes primitive and leaves points
		
		converter = IECoreHoudini.FromHoudiniPointsConverter( add )
		points2 = converter.convert()
		del points['generator']
		del points['generatorIndices']
		del points['born']
		del points['source']
		self.assertEqual( points2, points )
	def testNonConvertableAttr( self ) :
		hou.setFrame( 3 )
		cache = self.cacheSop()
		torus = cache.parent().createNode( "file" )
		torus.parm( "file" ).set( TestInterpolatedCacheReader.__torusTestFile )
		group = torus.createOutputNode( "group" )
		group.parm( "crname" ).set( "badObject" )
		group.parm( "entity" ).set( 1 )
		merge = cache.inputs()[0].createOutputNode( "merge" )
		merge.setInput( 1, group )
		cache.setInput( 0, merge )
		i = IECore.InterpolatedCache( cache.parm( "cacheSequence" ).eval(), IECore.InterpolatedCache.Interpolation.Linear, IECore.OversamplesCalculator( 24, 1 ) )
		self.assert_( "splineColor4fData" in i.attributes( 3, 'badObject' ) )
		result = IECoreHoudini.FromHoudiniPolygonsConverter( cache ).convert()
		self.assert_( "splineColor4fData" not in result )
Exemple #43
0
	def testAnimatedValues( self ) :
		
		sphere = IECoreHoudini.FnProceduralHolder.create( "test", "sphereProcedural", 1 )
		fn = IECoreHoudini.FnProceduralHolder( sphere )
		sphere.parm( "parm_radius" ).setExpression( "$FF" )
		hou.setFrame( 1 )
		self.assertEqual( sphere.evalParm( "parm_radius" ), 1 )
		self.assertEqual( fn.getProcedural().parameters()["radius"].getTypedValue(), 1 )
		hou.setFrame( 12.25 )
		self.assertEqual( sphere.evalParm( "parm_radius" ), 12.25  )
		# values haven't been flushed yet
		self.assertAlmostEqual( fn.getProcedural().parameters()["radius"].getTypedValue(), 1 )
		# so we flush them
		fn.setParameterisedValues()
		self.assertAlmostEqual( fn.getProcedural().parameters()["radius"].getTypedValue(), 12.25 )
Exemple #44
0
	def testAnimatedValues( self ) :
		
		noise = IECoreHoudini.FnOpHolder.create( "test", "noiseDeformer", 1 )
		fn = IECoreHoudini.FnOpHolder( noise )
		noise.parm( "parm_magnitude" ).setExpression( "$FF" )
		hou.setFrame( 1 )
		self.assertEqual( noise.evalParm( "parm_magnitude" ), 1 )
		self.assertEqual( fn.getOp().parameters()["magnitude"].getTypedValue(), 1 )
		hou.setFrame( 12.25 )
		self.assertEqual( noise.evalParm( "parm_magnitude" ), 12.25  )
		# values haven't been flushed yet
		self.assertAlmostEqual( fn.getOp().parameters()["magnitude"].getTypedValue(), 1 )
		# so we flush them
		fn.setParameterisedValues()
		self.assertAlmostEqual( fn.getOp().parameters()["magnitude"].getTypedValue(), 12.25 )
def run():
    hou.hipFile.addEventCallback(scene_event_callback)
    hou.hipFile.clear(suppress_save_prompt=False)
    with hou.undos.group("Demo"):
        hou.setUpdateMode(hou.updateMode.Manual)
        demobox.DemoBox()
        create_cam()
        hou.setUpdateMode(hou.updateMode.AutoUpdate)
        hou.playbar.setRealTime(True)
        hou.setFrame(25)
        create_mantra()
        create_cop()
        hou.node('/obj').layoutChildren()
    hou.hipFile.removeEventCallback(scene_event_callback)
    hou.hipFile.save(hou.hscriptExpandString('$TEMP') + '/demo.hip')
Exemple #46
0
	def testAnimatedValues( self ) :
		
		noise = IECoreHoudini.FnOpHolder.create( "test", "noiseDeformer", 1 )
		fn = IECoreHoudini.FnOpHolder( noise )
		noise.parm( "parm_magnitude" ).setExpression( "$FF" )
		hou.setFrame( 1 )
		self.assertEqual( noise.evalParm( "parm_magnitude" ), 1 )
		self.assertEqual( fn.getOp().parameters()["magnitude"].getTypedValue(), 1 )
		hou.setFrame( 12.25 )
		self.assertEqual( noise.evalParm( "parm_magnitude" ), 12.25  )
		# values haven't been flushed yet
		self.assertAlmostEqual( fn.getOp().parameters()["magnitude"].getTypedValue(), 1 )
		# so we flush them
		fn.setParameterisedValues()
		self.assertAlmostEqual( fn.getOp().parameters()["magnitude"].getTypedValue(), 12.25 )
Exemple #47
0
def cacheWrite(startFrame, endFrame, subFrame, format, mode):
    #expected format abc(Alembic), bgeo(Houdini bgeo)
    #expected mode add,

    selectedNodes = hou.selectedNodes()
    parent = selectedNodes[0].parent()
    ropnet = hou.node(parent.path()).createNode("ropnet")

    hou.setFrame(startFrame)

    message = ''

    for n in selectedNodes:

        if mode == 'version': cachePath = makeCachePath(n, 'add')
        if mode == 'overwrite': cachePath = makeCachePath(n, 'get')[-1]

        if format == 'abc':
            cacheProperty = ['abc', 'alembic', 'filename', '.abc', 'objects']
        if format == 'bgeo':
            cacheProperty = [
                '$F4.bgeo', 'geometry', 'sopoutput', '.$F4.bgeo', 'soppath'
            ]

        message += 'NODE' + ' - ' + n.path(
        ) + ' > ' + 'CACHE - $DATA/geo/' + cachePath.split(
            'geo/')[1] + '/' + n.name() + '.' + cacheProperty[0] + '\n'

        ropNode = hou.node(ropnet.path()).createNode(cacheProperty[1])

        ropNode.setName(n.name() + "_ropNode")

        hou.node(ropNode.path()).parm("trange").set(1)
        hou.node(ropNode.path()).parm("f1").set(startFrame)
        hou.node(ropNode.path()).parm("f2").set(endFrame)
        hou.node(ropNode.path()).parm("f3").set(1.0 / subFrame)

        hou.node(ropNode.path()).parm(cacheProperty[2]).set(
            os.path.join(cachePath,
                         n.name() + cacheProperty[3]))

        hou.node(ropNode.path()).parm(cacheProperty[4]).set(n.path())

        submitButton = ropNode.parm("execute")
        hou.Parm.pressButton(submitButton)

    hou.ui.displayMessage(message)
    ropnet.destroy()
	def testEmptyGroup( self ) :
		hou.setFrame( 3 )
		cache = self.cacheSop()
		groupA = cache.inputs()[0]
		null = cache.parent().createNode( "null" )
		groupB = null.createOutputNode( "group" )
		groupB.parm( "crname" ).set( "torus2" )
		groupB.parm( "entity" ).set( 1 )
		merge = groupA.createOutputNode( "merge" )
		merge.setInput( 1, groupB )
		cache.setInput( 0, merge )
		result = IECoreHoudini.FromHoudiniPolygonsConverter( cache ).convert()
		numTorusPoints = len(groupA.geometry().points())
		for key in [ "P", "Cs" ] :
			self.assert_( key in result )
			self.assertEqual( result[key].data.size(), numTorusPoints )
Exemple #49
0
def cacheWrite(startFrame, endFrame, subFrame, format, mode):
#expected format abc(Alembic), bgeo(Houdini bgeo)
#expected mode add,


    selectedNodes = hou.selectedNodes()
    parent = selectedNodes[0].parent()
    ropnet = hou.node(parent.path()).createNode("ropnet")

    hou.setFrame(startFrame)

    message = ''

    for n in selectedNodes:

        if mode == 'version': cachePath = makeCachePath(n, 'add')
        if mode == 'overwrite': cachePath = makeCachePath(n, 'get')[-1]
           
        if format == 'abc': cacheProperty = ['abc', 'alembic', 'filename', '.abc', 'objects']
        if format == 'bgeo': cacheProperty = ['$F4.bgeo', 'geometry', 'sopoutput', '.$F4.bgeo', 'soppath']


        message += 'NODE' + ' - ' + n.path() + ' > ' + 'CACHE - $DATA/geo/' + cachePath.split('geo/')[1] + '/' + n.name() + '.' + cacheProperty[0] + '\n'
        
        
        ropNode = hou.node(ropnet.path()).createNode(cacheProperty[1])

        ropNode.setName(n.name()+"_ropNode")
    
        hou.node(ropNode.path()).parm("trange").set(1)
        hou.node(ropNode.path()).parm("f1").set(startFrame)
        hou.node(ropNode.path()).parm("f2").set(endFrame)
        hou.node(ropNode.path()).parm("f3").set(1.0/subFrame)
        
        
        hou.node(ropNode.path()).parm(cacheProperty[2]).set(os.path.join(cachePath, n.name() + cacheProperty[3]))
        
        
        hou.node(ropNode.path()).parm(cacheProperty[4]).set(n.path())

        submitButton = ropNode.parm("execute")
        hou.Parm.pressButton(submitButton)

    hou.ui.displayMessage(message)
    ropnet.destroy()
	def testAnimatingGeometry( self ) :
		obj = hou.node( "/obj" )
		geo = obj.createNode( "geo", run_init_scripts=False )
		torus = geo.createNode( "torus" )
		facet = geo.createNode( "facet" )
		facet.parm("postnml").set(True)
		mountain = geo.createNode( "mountain" )
		mountain.parm("offset1").setExpression( "$FF" )
		facet.setInput( 0, torus )
		mountain.setInput( 0, facet )
		converter = IECoreHoudini.FromHoudiniPolygonsConverter( mountain )
		hou.setFrame( 1 )
		mesh1 = converter.convert()
		hou.setFrame( 2 )
		converter = IECoreHoudini.FromHoudiniPolygonsConverter( mountain )
		mesh2 = converter.convert()
		self.assertNotEqual( mesh1["P"].data, mesh2["P"].data )
		self.assertNotEqual( mesh1, mesh2 )
	def testTransformAttribute( self ) :
		cache = self.cacheSop()
		hou.setFrame( 2 )
		orig = IECoreHoudini.FromHoudiniPolygonsConverter( cache ).convert()
		cache.parm( "transformAttribute" ).set( "transform" )
		result = IECoreHoudini.FromHoudiniPolygonsConverter( cache ).convert()
		self.assertNotEqual( orig, result )
		self.assertNotEqual( orig['P'], result['P'] )
		self.assertEqual( orig['P'].data.size(), result['P'].data.size() )
		self.assertEqual( orig['Cs'], result['Cs'] )
		self.assertEqual( orig['pointId'], result['pointId'] )
		
		i = IECore.InterpolatedCache( cache.parm( "cacheSequence" ).eval(), IECore.InterpolatedCache.Interpolation.Linear, IECore.OversamplesCalculator( 24, 1 ) )
		matrix = i.read( 2, "torus", "transform" ).value.transform
		origP = orig["P"].data
		resultP = result["P"].data
		for i in range( 0, origP.size() ) :
			self.assertNotEqual( resultP[i], origP[i] )
			self.assertEqual( resultP[i], matrix.multVecMatrix( origP[i] ) )
	def testMultipleObjects( self ) :
		hou.setFrame( 3 )
		cache = self.cacheSop()
		torus = cache.parent().createNode( "file" )
		torus.parm( "file" ).set( TestInterpolatedCacheReader.__torusTestFile )
		group = torus.createOutputNode( "group" )
		group.parm( "crname" ).set( "torus2" )
		group.parm( "entity" ).set( 1 )
		merge = cache.inputs()[0].createOutputNode( "merge" )
		merge.setInput( 1, group )
		cache.setInput( 0, merge )
		result = IECoreHoudini.FromHoudiniPolygonsConverter( cache ).convert()
		numTorusPoints = len(torus.geometry().points()) 
		for key in [ "P", "Cs" ] :
			self.assert_( key in result )
			self.assertEqual( result[key].data.size(), 2 * numTorusPoints )
		
		for i in range( 0, numTorusPoints ) :
			self.assertNotEqual( result['P'].data[i], result['P'].data[numTorusPoints+i] )
			self.assertEqual( result['Cs'].data[i], result['Cs'].data[numTorusPoints+i] )
Exemple #53
0
	def testRenderWriterCOB(self):
		cache_file = "test/cortexWriter_testData/test.$F4.cob"
		writer = self.testCreateWriter()
		# set to cob
		writer.parm("export_format").set(1)
		# set path
		writer.parm("export_path").set(cache_file)
		# render
		self.render(writer, (1,100) )
		# check files
		files = glob.glob( "test/cortexWriter_testData/test.????.cob" )
		self.assertEqual( len(files), 100 )
		# load cob
		geo_1 = IECore.Reader.create( "test/cortexWriter_testData/test.0001.cob" ).read()
		geo_2 = IECore.Reader.create( "test/cortexWriter_testData/test.0051.cob" ).read()
		geo_3 = IECore.Reader.create( "test/cortexWriter_testData/test.0100.cob" ).read()
		# compare with a converter
		hou.setFrame(1)
		converter = IECoreHoudini.FromHoudiniGeometryConverter.create( writer.inputs()[0] )
		self.assertEqual( geo_1, converter.convert() )
		self.assertNotEqual( geo_2, converter.convert() )
		hou.setFrame(51)
		converter = IECoreHoudini.FromHoudiniGeometryConverter.create( writer.inputs()[0] )
		self.assertEqual( geo_2, converter.convert() )
		hou.setFrame(100)
		converter = IECoreHoudini.FromHoudiniGeometryConverter.create( writer.inputs()[0] )
		self.assertEqual( geo_3, converter.convert() )
	def keyParentTransformAnim_main(self, **connections):

		try:
			nodeToKey=str(connections["nodeToKey"])
		except:
			nodeToKey=""
		try:
			TMatrixNode=str(connections["TMatrixNode"])
		except:
			TMatrixNode=""	
		try:
			ntc=hou.node(nodeToKey)
			tn=hou.node(TMatrixNode)
			for val in ntc.parm("tx").keyframes():
				hou.setFrame(val.frame())
				ntc.parm("tx").set(val.value()*tn.parm("sx").eval()+tn.parm("tx").eval())
			for val in ntc.parm("ty").keyframes():
				hou.setFrame(val.frame())
				ntc.parm("ty").set(val.value()*tn.parm("sy").eval()+tn.parm("ty").eval())
			for val in ntc.parm("tz").keyframes():
				hou.setFrame(val.frame())
				ntc.parm("tz").set(val.value()*tn.parm("sz").eval()+tn.parm("tz").eval())
			return 1

		except:
			return 0
	def testAnimatingGeometry( self ) :
		obj = hou.node("/obj")
		geo = obj.createNode("geo", run_init_scripts=False)
		torus = geo.createNode( "torus" )
		facet = geo.createNode( "facet" )
		facet.parm("postnml").set(True)
		mountain = geo.createNode( "mountain" )
		if hou.applicationVersion()[0] >= 16:
			mountain.parm( "offsetx" ).setExpression( "$FF" )
		else:
			mountain.parm("offset1").setExpression( "$FF" )
		points = geo.createNode( "scatter" )
		facet.setInput( 0, torus )
		mountain.setInput( 0, facet )
		points.setInput( 0, mountain )
		converter = IECoreHoudini.FromHoudiniPointsConverter( points )
		hou.setFrame(1)
		points_1 = converter.convert()
		hou.setFrame(2)
		converter = IECoreHoudini.FromHoudiniPointsConverter( points )
		points_2 = converter.convert()
		self.assertNotEqual( points_1["P"].data, points_2["P"].data )
	def testAttributeMismatchBetweenFrames( self ) :
		cache = self.cacheSop()
		hou.setFrame( 1.5 )
		self.failUnless( isinstance( cache.geometry(), hou.Geometry ) )
		orig = IECoreHoudini.FromHoudiniPolygonsConverter( cache ).convert()
		hou.setFrame( 2.5 )
		self.assertEqual( cache.geometry(), None )
		self.failUnless( "Entry not found" in cache.errors() )
		hou.setFrame( 3 )
		result = IECoreHoudini.FromHoudiniPolygonsConverter( cache ).convert()
		self.failUnless( isinstance( cache.geometry(), hou.Geometry ) )
		self.assertNotEqual( orig, result )
Exemple #57
0
def bakeObjectToWorld(startFrame, endFrame):
    selectedNode=hou.selectedNodes()
    selectedNodeName=selectedNode[0].name()
    parent=selectedNode[0].parent()
    bakeNode=hou.copyNodesTo(selectedNode,parent)
    bakeNode[0].setName(selectedNodeName + "_bake")
    bakeNode[0].parm("keeppos").set(0)
    fetchNode=hou.node(parent.path()).createNode("fetch","fetch_"+selectedNodeName)
    hou.node(fetchNode.path()).parm("fetchobjpath").set(selectedNode[0].path())
    hou.node(fetchNode.path()).parm("useinputoffetched").set(1)
    nullNode=hou.node(parent.path()).createNode("null")
    nullNode.setFirstInput(fetchNode)
    nullNodeName=nullNode.name()
    
    
    parms=["tx","ty","tz","rx","ry","rz"]
    constant=["TX","TY","TZ","RX","RY","RZ"]
    
    
    bakeNode[0].setInput(0,None)
    
    #delete expresssion in parms and set to 0
    for p in parms:
      bakeNode[0].parm(p).deleteAllKeyframes()
      hou.hscript('objextractpretransform '+ bakeNode[0].path())
      bakeNode[0].parm(p).set(0)
    
    
    
    for p, c in zip(parms, constant):
        #bakeNode[0].parm(p).deleteAllKeyframes()
        hou.node(bakeNode[0].path()).parm(p).setExpression('origin("","../'+nullNodeName+'",'+c+')')
    
    
    
    #add dict for hou.Keyframe and values    
    key = dict([(x, hou.Keyframe()) for x in parms])
    values = dict([(x, []) for x in constant])
          
    #bake time range
    timeRange = xrange(startFrame,endFrame+1)
    
    
    #fill values dict
    for t in timeRange:
        hou.setFrame(t)
        for v, p in zip(constant,parms):
	    values[v].append(bakeNode[0].parm(p).eval())
	    
    
    for p in parms:
      bakeNode[0].parm(p).deleteAllKeyframes()
      bakeNode[0].parm(p).set(0)
    
    #set key by keyframes
    
    for t in timeRange:
	hou.setFrame(t)
	for v, p, k in zip(constant,parms,key):
	  key[k].setValue(values[v][t-startFrame])
	  bakeNode[0].parm(p).setKeyframe(key[k])
    
    fetchNode.destroy()
    nullNode.destroy()
	def createTurntable_main(self, **connections):
		try:
			dbPath=connections["dbPath"]
		except:
			dbPath=""
		try:
			Type=connections["Type"]
		except:
			Type=""
		try:
			Name=str(connections["Name"])
		except:
			Name=""
		try:
			Version=str(connections["Version"])
		except:
			Version=""
		try:
			oas_output=connections["oas_output"]
		except:
			oas_output="hipFile"		

		if str(geT(dbPath))=="" or str(geT(dbPath))=="0":
			return 0

		vers=getVerFrompath(str(dbPath)+":Model@"+str(Version))
		vPath=gVP(str(dbPath)+":Model@"+str(vers))


		if Type=="Model":
			sure="01_Model"
		elif Type=="Material":
			sure="02_Material"
		else:
			sure="03_Misc"


		projj=ref(str(dbPath).split(":")[1])
		renderdir="/W/Projects/"+projj+"/60_PreRenders/Turntable/"+sure+"/"+str(Name)+"/"+str(vers)
		seqdir=renderdir+"/seq"
		movdir=renderdir+"/mov"

		if os.path.isdir(seqdir):
			pass
		else:
			os.makedirs(seqdir)
		if os.path.isdir(movdir):
			pass
		else:
			os.makedirs(movdir)

		if str(vPath)=="0" or vPath=="":
			return 0

		if os.path.isdir(vPath+'/hipFile'):
			pass
		else:
			os.makedirs(vPath+'/hipFile')
		if os.path.isdir(vPath+'/render'):
			pass
		else:
			os.makedirs(vPath+'/render')
		if os.path.isdir(vPath+'/mov'):
			pass
		else:
			os.makedirs(vPath+'/mov')

		hou.hipFile.clear()

		ret1=LHD(Name,"Model",Version,dbPath,"Turntable_Model")
		par=hou.node("/obj/Turntable_Model").parm("ry")
		hou.setFrame(1)
		par.setKeyframe(hou.Keyframe(0))
		hou.setFrame(101)
		par.setKeyframe(hou.Keyframe(720))
		hou.setFrame(1)

		coll=""
		for item in hou.node("/obj/Turntable_Model").children():
			coll+=str(item.path())+" "

		mat_pars=hou.node("/obj/Turntable_Model").parmsInFolder(("Materials",))

		for pa in mat_pars:
			try:
				pa.set("/obj/Turntable_Shader/turntableShop/out")
			except:
				pass
		
		ret2=LHD("LookdevLightRig","Lightrig","latest",":General:Assets:LightSetups:LookdevLightRig","Turntable_Lightrig")
		hou.node("/obj/"+"Turntable_Lightrig").parm("models").set(coll)
		ret3=LHD("modelTurntable","RenderSetup","latest",":General:Assets:RenderSetups:modelTurntable","Turntable_RenderSetup")

		rsobj=hou.node("/obj/Turntable_RenderSetup")
		rsobj.parm("tt_picture").set(seqdir+'/'+Name+".$F4.exr")
		rsobj.parm("tt_comment").set(Name+"_"+vers)

		ret4=LHD("autoscaleCamera","Camera","latest",":General:Assets:CameraSetups:autoscaleCamera","Turntable_LookdevCamera")
		hou.node("/obj/"+"Turntable_LookdevCamera").parm("models").set(coll)
		ret5=LHD("ModelTurntableShader","Shader","latest",":General:Assets:Shaders:ModelTurntableShader","Turntable_Shader")	


		hou.hipFile.save(vPath+'/hipFile/turntable.hip')

		hou.exit()
Exemple #59
0
	def loadHDASets_main(self, **connections):
		try:
			nameOverride=str(connections["nameOverride"])
		except:
			nameOverride=""
		try:
			dbPath=connections["dbPath"]
		except:
			dbPath=""
		try:
			Name=str(connections["Name"])
		except:
			Name=""
		try:
			Type=str(connections["Type"])
		except:
			Type=""
		try:
			Version=str(connections["Version"])
		except:
			Version=""
		try:
			oas_output=connections["oas_output"]
		except:
			oas_output="version"		

		if str(geT(dbPath))=="" or str(geT(dbPath))=="0":
			return 0


		if Type=="Model":
			return LHD(Name,Type,Version,dbPath,nameOverride)
		elif Type=="Engine":
			return LHD(Name,Type,Version,dbPath,nameOverride)
			#hou.node("/obj/"+nameOverride).setDisplayFlag(False)
			#hou.node("/obj/"+nameOverride).setDisplayFlag(True)
		elif Type=="Setup":
			ret=LHD(Name,"Model","latest",dbPath,Name+"_Model")
			try:
				ret2=LHD(Name,"Deform","latest",dbPath,Name+"_Deform")
			except:
				pass
			return LHD(Name,Type,Version,dbPath,Name+"_Setup")
		elif Type=="Material":
			hou.hipFile.clear()
			ret1=LHD(Name,"Model","latest",dbPath,Name+"_Model")
			par=hou.node("/obj/"+Name+"_Model").parm("ry")
			coll=""
			for item in hou.node("/obj/"+Name+"_Model").children():
				coll+=str(item.path())+" "

			for item in hou.node("/obj/"+Name+"_Model").parmsInFolder(("Materials",)):
				try:
					item.set("/obj/"+Name+"_Material/"+str(item.name().split("_shop")[0])+"/out")
				except:
					pass
			hou.setFrame(1)
			par.setKeyframe(hou.Keyframe(0))
			hou.setFrame(101)
			par.setKeyframe(hou.Keyframe(360))
			hou.setFrame(1)
			ret2=LHD("LookdevLightRig","Lightrig","latest",":General:Assets:LightSetups:LookdevLightRig","Lookdev_Lightrig")
			hou.node("/obj/"+"Lookdev_Lightrig").parm("models").set(coll)
			ret3=LHD("LookdevLightRig","RenderSetup","latest",":General:Assets:LightSetups:LookdevLightRig","Lookdev_RenderSetup")
			ret4=LHD("autoscaleCamera","Camera","latest",":General:Assets:CameraSetups:autoscaleCamera","Lookdev_LookdevCamera")
			hou.node("/obj/"+"Lookdev_LookdevCamera").parm("models").set(coll)
			return LHD(Name,Type,Version,dbPath,Name+"_Material")			
		elif Type=="everything":
			ret=LHD(Name,"Model","latest",dbPath,Name+"_Model")
			hou.node("/obj/"+Name+"_Model").setDisplayFlag(False)
			hou.node("/obj/"+Name+"_Model").matchCurrentDefinition()
			LHD(Name,"Setup","latest",dbPath,Name+"_Setup")
			hou.node("/obj/"+Name+"_Setup").setDisplayFlag(False)
			hou.node("/obj/"+Name+"_Setup").matchCurrentDefinition()
			for item in hou.node("/obj/"+Name+"_Model").parmsInFolder(("Materials",)):
				try:
					item.set("/obj/"+Name+"_Material/"+str(item.name().split("_shop")[0])+"/out")
				except:
					pass
			try:
				ret2=LHD(Name,"Deform","latest",dbPath,Name+"_Deform")
				hou.node("/obj/"+Name+"_Deform").matchCurrentDefinition()
				hou.node("/obj/"+Name+"_Deform").setDisplayFlag(False)
			except:
				pass

			LHD(Name,"Material","latest",dbPath,Name+"_Material")
			hou.node("/obj/"+Name+"_Material").matchCurrentDefinition()
			hou.node("/obj/"+Name+"_Material").setDisplayFlag(False)
			return "latest"