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)
