def testComputeTime(): nbFrames = 10 N = 0 print("testComputeTime %d" % N); N += 1 gA = tuttle.Graph() gA.createNode( "tuttle.avreader", filename="TuttleOFX-data/video/bars_100.avi", v_colorspace=2 ) print("testComputeTime %d" % N); N += 1 t0 = time.clock() time0 = time.time() print("testComputeTime %d" % N); N += 1 gA.compute( tuttle.ComputeOptions(0, nbFrames) ) t1 = time.clock() time1 = time.time() print("testComputeTime %d" % N); N += 1 rangeCompute_duration = t1-t0 rangeCompute_timeDuration = time1-time0 print("testComputeTime %d" % N); N += 1 gB = tuttle.Graph() gB.createNode( "tuttle.avreader", filename="TuttleOFX-data/video/bars_100.avi", v_colorspace=2 ) print("testComputeTime %d" % N); N += 1 t0 = time.clock() time0 = time.time() print("compute frame by frame") for i in range(0, nbFrames): print("compute frame %d" % i) gB.compute( tuttle.ComputeOptions(i) ) t1 = time.clock() time1 = time.time() print("testComputeTime %d" % N); N += 1 frameByFrameCompute_duration = t1-t0 frameByFrameCompute_timeDuration = time1-time0 print("testComputeTime %d" % N); N += 1 diff = frameByFrameCompute_duration - rangeCompute_duration diffTime = frameByFrameCompute_timeDuration - rangeCompute_timeDuration print("_"*10) print("rangeCompute_duration:", rangeCompute_duration) print("frameByFrameCompute_duration:", frameByFrameCompute_duration) print("diff duration:", diff) print("-"*10) print("rangeCompute_timeDuration:", rangeCompute_timeDuration) print("frameByFrameCompute_timeDuration:", frameByFrameCompute_timeDuration) print("diff time duration:", diffTime) print("_"*10) print("testComputeTime %d" % N); N += 1
def testMultipleCompute_renderSomeFrames(): g = tuttle.Graph() checkerboard = g.createNode("tuttle.checkerboard", size=[50, 50]) invert = g.createNode("tuttle.invert") write = g.createNode("tuttle.pngwriter", filename=".tests/output.png") g.connect([checkerboard, invert, write]) assert g.compute(write, tuttle.ComputeOptions(0)) assert g.compute(write, tuttle.ComputeOptions(5)) assert g.compute(write, tuttle.ComputeOptions(0))
def testMergeWithSameChildrens(): g = tuttle.Graph() read = g.createNode("tuttle.checkerboard", size=[100, 200], explicitConversion="8i") scale = g.createNode("tuttle.swscale", width=150) effect = g.createNode("tuttle.invert") merge = g.createNode("tuttle.merge", offsetA=[150, 0], mergingFunction="copy", rod="union") write = g.createNode("tuttle.invert") # read -> scale -> effect # \ \ # -----------> merge -> write g.connect([read, scale, effect]) g.connect(scale, merge.getAttribute("B")) g.connect(effect, merge.getAttribute("A")) g.connect(merge, write) outputCache = tuttle.MemoryCache() g.compute(outputCache, write, tuttle.ComputeOptions(5)) # We retrieve the output image buffer, and we could read the image size rodMerge = outputCache.get(0).getROD() print(rodMerge.x1, rodMerge.y1, rodMerge.x2, rodMerge.y2) assert rodMerge.x1 == 0 assert rodMerge.y1 == 0 assert rodMerge.x2 == 300 assert rodMerge.y2 == 300
def testCompute(): graph = tuttle.Graph() n = [ tuttle.NodeInit( "tuttle.exrreader", filename="TuttleOFX-data/image/openexr/DisplayWindow/t##.exr"), tuttle.NodeInit("tuttle.invert"), tuttle.NodeInit("tuttle.gamma", master=.5), tuttle.NodeInit("tuttle.jpegwriter", filename=".tests/fromExr/output-####.jpg"), ] nodes = graph.addConnectedNodes(n) procOptions = tuttle.ComputeOptions() procGraph = tuttle.ProcessGraph(procOptions, graph, []) print "before compute" outputCache = tuttle.MemoryCache() timeRange = tuttle.TimeRange(1, 16, 10) print "setup" procGraph.setup() print "beginSequence" procGraph.beginSequence(timeRange) for time in xrange(timeRange._begin, timeRange._end, timeRange._step): print "time:", time procGraph.setupAtTime(time) procGraph.processAtTime(outputCache, time) print "endSequence" procGraph.endSequence() print "after compute"
def testTranscodeToDefaultCodec(): tuttle.compute( [ tuttle.NodeInit( "tuttle.avreader", filename="TuttleOFX-data/video/bars_100.avi", v_colorspace=2 ), # video with PAR 16/15=1.066667 tuttle.NodeInit( "tuttle.invert" ), tuttle.NodeInit( "tuttle.avwriter", filename=".tests/testTrancodeToDefaultCodec.mov", v_colorspace=2, v_aspect=[0,1] ), ], tuttle.ComputeOptions(0,20) )
def testTrancodeToMpegpipe(): tuttle.compute([ tuttle.NodeInit("tuttle.avreader", filename="TuttleOFX-data/video/flame.avi", colorspace="bt709"), tuttle.NodeInit("tuttle.avwriter", filename=".tests/testTrancodeToMpegpipe.y4m", format="yuv4mpegpipe", videoCodec="rawvideo", colorspace="bt709", aspect=[0, 1]), ], tuttle.ComputeOptions(0, 10))
def computeNode(self, node, frame): """ Computes the node (displayed in the viewer) at the frame indicated. """ buttleData = ButtleDataSingleton().get() graphTuttle = buttleData.getGraph().getGraphTuttle() #Get the output where we save the result self._tuttleImageCache = tuttle.MemoryCache() if buttleData.getVideoIsPlaying(): # if a video is playing processGraph = buttleData.getProcessGraph() processGraph.setupAtTime(frame) processGraph.processAtTime(self._tuttleImageCache, frame) else: # if it's an image only processOptions = tuttle.ComputeOptions(int(frame)) processGraph = tuttle.ProcessGraph(processOptions, graphTuttle, [node]) processGraph.setup() timeRange = tuttle.TimeRange(frame, frame, 1) # buttleData.getTimeRange() processGraph.beginSequence(timeRange) processGraph.setupAtTime(frame) processGraph.processAtTime(self._tuttleImageCache, frame) processGraph.endSequence() self._computedImage = self._tuttleImageCache.get(0) #Add the computedImage to the map hashMap = tuttle.NodeHashContainer() graphTuttle.computeGlobalHashAtTime(hashMap, frame) hasCode = hashMap.getHash(node, frame) #Max 15 computedImages saved in memory if hasCode not in buttleData._mapNodeNameToComputedImage.keys( ) and len(buttleData._mapNodeNameToComputedImage) < 15: buttleData._mapNodeNameToComputedImage.update( {hasCode: self._computedImage}) elif hasCode not in buttleData._mapNodeNameToComputedImage.keys( ) and len(buttleData._mapNodeNameToComputedImage) >= 15: #Delete a computed image from the memory (random) buttleData._mapNodeNameToComputedImage.popitem() buttleData._mapNodeNameToComputedImage.update( {hasCode: self._computedImage}) return self._computedImage
def computeGraph(renderSharedInfo, newRender, bundlePaths): try: renderSharedInfo['startDate'] = time.time() configLocalPluginPath(bundlePaths) renderSharedInfo['status'] = 1 tuttleGraph = loadGraph(newRender['scene']) logging.error('tuttle graph:' + str(tuttleGraph)) print('tuttle graph:' + str(tuttleGraph)) renderSharedInfo['status'] = 2 tuttleComputeOptions = tuttle.ComputeOptions() if 'options' in newRender['scene']: for option in newRender['scene']['options']: if "TimeRange" in option['id']: begin = option['values']['begin'] end = option['values']['end'] step = option['values']['step'] tuttleComputeOptions.setTimeRange(begin, end, step) if "RenderScale" in option['id']: x = option['values']['x'] y = option['values']['y'] tuttleComputeOptions.setRenderScale(x, y) ## Create handle and set it in ComputeOptions progressHandle = ProgressHandle(renderSharedInfo) tuttleComputeOptions.setProgressHandle(progressHandle) tuttleGraph.compute(tuttleComputeOptions) renderSharedInfo['status'] = 3 except Exception as e: logging.error("_" * 80) logging.error(" " * 20 + "RENDER ERROR") logging.error(str(e)) # logging.error("bundlePaths:", str(bundlePaths)) # logging.error("tuttleGraph:", str(tuttleGraph)) logging.error("_" * 80) renderSharedInfo['status'] = -1 raise
def launchProcessGraph(self): buttleData = ButtleDataSingleton().get() #Get the name of the currentNode of the viewer node = buttleData.getCurrentViewerNodeName() # initialization of the process graph graph = buttleData.getGraph().getGraphTuttle() # timeRange between the frames of beginning and end (first frame, last frame, step) timeRange = tuttle.TimeRange(self._frame, self._nbFrames, 1) self._processOptions = tuttle.ComputeOptions(self._frame, self._nbFrames, 1) processGraph = tuttle.ProcessGraph(self._processOptions, graph, [node]) processGraph.setup() processGraph.beginSequence(timeRange) # communicate processGraph to buttleData buttleData.setProcessGraph(processGraph) buttleData.setVideoIsPlaying(True)
def endSequence(self): """ Called at the end of the process """ print "---> endSequence" if len(argv) != 3: print "Script args : [email protected] [email protected]" exit() pathIn = argv[1] pathOut = argv[2] # ComputeOption init co = tuttle.ComputeOptions() co.setVerboseLevel(tuttle.eVerboseLevelError) ## Create handle and set it in ComputeOptions handle = ProgressHandle(start) co.setProgressHandle(handle) # Create nodes extIn = os.path.splitext(pathIn)[1] extOut = os.path.splitext(pathOut)[1] readerInPlug = tuttle.getBestReader(extIn) writerOutPlug = tuttle.getBestWriter(extOut) if len(readerInPlug) == 0: print "ERROR: unsupported input file : " + extIn exit() if len(writerOutPlug) == 0: print "ERROR: unsupported input file : " + extOut exit()
) g.connect([text_blur, blur]) g.connect(blur, text_merge.getClip('B')) g.connect(text, text_merge.getClip('A')) # Connect and merge text and constant constant_text_merge = g.createNode( 'tuttle.merge', rod='B', mergingFunction='over', ) g.connect(constant, constant_text_merge.getClip('B')) g.connect(text_merge, constant_text_merge.getClip('A')) # Connect and merge reader with the rest # Create merge image_merge = g.createNode('tuttle.merge', rod='union', mergingFunction='over', offsetB=(0, -(1080 - 804) / 2)) g.connect(reader, image_merge.getClip('A')) g.connect(constant_text_merge, image_merge.getClip('B')) # Write the result g.connect([image_merge, writer]) # Set options and writer node co = tuttle.ComputeOptions(int(td.min), int(td.max)) g.compute(writer, co)
from pyTuttle import tuttle tuttle.core().preload() g = tuttle.Graph() read = g.createNode("tuttle.pngreader", filename="data/input.png") blur = g.createNode("tuttle.blur", size={1.0: [80.0, 40.0], 9.0: 0.0}) write = g.createNode("tuttle.pngwriter", filename="data/output_####.png") # Read arbitrary blur values, to see the interpolation s = blur.getParam("size") for i in xrange(0, 10 * 5): t = i / 5.0 # step is 0.2 print "blur size at ", t, ":", \ "(", s.getDoubleValueAtTimeAndIndex(t, 0), ", ", \ s.getDoubleValueAtTimeAndIndex(t, 1), ")" g.connect([read, blur, write]) g.compute(write, tuttle.ComputeOptions(1, 9, 3))
def testComputeTime(): N = 0 print "testComputeTime %d" % N N += 1 gA = tuttle.Graph() gA.createNode("tuttle.avreader", filename="TuttleOFX-data/video/bars_100.avi", colorspace="bt709") print "testComputeTime %d" % N N += 1 t0 = time.clock() time0 = time.time() print "testComputeTime %d" % N N += 1 gA.compute(tuttle.ComputeOptions(0, 200)) t1 = time.clock() time1 = time.time() print "testComputeTime %d" % N N += 1 rangeCompute_duration = t1 - t0 rangeCompute_timeDuration = time1 - time0 print "testComputeTime %d" % N N += 1 gB = tuttle.Graph() gB.createNode("tuttle.avreader", filename="TuttleOFX-data/video/bars_100.avi", colorspace="bt709") print "testComputeTime %d" % N N += 1 t0 = time.clock() time0 = time.time() print "compute frame by frame" for i in xrange(0, 200): print "compute frame %d" % i gB.compute(tuttle.ComputeOptions(i)) t1 = time.clock() time1 = time.time() print "testComputeTime %d" % N N += 1 frameByFrameCompute_duration = t1 - t0 frameByFrameCompute_timeDuration = time1 - time0 print "testComputeTime %d" % N N += 1 diff = frameByFrameCompute_duration - rangeCompute_duration diffTime = frameByFrameCompute_timeDuration - rangeCompute_timeDuration print "_" * 10 print "rangeCompute_duration:", rangeCompute_duration print "frameByFrameCompute_duration:", frameByFrameCompute_duration print "diff duration:", diff print "-" * 10 print "rangeCompute_timeDuration:", rangeCompute_timeDuration print "frameByFrameCompute_timeDuration:", frameByFrameCompute_timeDuration print "diff time duration:", diffTime print "_" * 10 print "testComputeTime %d" % N N += 1
def run(self, parser): """ Process the do operation. """ # Parse command-line args, unknown = parser.parse_known_args() # Set sam log level self.setLogLevel(args.verbose) # set tuttle host log level tuttle.core().getFormatter().setLogLevel(args.verbose) # Clear plugin cache if args.rebuildPluginCache: tuttle.core().getPluginCache().clearPluginFiles() # preload OFX plugins if args.noPluginCache: tuttle.core().preload(False) else: tuttle.core().preload(True) # sam-do --nodes if args.nodes: self._displayPlugins() exit(0) # sam-do --file-formats if args.fileFormats: self._displayFileFormats() exit(0) # sam-do --help if self._isCommandLineAskForHelp(args.inputs, unknown): self._displayCommandLineHelp(parser) exit(0) # Check sam-do command line if self._isCommandLineInvalid(args.inputs, unknown): self._displayCommandLineHelp(parser) exit(1) # Add unknown options to the command line to process args.inputs.extend(unknown) # Split command line splitCmd = samDoUtils.SplitCmd(args.inputs, args.noRecursivity) graphsWithNodes = [] for splitCmdGraph in splitCmd.getGraphs(): self.logger.debug('Create the following tuttle graph: \n' + str(splitCmdGraph)) try: graphsWithNodes.append(self._getTuttleGraph(splitCmdGraph)) except Exception as e: self.logger.error('Cannot create tuttle graph') self.logger.debug('\n' + str(splitCmdGraph)) self.logger.debug(e) if not graphsWithNodes: self.logger.error('No tuttle graph to compute.') exit(1) error = 0 # Compute the corresponding tuttle graphs for graph, nodes in graphsWithNodes: # Options of process options = tuttle.ComputeOptions() # sam-do --ranges if args.ranges is not None: self._setTimeRanges(options, args.ranges) # sam-do --continue-on-error options.setContinueOnError(args.continueOnError) # sam-do --stop-on-missing-files options.setContinueOnMissingFile(not args.stopOnMissingFiles) # Set progress handle ranges = options.getTimeRanges() if not len(ranges): # get time domaine try: timeDomain = nodes[0].asImageEffectNode( ).computeTimeDomain() ranges = [] ranges.append( tuttle.TimeRange(int(timeDomain.min), int(timeDomain.max), 1)) except Exception as e: # the first added node has no filename set pass progress = samDoUtils.ProgressHandle(ranges) options.setProgressHandle(progress) if not nodes: self.logger.warning('No tuttle nodes to compute') continue # Connect and compute try: graph.compute(nodes[-1], options) except Exception as e: self.logger.error('Tuttle graph computation has failed.') self.logger.debug(e) error = 1 self.logger.info('Memory usage: ' + str(int(samUtils.memoryUsageResource())) + 'KB') exit(error)