Indigo Renderer Forum

Code: Select all

#!/usr/env python

import indigo

# Utils

import threading

class TimerThread(threading.Thread):
	"""Periodically call self.kick(). The period of time in seconds
	between calling is given by self.KICK_PERIOD, and the first call
	may be delayed by setting self.STARTUP_DELAY, also in seconds.
	self.kick() will continue to be called at regular intervals until
	self.stop() is called. Since this is a thread, calling self.join()
	may be wise after calling self.stop() if self.kick() is performing
	a task necessary for the continuation of the program.
	The object that creates this TimerThread may pass into it data
	needed during self.kick() as a dict LocalStorage in __init__().
	
	"""
	STARTUP_DELAY = 0
	KICK_PERIOD = 8
	
	active = True
	timer = None
	
	LocalStorage = None
	
	def __init__(self, LocalStorage=dict()):
		threading.Thread.__init__(self)
		self.LocalStorage = LocalStorage
	
	def set_kick_period(self, period):
		"""Adjust the KICK_PERIOD between __init__() and start()"""
		self.KICK_PERIOD = period + self.STARTUP_DELAY
	
	def stop(self):
		"""Stop this timer. This method does not join()"""
		self.active = False
		if self.timer is not None:
			self.timer.cancel()
			
	def run(self):
		"""Timed Thread loop"""
		while self.active:
			self.timer = threading.Timer(self.KICK_PERIOD, self.kick_caller)
			self.timer.start()
			if self.timer.isAlive(): self.timer.join()
	
	def kick_caller(self):
		"""Intermediary between the kick-wait-loop and kick to allow
		adjustment of the first KICK_PERIOD by STARTUP_DELAY
		
		"""
		if self.STARTUP_DELAY > 0:
			self.KICK_PERIOD -= self.STARTUP_DELAY
			self.STARTUP_DELAY = 0
		
		self.kick()
	
	def kick(self):
		"""Sub-classes do their work here"""
		pass

# Rendering monitoring

def indigo_log(string):
	print(string)

def handler_LOG(msg):
	indigo_log('RENDERING: %s' % msg[:-1]) # Remove annoying extra \n from message
	return False
		
def handler_EVENT(msg):
	if msg == indigo.IndigoEventType.HALT_REQUESTED:
		indigo_log('Halt condition reached')
		return True
			
	return False
		
def handler_ERROR(msg):
	indigo_log('ERROR: %s' % msg)
	return True
		
class IndigoMessageThread(TimerThread):
	KICK_PERIOD = 0.5
			
	message_handlers = {
		indigo.indigo.IndigoMessageType.LOG:	handler_LOG,
		indigo.indigo.IndigoMessageType.EVENT:	handler_EVENT,
		indigo.indigo.IndigoMessageType.ERROR:	handler_ERROR,
	}
			
	def kick(self):
		msgs = self.LocalStorage['renderer'].get_messages()
		if len(msgs) > 0:
			stop = False
			for type, msg in msgs:
				if type in self.message_handlers.keys():
					if self.message_handlers[type](msg):
						stop = True
			
			if stop:
				self.stop()
		
class IndigoStatsThread(TimerThread):
	KICK_PERIOD = 0.5
	stats_string = ''
	def kick(self):
		self.stats_string = '%s | %0.2f kS/Sec | %0.2f Samples/Px' % (
			format_elapsed_time(self.LocalStorage['renderer'].get_render_time()),
			self.LocalStorage['renderer'].get_samples_per_second() / 1000.0,
			self.LocalStorage['renderer'].get_samples_per_pixel(),
		)
		indigo_log(self.stats_string)
		
class IndigoFramebufferThread(TimerThread):
	KICK_PERIOD = 30
	def kick(self):
		renderer = self.LocalStorage['renderer']
				
		xres, yres, combined = renderer.blenderCombinedRect(True) # RGC = True
				
		if xres > 0 and yres > 0 and len(combined) > 0:
			# Do something with the image data in combined variable
		else:
			indigo_log('Invalid framebuffer: %ix%ix%i' % (xres, yres, len(combined)))

# Rendering instance

renderer = indigo.Context(
	"PATH_TO_SDK_BINARIES",
	"PATH_TO_OUTPUT"
)

# Periodically get messages from Indigo's message queue
message_thread = IndigoMessageThread(
	{ 'renderer': renderer }
)

message_thread.start()

# Load the scene file into the renderer
if not renderer.load_igs("PATH_TO_IGS"):
	print("ERROR Loading scene.")
	exit()

# Start the rendering
renderer.build_scene()
renderer.start_rendering()

# Periodically print rendering stats/progress etc
stats_thread = IndigoStatsThread(
	{ 'renderer': renderer }
)

stats_thread.start()

# Periodically get the rendered image back from Indigo
framebuffer_thread = IndigoFramebufferThread(
	{ 'renderer': renderer }
)

framebuffer_thread.start()

# Wait for rendering to complete; this is detected by the message_thread terminating
while message_thread.isAlive():
	# wait; you could do other tasks here asynchronously as the render progresses....
	sleep(1)


# Clean up

stats_thread.stop()
stats_thread.join()
message_thread.stop()
message_thread.join()
framebuffer_thread.stop()
framebuffer_thread.join()
renderer = None