def CreateConfig(self, type):
# Load the configuration from file
props = pyluxcore.Properties("resources/scenes/simple/simple.cfg")
# Change the render engine to PATHCPU
props.Set(pyluxcore.Property("renderengine.type", ["PATHCPU"]))
props.Set(pyluxcore.Property("sampler.type", ["RANDOM"]))
props.Set(GetDefaultEngineProperties("PATHCPU"))
config = pyluxcore.RenderConfig(props)
scene = config.GetScene()
# Delete the red and green boxes
scene.DeleteObject("box1")
scene.DeleteObject("box2")
# Create the base object
props = pyluxcore.Properties()
if (type == "Normal"):
props.SetFromString("""
scene.objects.box1.ply = resources/scenes/simple/simple-mat-cube1.ply
scene.objects.box1.material = redmatte
""")
elif (type == "Instance"):
props.SetFromString("""
scene.objects.box1.ply = resources/scenes/simple/simple-mat-cube1.ply
scene.objects.box1.material = redmatte
scene.objects.box1.transformation = 1.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 1.0 0.0 -0.5 0.0 0.0 1.0
""")
elif (type == "Motion"):
props.SetFromString("""
scene.objects.box1.ply = resources/scenes/simple/simple-mat-cube1.ply
scene.objects.box1.material = redmatte
scene.objects.box1.motion.0.time = 0.0
scene.objects.box1.motion.0.transformation = 1.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 1.0 0.0 -0.25 0.0 0.0 1.0
scene.objects.box1.motion.1.time = 1.0
scene.objects.box1.motion.1.transformation = 1.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 1.0 0.0 0.25 0.0 0.0 1.0
""")
else:
self.assertFalse()
scene.Parse(props)
return config
def resizeEvent(self, event):
if (event.size().width() != self.filmWidth) or (event.size().height() != self.filmHeight):
# Stop the rendering
self.session.Stop()
self.session = None
# Set the new size
self.filmWidth = int(event.size().width())
self.filmHeight = int(event.size().height())
self.config.Parse(pyluxcore.Properties().
Set(pyluxcore.Property("film.width", [self.filmWidth])).
Set(pyluxcore.Property("film.height", [self.filmHeight])))
self.allocateImageBuffers()
# Re-start the rendering
self.session = pyluxcore.RenderSession(self.config)
self.session.Start()
super(RenderView, self).resizeEvent(event)
def renderEnginePathOCL(self, index):
# Stop the rendering
self.session.Stop()
self.session = None
# Change the render engine to PATHCPU
props = self.config.GetProperties()
selectString = list("0" * len(self.deviceList))
selectString[index] = "1"
props.Set(pyluxcore.Property("renderengine.type", ["PATHOCL"])). \
Set(pyluxcore.Property("opencl.devices.select", ["".join(selectString)]))
# Create the new RenderConfig
self.config = pyluxcore.RenderConfig(props, self.scene)
# Re-start the rendering
self.session = pyluxcore.RenderSession(self.config)
self.session.Start()
print("PathOCL selected: %s" % self.deviceList[index][0])
def test_Properties_GetAllUniqueSubNames(self):
props = pyluxcore.Properties()
props.Set(pyluxcore.Property("test1.prop1.aa", "aa"))
props.Set(pyluxcore.Property("test1.prop1.bb", "bb"))
props.Set(pyluxcore.Property("test1.prop1.prop2.aa", "aa"))
props.Set(pyluxcore.Property("test1.prop1.prop2.bb", "bb"))
props.Set(pyluxcore.Property("test1.prop2.aa", "aa"))
props.Set(pyluxcore.Property("test2.prop1.aa", "aa"))
props.Set(pyluxcore.Property("test2.prop1.bb", "bb"))
props.Set(pyluxcore.Property("test2.prop2", "aa"))
props.Set(pyluxcore.Property("test3.prop1.aa", "aa"))
self.assertEqual(props.GetAllUniqueSubNames("test1"),
["test1.prop1", "test1.prop2"])
self.assertEqual(props.GetAllUniqueSubNames("test1.prop1"),
["test1.prop1.prop2"])
def test_Properties_SpaceInName(self):
props = pyluxcore.Properties()
props.Set(pyluxcore.Property("aa.b b.cc", "123"))
self.assertEqual(props.Get("aa.b b.cc").Get(), ["123"])
props = pyluxcore.Properties()
props.SetFromString("test1.prop1 = 1 2.0 aa \"quoted\"\ntest2.pr op2 = 1 2.0 'quoted' bb\ntest2.prop3 = 1")
self.assertEqual(props.Get("test1.prop1").Get(), ["1", "2.0", "aa", "quoted"])
self.assertEqual(props.Get("test2.pr op2").Get(), ["1", "2.0", "quoted", "bb"])
self.assertEqual(props.Get("test2.prop3").Get(), ["1"])
def luxBallMove(self, t):
# Begin scene editing
self.session.BeginSceneEdit()
self.luxBallPos[0] += t
# Set the new LuxBall position (note: using the transpose matrix)
mat = [1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
self.luxBallPos[0], self.luxBallPos[1], self.luxBallPos[2], 1.0]
self.scene.Parse(self.scene.GetProperties().GetAllProperties("scene.objects.luxtext").
Set(pyluxcore.Property("scene.objects.luxtext.transformation", mat)))
self.scene.Parse(self.scene.GetProperties().GetAllProperties("scene.objects.luxinner").
Set(pyluxcore.Property("scene.objects.luxinner.transformation", mat)))
self.scene.Parse(self.scene.GetProperties().GetAllProperties("scene.objects.luxshell").
Set(pyluxcore.Property("scene.objects.luxshell.transformation", mat)))
# End scene editing
self.session.EndSceneEdit()
print("LuxBall new position: %f, %f, %f" % (self.luxBallPos[0], self.luxBallPos[1], self.luxBallPos[2]))
def filmSetOutputChannel(self, type):
# Stop the rendering
self.session.Stop()
self.session = None
# Delete old channel outputs
self.config.Delete("film.outputs")
# Set the new channel outputs
self.config.Parse(pyluxcore.Properties().
Set(pyluxcore.Property("film.outputs.1.type", ["RGB_IMAGEPIPELINE"])).
Set(pyluxcore.Property("film.outputs.1.filename", ["luxball_RGB_IMAGEPIPELINE.png"])).
Set(pyluxcore.Property("film.outputs.2.type", [str(type)])).
Set(pyluxcore.Property("film.outputs.2.filename", ["luxball_SELECTED_OUTPUT.exr"])))
self.selectedFilmChannel = type
# Re-start the rendering
self.session = pyluxcore.RenderSession(self.config)
self.session.Start()
print("Film channel selected: %s" % (str(type)))
def PropertiesOps():
prop = pyluxcore.Property("test1.prop1", "aa")
prop.Clear().Add([0, 2]).Add([3])
prop.Set(0, 1)
prop.Set([3, 2, 1])
pyvariable = 999
prop = pyluxcore.Property("test1.prop1", [True, 1, 2.0, "aa", pyvariable])
props = pyluxcore.Properties()
props.SetFromString(
"test1.prop1 = 1 2.0 aa \"quoted\"\ntest2.prop2 = 1 2.0 'quoted' bb\ntest2.prop3 = 1"
)
props0 = pyluxcore.Properties()
props1 = pyluxcore.Properties() \
.Set(pyluxcore.Property("test1.prop1", [True, 1, 2.0, "aa"])) \
.Set(pyluxcore.Property("test2.prop1", ["bb"]))
props0.Set(props1, "prefix.")
def cameraToggleDOF(self):
# Begin scene editing
self.session.BeginSceneEdit()
# Edit the camera
self.dofEnabled = not self.dofEnabled
self.scene.Parse(self.scene.ToProperties().GetAllProperties("scene.camera").
Set(pyluxcore.Property("scene.camera.lensradius", [0.015 if self.dofEnabled else 0.0])))
# End scene editing
self.session.EndSceneEdit()
print("Camera DOF toggled: %s" % (str(self.dofEnabled)))
def luxBallMatGlass(self):
# Begin scene editing
self.session.BeginSceneEdit()
# Edit the material
self.scene.Parse(pyluxcore.Properties().
Set(pyluxcore.Property("scene.materials.shell.type", ["glass"])).
Set(pyluxcore.Property("scene.materials.shell.kr", [0.69, 0.78, 1.0])).
Set(pyluxcore.Property("scene.materials.shell.kt", [0.69, 0.78, 1.0])).
Set(pyluxcore.Property("scene.materials.shell.ioroutside", [1.0])).
Set(pyluxcore.Property("scene.materials.shell.iorinside", [1.45]))
)
# To remove unreferenced constant textures defined implicitely
self.scene.RemoveUnusedTextures()
# To remove all unreferenced image maps (note: the order of call does matter)
self.scene.RemoveUnusedImageMaps()
# End scene editing
self.session.EndSceneEdit()
print("LuxBall material set to: Glass")
def RunRemoveUnusedTest(self, name, removeImageMaps, removeUnusedTexs,
removeUnusedMats, removeUnusedMeshes, editProps):
# Load the configuration from file
props = pyluxcore.Properties(
"resources/scenes/simple/texture-imagemap.cfg")
# Change the render engine to PATHCPU
props.Set(pyluxcore.Property("renderengine.type", ["PATHCPU"]))
props.Set(pyluxcore.Property("sampler.type", ["RANDOM"]))
props.Set(GetDefaultEngineProperties("PATHCPU"))
# Delete halt condition
props.Delete("batch.haltthreshold")
config = pyluxcore.RenderConfig(props)
session = pyluxcore.RenderSession(config)
session.Start()
time.sleep(2.0)
session.BeginSceneEdit()
scene = config.GetScene()
scene.Parse(editProps)
if (removeImageMaps):
scene.RemoveUnusedImageMaps()
if (removeUnusedTexs):
scene.RemoveUnusedTextures()
if (removeUnusedMats):
scene.RemoveUnusedMaterials()
if (removeUnusedMeshes):
scene.RemoveUnusedMeshes()
session.EndSceneEdit()
time.sleep(5.0)
session.Stop()
image = GetImagePipelineImage(session.GetFilm())
CheckResult(self, image, name, False)
def TestGeneratedScene(cls, params):
engineType = params[0]
samplerType = params[1]
# Create the rendering configuration
cfgProps = pyluxcore.Properties(LuxCoreTest.customConfigProps)
cfgProps.SetFromString("""
film.width = 512
film.height = 384
""")
# Set the rendering engine
cfgProps.Set(GetEngineProperties(engineType))
# Set the sampler (if required)
if samplerType:
cfgProps.Set(pyluxcore.Property("sampler.type", samplerType))
# Create the scene properties
scnProps = pyluxcore.Properties()
# Set the camera position
scnProps.SetFromString("""
scene.camera.lookat.orig = 0.0 5.0 2.0
scene.camera.lookat.target = 0.0 0.0 0.0
""")
# Define a white matte material
scnProps.SetFromString("""
scene.materials.whitematte.type = matte
scene.materials.whitematte.kd = 0.75 0.75 0.75
""")
# Add a plane
scnProps.Set(BuildPlane("plane1", "whitematte"))
# Add a distant light source
scnProps.SetFromString("""
scene.lights.distl.type = sharpdistant
scene.lights.distl.color = 1.0 1.0 1.0
scene.lights.distl.gain = 2.0 2.0 2.0
scene.lights.distl.direction = 1.0 1.0 -1.0
""")
# Create the scene
scene = pyluxcore.Scene()
scene.Parse(scnProps)
# Create the render config
config = pyluxcore.RenderConfig(cfgProps, scene)
# Run the rendering
StandardImageTest(cls, "GeneratedScene_" + engineType + ("" if not samplerType else ("_" + samplerType)), config)
def SaveFilm():
print("Film save example (requires scenes directory)...")
# Load the configuration from file
props = pyluxcore.Properties("scenes/simple/simple.cfg")
#props = pyluxcore.Properties("scenes/luxball/luxball-hdr.cfg")
# To test large films
#props.Set(pyluxcore.Property("film.width", 2048))
#props.Set(pyluxcore.Property("film.height", 2048))
# Change the render engine to PATHCPU
props.Set(pyluxcore.Property("renderengine.type", ["PATHCPU"]))
config = pyluxcore.RenderConfig(props)
session = pyluxcore.RenderSession(config)
session.Start()
startTime = time.time()
while True:
time.sleep(.5)
elapsedTime = time.time() - startTime
# Print some information about the rendering progress
# Update statistics
session.UpdateStats()
stats = session.GetStats()
print(
"[Elapsed time: %3d/5sec][Samples %4d][Avg. samples/sec % 3.2fM on %.1fK tris]"
% (stats.Get("stats.renderengine.time").GetFloat(),
stats.Get("stats.renderengine.pass").GetInt(),
(stats.Get("stats.renderengine.total.samplesec").GetFloat() /
1000000.0),
(stats.Get("stats.dataset.trianglecount").GetFloat() / 1000.0)))
if elapsedTime > 5.0:
# Time to stop the rendering
break
session.Stop()
# Save the rendered image
t1 = Clock()
session.GetFilm().SaveFilm("simple.flm")
t2 = Clock()
print("Film save time: %s secs" % (t2 - t1))
print("Done.")
def luxBallMatGlossyImageMap(self):
# Begin scene editing
self.session.BeginSceneEdit()
# Define check map
imageMap = array('f', [0.0] * (128 * 128 * 3))
for y in range(128):
for x in range(128):
offset = (x + y * 128) * 3
if (x % 64 < 32) ^ (y % 64 < 32):
imageMap[offset] = 1.0
imageMap[offset] = 1.0
imageMap[offset] = 1.0
else:
imageMap[offset] = 1.0
imageMap[offset] = 0.0
imageMap[offset] = 0.0
########################################################################
# NOTICE THE DIFFERENT BEHAVIOR REQUIRED BY PYTHON 2.7
########################################################################
self.scene.DefineImageMap("check_map", buffer(imageMap) if sys.version_info < (3,0,0) else imageMap, 2.2, 3, 128, 128)
# Edit the material
self.scene.Parse(pyluxcore.Properties().
Set(pyluxcore.Property("scene.textures.tex.type", ["imagemap"])).
Set(pyluxcore.Property("scene.textures.tex.file", ["check_map"])).
Set(pyluxcore.Property("scene.textures.tex.gain", [0.6])).
Set(pyluxcore.Property("scene.textures.tex.mapping.uvscale", [16, -16])).
Set(pyluxcore.Property("scene.materials.shell.type", ["glossy2"])).
Set(pyluxcore.Property("scene.materials.shell.kd", ["tex"])).
Set(pyluxcore.Property("scene.materials.shell.ks", [0.25, 0.0, 0.0])).
Set(pyluxcore.Property("scene.materials.shell.uroughness", [0.05])).
Set(pyluxcore.Property("scene.materials.shell.vroughness", [0.05])))
# To remove unreferenced constant textures defined implicitely
self.scene.RemoveUnusedTextures()
# To remove all unreferenced image maps (note: the order of call does matter)
self.scene.RemoveUnusedImageMaps()
# End scene editing
self.session.EndSceneEdit()
print("LuxBall material set to: Glossy with image map")
def test_Film_SaveLoad(self):
# Load the configuration from file
props = pyluxcore.Properties("resources/scenes/simple/simple.cfg")
# Change the render engine to PATHCPU
props.Set(pyluxcore.Property("renderengine.type", ["PATHCPU"]))
props.Set(pyluxcore.Property("sampler.type", ["RANDOM"]))
props.Set(GetDefaultEngineProperties("PATHCPU"))
config = pyluxcore.RenderConfig(props)
session = DoRenderSession(config)
# Get the imagepipeline result
filmA = session.GetFilm()
imageA = GetImagePipelineImage(filmA)
# Save the film
filmA.SaveFilm("simple.flm")
# Load the film
filmB = pyluxcore.Film("simple.flm")
self.assertEqual(filmB.GetWidth(), filmA.GetWidth())
self.assertEqual(filmB.GetHeight(), filmA.GetHeight())
# Get the imagepipeline result
imageB = GetImagePipelineImage(filmB)
# To debug
#imageA.save("imageA.png")
#imageB.save("imageB.png")
# Check if there is a difference
(sameImage, diffCount, diffImage) = CompareImage(imageA, imageB)
self.assertTrue(sameImage)
os.unlink("simple.flm")
def renderEnginePathCPU(self):
# Stop the rendering
self.session.Stop()
self.session = None
# Change the render engine to PATHCPU
props = self.config.GetProperties()
props.Set(pyluxcore.Property("renderengine.type", ["PATHCPU"]))
# Create the new RenderConfig
self.config = pyluxcore.RenderConfig(props, self.scene)
# Re-start the rendering
self.session = pyluxcore.RenderSession(self.config)
self.session.Start()
print("PathCPU selected")
def __init__(self, cfgFileName):
super(RenderView, self).__init__()
self.dofEnabled = True
self.luxBallShapeIsCube = False
self.selectedFilmChannel = pyluxcore.FilmOutputType.RGB_TONEMAPPED
self.createActions()
self.createMenus()
# Load the configuration from file
props = pyluxcore.Properties(cfgFileName)
# Change the render engine to PATHCPU
props.Set(pyluxcore.Property("renderengine.type", ["PATHCPU"]))
# Read the configuration and start the rendering
self.scene = pyluxcore.Scene(props.Get("scene.file").GetString(),
props.Get("images.scale", [1.0]).GetFloat())
sceneProps = self.scene.GetProperties()
# Save Camera position
self.cameraPos = sceneProps.Get("scene.camera.lookat.orig").GetFloats()
self.luxBallPos = [0.0, 0.0, 0.0]
# Create the rendering configuration
self.config = pyluxcore.RenderConfig(props, self.scene)
self.filmWidth, self.filmHeight = self.config.GetFilmSize()[:2]
# Allocate the image for the rendering
self.allocateImageBuffers()
self.setGeometry(0, 0, self.filmWidth, self.filmHeight)
self.setWindowTitle('LuxCore RenderView')
self.center()
# Create the rendering session
self.session = pyluxcore.RenderSession(self.config)
# Start the rendering
self.session.Start()
self.timer = QBasicTimer()
self.timer.start(500, self)
def test_Property_GetTypes(self):
prop = pyluxcore.Property("test1.prop1", "aa")
prop.Set(0, True)
self.assertEqual(prop.GetBool(), True)
prop.Set(0, 123)
self.assertEqual(prop.GetInt(), 123)
prop.Set(0, 123.45)
self.assertEqual(prop.GetFloat(), 123.45)
prop.Set(0, "abc")
self.assertEqual(prop.GetString(), "abc")
prop.Clear().Add([True, False])
self.assertEqual(prop.GetBools(), [True, False])
prop.Clear().Add([123, 456])
self.assertEqual(prop.GetInts(), [123, 456])
prop.Clear().Add([123.45, 678.9])
self.assertEqual(prop.GetFloats(), [123.45, 678.9])
prop.Clear().Add(["abc", "def"])
self.assertEqual(prop.GetStrings(), ["abc", "def"])
def TestSceneEditRendering(cls, params):
engineType = params[0]
samplerType = params[1]
# Create the rendering configuration
props = pyluxcore.Properties(LuxCoreTest.customConfigProps)
props.SetFromFile("resources/scenes/simple/simple.cfg")
# Set the rendering engine
props.Set(GetEngineProperties(engineType))
# Set the sampler (if required)
if samplerType:
props.Set(pyluxcore.Property("sampler.type", samplerType))
config = pyluxcore.RenderConfig(props)
# Run the rendering
StandardAnimTest(
cls, "SceneEditRendering_" + engineType + ("" if not samplerType else
("_" + samplerType)),
config, 5)
def ExtractConfiguration():
print("Extracting Film configuration example (requires scenes directory)...")
# Load the configuration from file
props = pyluxcore.Properties("scenes/luxball/luxball-hdr-comp.cfg")
# Change the render engine to PATHCPU
props.Set(pyluxcore.Property("renderengine.type", ["PATHCPU"]))
config = pyluxcore.RenderConfig(props)
session = pyluxcore.RenderSession(config)
# Extract the RenderConfig properties (redundant here)
props = session.GetRenderConfig().GetProperties()
ids = set()
for i in props.GetAllUniqueSubNames("film.outputs"):
if props.Get(i + ".type").GetString() == "MATERIAL_ID_MASK":
ids.add(props.Get(i + ".id").GetInt())
for i in ids:
print("MATERIAL_ID_MASK ID => %d" % i)
print("Done.")
def save_file(self):
path = QFileDialog().getSaveFileName(self, u"Save as", (""), "*.cfg")
fileName = path[0]
if not fileName == "":
if not fileName.endswith('cfg'):
fileName = fileName + '.cfg'
print(fileName)
fi = QFileInfo(fileName)
getName = fi.fileName()
getDir = os.path.dirname(fileName)
print(getName)
print(getDir)
self.configProps.Set(
pyluxcore.Property("renderengine.type", ["FILESAVER"]))
print("scene saved")
self.configProps.SetFromString("""
filesaver.format = "TXT"
filesaver.renderengine.type = "PATHCPU"
filesaver.directory = {dirt}
filesaver.filename ={cfgName}
""".format(dirt="\"" + getDir + "/\"", cfgName=getName))
self.render_image()
def SaveResumeRenderingS():
print("Save and Resume example (requires scenes directory)...")
# Load the configuration from file
props = pyluxcore.Properties("scenes/luxball/luxball-hdr.cfg")
# Change the render engine to PATHCPU
props.Set(pyluxcore.Property("renderengine.type", ["PATHCPU"]))
config = pyluxcore.RenderConfig(props)
session = pyluxcore.RenderSession(config)
session.Start()
startTime = time.time()
for i in range(0, 3):
time.sleep(1)
elapsedTime = time.time() - startTime
# Print some information about the rendering progress
# Update statistics
session.UpdateStats()
stats = session.GetStats();
print("[Elapsed time: %3d/3sec][Samples %4d][Avg. samples/sec % 3.2fM on %.1fK tris]" % (
stats.Get("stats.renderengine.time").GetFloat(),
stats.Get("stats.renderengine.pass").GetInt(),
(stats.Get("stats.renderengine.total.samplesec").GetFloat() / 1000000.0),
(stats.Get("stats.dataset.trianglecount").GetFloat() / 1000.0)))
session.Pause()
session.GetFilm().SaveOutput("test-save.png", pyluxcore.FilmOutputType.RGB_IMAGEPIPELINE, pyluxcore.Properties())
# Save the session resume file
session.SaveResumeFile("test.rsm")
# Save the rendered image
session.GetFilm().Save()
# Stop the rendering
session.Stop()
# Resume rendering
print("Resume rendering")
(config, startState, startFilm) = pyluxcore.RenderConfig.LoadResumeFile("test.rsm")
session = pyluxcore.RenderSession(config, startState, startFilm)
session.Start()
startTime = time.time()
for i in range(0, 3):
time.sleep(1)
elapsedTime = time.time() - startTime
# Print some information about the rendering progress
# Update statistics
session.UpdateStats()
stats = session.GetStats();
print("[Elapsed time: %3d/3sec][Samples %4d][Avg. samples/sec % 3.2fM on %.1fK tris]" % (
stats.Get("stats.renderengine.time").GetFloat(),
stats.Get("stats.renderengine.pass").GetInt(),
(stats.Get("stats.renderengine.total.samplesec").GetFloat() / 1000000.0),
(stats.Get("stats.dataset.trianglecount").GetFloat() / 1000.0)))
session.GetFilm().SaveOutput("test-resume.png", pyluxcore.FilmOutputType.RGB_IMAGEPIPELINE, pyluxcore.Properties())
session.Stop()
print("Done.")
def ImagePipelineEdit():
print("Image pipeline editing examples (requires scenes directory)...")
# Load the configuration from file
props = pyluxcore.Properties("scenes/luxball/luxball-hdr.cfg")
# Change the render engine to PATHCPU
props.Set(pyluxcore.Property("renderengine.type", ["PATHCPU"]))
config = pyluxcore.RenderConfig(props)
session = pyluxcore.RenderSession(config)
session.Start()
startTime = time.time()
imageSaved = False
while True:
time.sleep(1)
elapsedTime = time.time() - startTime
# Print some information about the rendering progress
# Update statistics
session.UpdateStats()
stats = session.GetStats();
print("[Elapsed time: %3d/10sec][Samples %4d][Avg. samples/sec % 3.2fM on %.1fK tris]" % (
stats.Get("stats.renderengine.time").GetFloat(),
stats.Get("stats.renderengine.pass").GetInt(),
(stats.Get("stats.renderengine.total.samplesec").GetFloat() / 1000000.0),
(stats.Get("stats.dataset.trianglecount").GetFloat() / 1000.0)))
if elapsedTime > 5.0 and not imageSaved:
session.GetFilm().Save()
os.rename("normal.png", "normal-edit1.png")
# Define the new image pipeline
props = pyluxcore.Properties()
props.SetFromString("""
film.imagepipeline.0.type = TONEMAP_REINHARD02
film.imagepipeline.1.type = CAMERA_RESPONSE_FUNC
film.imagepipeline.1.name = Ektachrome_320TCD
film.imagepipeline.2.type = GAMMA_CORRECTION
film.imagepipeline.2.value = 2.2
""")
session.Parse(props)
# Change radiance group scale
# props = pyluxcore.Properties()
# props.SetFromString("""
# film.radiancescales.0.rgbscale = 1.0 0.0 0.0
# """)
# session.Parse(props)
imageSaved = True
if elapsedTime > 10.0:
# Time to stop the rendering
break
session.Stop()
# Save the rendered image
session.GetFilm().Save()
os.rename("normal.png", "normal-edit2.png")
print("Done.")
def PropertiesTests():
print("Properties examples...")
prop = pyluxcore.Property("test1.prop1", 0)
prop.Set(0, 3705339624)
prop = pyluxcore.Property("test1.prop1", 3705339624)
print("test1.prop1 => %s\n" % prop.GetInt(0))
prop = pyluxcore.Property("test1.prop1", "aa")
print("test1.prop1 => %s\n" % prop.GetString(0))
prop.Clear().Add([0, 2]).Add([3])
prop.Set(0, 1)
print("[%s]\n" % prop.ToString())
print("[%s]\n" % pyluxcore.Property("test1.prop1").Add([1, 2, 3]).Add([1.0, 2.0, 3.0]))
prop.Set([3, 2, 1])
print("[%s]\n" % prop.ToString())
pyvariable = 999
prop = pyluxcore.Property("test1.prop1", [True, 1, 2.0, "aa", pyvariable])
print("[%s]" % prop)
print("Size: %d" % prop.GetSize())
print("List: %s" % str(prop.Get()))
print("[0]: %s" % prop.GetString())
print("[1]: %d\n" % prop.GetInt(1))
props = pyluxcore.Properties()
props.SetFromString("test1.prop1 = 1 2.0 aa \"quoted\"\ntest2.prop2 = 1 2.0 'quoted' bb\ntest2.prop3 = 1")
print("[\n%s]\n" % props)
print("%s" % props.GetAllNames())
print("%s" % props.GetAllNames("test1"))
print("%s\n" % props.GetAllUniqueSubNames("test2"))
props0 = pyluxcore.Properties()
props1 = pyluxcore.Properties() \
.Set(pyluxcore.Property("test1.prop1", [True, 1, 2.0, "aa"])) \
.Set(pyluxcore.Property("test2.prop1", ["bb"]));
props0.Set(props1, "prefix.")
print("[\n%s]\n" % props0)
print("Get: %s" % props0.Get("prefix.test1.prop1"))
print("Get default: %s\n" % props0.Get("doesnt.exist", ["default_value0", "default_value1"]))
blob = bytearray(100)
for i in range(0, len(blob)):
blob[i] = i
prop = pyluxcore.Property("test.blob", [blob])
prop.Add([[1, 2, 3]])
blob2 = prop.GetBlob()
print("Blob [0]:", end="")
for i in range(0, len(blob2)):
print(" %d" % blob2[i], end="")
print("")
blob2 = prop.GetBlob(1)
print("Blob [1]:", end="")
for i in range(0, len(blob2)):
print(" %d" % blob2[i], end="")
print("\n")
a = array('f', [1.0, 2.0, 3.0])
prop = pyluxcore.Property("test.array", [])
prop.AddAllFloat(a)
print("Array: ", end="")
for i in range(3):
print(" %f" % prop.GetFloat(i), end="")
print("")
a =[1.0, 2.0, 3.0]
prop = pyluxcore.Property("test.array", [])
prop.AddAllFloat(a)
print("List: ", end="")
for i in range(3):
print(" %f" % prop.GetFloat(i), end="")
print("")
print("")
size = 2000000
a = array('f', [i for i in range(size)])
prop = pyluxcore.Property("test.array", [])
start = Clock()
for i in range(size):
prop.Add([a[i]])
end = Clock()
print("Add test: %.2gs" % (end-start))
prop = pyluxcore.Property("test.array", [])
start = Clock()
prop.AddAllFloat(a)
end = Clock()
print("AddAll test: %.2gs" % (end-start))
prop = pyluxcore.Property("test.array", [])
start = Clock()
prop.AddAllFloat(a, 3, 1)
end = Clock()
print("AddAllStride test: %.2gs" % (end-start))
def StrandsRender():
print("Strands example...")
# Create the rendering configuration
cfgProps = pyluxcore.Properties()
cfgProps.SetFromString("""
film.width = 640
film.height = 480
""")
# Set the rendering engine
cfgProps.Set(pyluxcore.Property("renderengine.type", ["PATHCPU"]))
# Create the scene properties
scnProps = pyluxcore.Properties()
# Set the camera position
scnProps.SetFromString("""
scene.camera.lookat.orig = 0.0 5.0 2.0
scene.camera.lookat.target = 0.0 0.0 0.0
""")
# Define a white matte material
scnProps.SetFromString("""
scene.materials.whitematte.type = matte
scene.materials.whitematte.kd = 0.75 0.75 0.75
""")
# Add a plane
scnProps.Set(BuildPlane("plane1", "whitematte"))
# Add a distant light source
scnProps.SetFromString("""
scene.lights.distl.type = sharpdistant
scene.lights.distl.color = 1.0 1.0 1.0
scene.lights.distl.gain = 2.0 2.0 2.0
scene.lights.distl.direction = 1.0 1.0 -1.0
""")
# Create the scene
#resizePolicyProps = pyluxcore.Properties()
#resizePolicyProps.SetFromString("""
# scene.images.resizepolicy.type = "MIPMAPMEM"
# scene.images.resizepolicy.scale = 1.0
# scene.images.resizepolicy.minsize = 64
# """)
#scene = pyluxcore.Scene(scnProps, resizePolicyProps)
scene = pyluxcore.Scene()
scene.Parse(scnProps)
# Add strands
points = []
segments = []
strandsCount = 30
for i in range(strandsCount):
x = random.random() * 2.0 - 1.0
y = random.random() * 2.0 - 1.0
points.append((x , y, 0.0))
points.append((x , y, 1.0))
segments.append(1)
scene.DefineStrands("strands_shape", strandsCount, 2 * strandsCount, points, segments,
0.025, 0.0, (1.0, 1.0, 1.0), None, "ribbon",
0, 0, 0, False, False, True)
strandsProps = pyluxcore.Properties()
strandsProps.SetFromString("""
scene.objects.strands_obj.material = whitematte
scene.objects.strands_obj.shape = strands_shape
""")
scene.Parse(strandsProps)
# Save the strand mesh (just for testing)
scene.SaveMesh("strands_shape", "strands_shape.ply")
# Create the render config
config = pyluxcore.RenderConfig(cfgProps, scene)
session = pyluxcore.RenderSession(config)
session.Start()
startTime = time.time()
while True:
time.sleep(1)
elapsedTime = time.time() - startTime
# Print some information about the rendering progress
# Update statistics
session.UpdateStats()
stats = session.GetStats();
print("[Elapsed time: %3d/5sec][Samples %4d][Avg. samples/sec % 3.2fM on %.1fK tris]" % (
stats.Get("stats.renderengine.time").GetFloat(),
stats.Get("stats.renderengine.pass").GetInt(),
(stats.Get("stats.renderengine.total.samplesec").GetFloat() / 1000000.0),
(stats.Get("stats.dataset.trianglecount").GetFloat() / 1000.0)))
if elapsedTime > 5.0:
# Time to stop the rendering
break
session.Stop()
# Save the rendered image
session.GetFilm().Save()
print("Done.")
def GetOutputTest():
print("Film getOutput() example (requires scenes directory)...")
# Load the configuration from file
props = pyluxcore.Properties("scenes/luxball/luxball-hdr.cfg")
# Change the render engine to PATHCPU
props.Set(pyluxcore.Property("renderengine.type", ["PATHCPU"]))
config = pyluxcore.RenderConfig(props)
session = pyluxcore.RenderSession(config)
# NOTICE THE DIFFERENT BEHAVIOR REQUIRED BY PYTHON 3.3, 2.7 and 2.6
filmWidth, filmHeight = config.GetFilmSize()[:2]
if sys.version_info < (2,7,0):
imageBufferFloat = bytearray(filmWidth * filmHeight * 3 * 4)
imageBufferUChar = bytearray(filmWidth * filmHeight * 4)
elif sys.version_info < (3,0,0):
imageBufferFloat = buffer(array('f', [0.0] * (filmWidth * filmHeight * 3)))
imageBufferUChar = buffer(array('B', [0] * (filmWidth * filmHeight * 4)))
else:
imageBufferFloat = array('f', [0.0] * (filmWidth * filmHeight * 3))
imageBufferUChar = array('B', [0] * (filmWidth * filmHeight * 4))
session.Start()
startTime = time.time()
imageIndex = 0
while True:
time.sleep(1)
elapsedTime = time.time() - startTime
# Print some information about the rendering progress
# Update statistics
session.UpdateStats()
stats = session.GetStats();
print("[Elapsed time: %3d/5sec][Samples %4d][Avg. samples/sec % 3.2fM on %.1fK tris]" % (
stats.Get("stats.renderengine.time").GetFloat(),
stats.Get("stats.renderengine.pass").GetInt(),
(stats.Get("stats.renderengine.total.samplesec").GetFloat() / 1000000.0),
(stats.Get("stats.dataset.trianglecount").GetFloat() / 1000.0)))
# This is mostly for testing the PyLuxCore functionality, save an image every second
# Update the image
session.GetFilm().GetOutputFloat(pyluxcore.FilmOutputType.RGB_IMAGEPIPELINE, imageBufferFloat)
pyluxcore.ConvertFilmChannelOutput_3xFloat_To_4xUChar(filmWidth, filmHeight,
imageBufferFloat, imageBufferUChar, False)
# Save the imageBufferUChar buffer to a PPM file
imageFileName = "image" + str(imageIndex) + ".ppm"
print("Saving image file: " + imageFileName)
f = open(imageFileName, "w")
f.write("P3\n")
f.write(str(filmWidth) + " " + str(filmHeight) + "\n")
f.write("255\n")
for i in range(0, len(imageBufferUChar), 4):
f.write(str(imageBufferUChar[i + 2]) + " " + str(imageBufferUChar[i + 1]) + " " + str(imageBufferUChar[i]) + "\n")
f.close()
imageIndex += 1
if elapsedTime > 5.0:
# Time to stop the rendering
break
session.Stop()
print("Done.")
def LuxCoreConsole(argv):
parser = argparse.ArgumentParser(description="PyLuxCoreConsole")
parser.add_argument("fileToRender",
help=".cfg, .lxs, .bcf or .rsm file to render")
parser.add_argument("-f",
"--scene",
metavar="FILE_NAME",
nargs=1,
help="scene file name")
parser.add_argument("-w",
"--film-width",
metavar="WIDTH",
nargs=1,
type=int,
help="film width")
parser.add_argument("-e",
"--film-height",
metavar="HEIGHT",
nargs=1,
type=int,
help="film height")
parser.add_argument("-D",
"--define",
metavar=("PROP_NAME", "VALUE"),
nargs=2,
action="append",
help="assign a value to a property")
parser.add_argument("-d",
"--current-dir",
metavar="DIR_NAME",
nargs=1,
help="current directory path")
parser.add_argument(
"-c",
"--remove-unused",
action="store_true",
help="remove all unused meshes, materials, textures and image maps")
parser.add_argument("-t",
"--camera-shutter",
metavar="CAMERA_SHUTTER",
nargs=2,
type=float,
help="camera shutter open/close")
# Parse command line arguments
args = parser.parse_args(argv)
cmdLineProp = pyluxcore.Properties()
if (args.scene):
cmdLineProp.Set(pyluxcore.Property("scene.file", args.scene))
if (args.film_width):
cmdLineProp.Set(pyluxcore.Property("film.width", args.film_width))
if (args.film_height):
cmdLineProp.Set(pyluxcore.Property("film.height", args.film_height))
if (args.define):
for (name, value) in args.define:
cmdLineProp.Set(pyluxcore.Property(name, value))
if (args.current_dir):
os.chdir(args.current_dir[0])
removeUnused = args.remove_unused
if (not args.fileToRender):
raise TypeError("File to render must be specified")
# Load the file to render
config = None
startState = None
startFilm = None
configFileNameExt = os.path.splitext(args.fileToRender)[1]
if (configFileNameExt == ".lxs"):
# It is a LuxRender SDL file
logger.info("Parsing LuxRender SDL file...")
# Parse the LXS file
configProps = pyluxcore.Properties()
sceneProps = pyluxcore.Properties()
pyluxcore.ParseLXS(args.fileToRender, configProps, sceneProps)
configProps.Set(cmdLineProp)
scene = pyluxcore.Scene(
configProps.Get("images.scale", [1.0]).GetFloat())
scene.Parse(sceneProps)
config = pyluxcore.RenderConfig(configProps, scene)
elif (configFileNameExt == ".cfg"):
# It is a LuxCore SDL file
configProps = pyluxcore.Properties(args.fileToRender)
configProps.Set(cmdLineProp)
config = pyluxcore.RenderConfig(configProps)
elif (configFileNameExt == ".bcf"):
# It is a LuxCore RenderConfig binary archive
config = pyluxcore.RenderConfig(args.fileToRender)
config.Parse(cmdLineProp)
elif (configFileNameExt == ".rsm"):
# It is a rendering resume file
(config, startState,
startFilm) = pyluxcore.RenderConfig.LoadResumeFile(args.fileToRender)
config.Parse(cmdLineProp)
else:
raise TypeError("Unknown file extension: " + args.fileToRender)
if (removeUnused):
config.GetScene().RemoveUnusedMeshes()
config.GetScene().RemoveUnusedImageMaps()
config.GetScene().RemoveUnusedMaterials()
config.GetScene().RemoveUnusedTextures()
# Overwrite camera shutter open/close
if (args.camera_shutter):
cameraProps = config.GetScene().ToProperties().GetAllProperties(
"scene.camera")
cameraProps.Set(
pyluxcore.Property("scene.camera.shutteropen",
[args.camera_shutter[0]]))
cameraProps.Set(
pyluxcore.Property("scene.camera.shutterclose",
[args.camera_shutter[1]]))
config.GetScene().Parse(cameraProps)
# Force the film update at 2.5secs (mostly used by PathOCL)
# Skip in case of a FILESAVER
isFileSaver = (
config.GetProperty("renderengine.type").GetString() == "FILESAVER")
if (not isFileSaver):
config.Parse(pyluxcore.Properties().Set(
pyluxcore.Property("screen.refresh.interval", 2500)))
session = BatchRendering(config, startState, startFilm)
if (not isFileSaver):
# Save the rendered image
session.GetFilm().Save()
logger.info("Done.")
def build_scene(fluid_mesh):
scene = pyluxcore.Scene()
props = pyluxcore.Properties()
props.SetFromString("""
scene.camera.type = "perspective"
scene.camera.lookat.orig = 0.5 -2.0 1.0
scene.camera.lookat.target = 0.5 0.5 0.4
scene.camera.fieldofview = 35
################################################################################
scene.materials.fluid.type = glass
#scene.materials.fluid.kd = 1. 0.824176 0.549451
scene.materials.fluid.kr = 1.0 1.0 1.0
scene.materials.fluid.kt = 1.0 1.0 1.0
scene.materials.fluid.interiorior = 1.333
scene.materials.fluid.exteriorior = 1.0
scene.materials.fluid.photongi.enable = 1
################################################################################
scene.textures.table.type = blender_noise
scene.materials.slab.type = matte
#scene.materials.slab.kd = table
scene.materials.slab.kd = 0.8 0.64 0.45
################################################################################
#scene.materials.container.type = roughglass
#scene.materials.container.kr = 0.9 0.9 0.9
#scene.materials.container.kt = 0.9 0.9 0.9
#scene.materials.container.interiorior = 1.5
#scene.materials.container.exteriorior = 1.0
#scene.materials.container.uroughness = 0.5
#scene.materials.container.vroughness = 0.5
scene.materials.container.type = matte
scene.materials.container.kd = 1.0 1.0 1.0
################################################################################
#scene.lights.l1.type = sky2
#scene.lights.l1.gain = 0.0003 0.0003 0.0003
#scene.lights.l1.dir = 0.0 0.0 1.0
#scene.lights.l1.relsize = 1.0
#scene.lights.l1.turbidity = 2.0
#scene.lights.l1.ground.enable = 0
scene.lights.l2.type = point
scene.lights.l2.position = 0.5 0.5 1.0
scene.lights.l2.gain = 0.7 0.7 0.7
scene.lights.l3.type = point
scene.lights.l3.position = 0.0 0.5 2.0
scene.lights.l3.gain = 0.99 0.99 0.99
################################################################################
scene.objects.slab.material = slab
scene.objects.slab.ply = slab.ply
#scene.objects.container.material = container
#scene.objects.container.ply = container_tri.ply
#scene.objects.stairs.material = container
#scene.objects.stairs.ply = stairs.ply
scene.objects.solid.material = container
scene.objects.solid.ply = solid.ply
################################################################################
""")
scene.Parse(props)
props = pyluxcore.Properties()
props.Set(pyluxcore.Property("scene.objects.fluid.material", "fluid"))
props.Set(pyluxcore.Property("scene.objects.fluid.ply", fluid_mesh))
scene.Parse(props)
return scene
def luxBallShapeToggle(self):
# Begin scene editing
self.session.BeginSceneEdit()
# I delete and re-create the LuxBall to reset objects position in
# case they have been moved
# Delete the LuxBall
self.scene.DeleteObject("luxtext")
self.scene.DeleteObject("luxinner")
self.scene.DeleteObject("luxshell")
self.scene.RemoveUnusedMeshes()
# Re-create the LuxBall inner and text
sceneProps = pyluxcore.Properties("scenes/luxball/luxball-hdr.scn")
self.scene.Parse(sceneProps.GetAllProperties("scene.objects.luxtext"))
self.scene.Parse(sceneProps.GetAllProperties("scene.objects.luxinner"))
# Re-create the LuxBall shape
if self.luxBallShapeIsCube:
self.scene.Parse(sceneProps.GetAllProperties("scene.objects.luxshell").
Set(pyluxcore.Property("scene.objects.luxshell.ply", ["scenes/luxball/luxball-shell.ply"])))
self.luxBallShapeIsCube = False
else:
self.scene.DefineMesh("LuxCubeMesh", [
# Bottom face
(-0.405577, -0.343839, 0.14),
(-0.405577, 0.506553, 0.14),
(0.443491, 0.506553, 0.14),
(0.443491, -0.343839, 0.14),
# Top face
(-0.405577, -0.343839, 0.819073),
(0.443491, -0.343839, 0.819073),
(0.443491, 0.506553, 0.819073),
(-0.405577, 0.506553, 0.819073),
# Side left
(-0.405577, -0.343839, 0.14),
(-0.405577, -0.343839, 0.819073),
(-0.405577, 0.506553, 0.819073),
(-0.405577, 0.506553, 0.14),
# Side right
(0.443491, -0.343839, 0.14),
(0.443491, 0.506553, 0.14),
(0.443491, 0.506553, 0.819073),
(0.443491, -0.343839, 0.819073),
# Side back
(-0.405577, -0.343839, 0.14),
(0.443491, -0.343839, 0.14),
(0.443491, -0.343839, 0.819073),
(-0.405577, -0.343839, 0.819073),
# Side front
(-0.405577, 0.506553, 0.14),
(-0.405577, 0.506553, 0.819073),
(0.443491, 0.506553, 0.819073),
(0.443491, 0.506553, 0.14)], [
# Bottom face
(0, 1, 2), (2, 3, 0),
# Top face
(4, 5, 6), (6, 7, 4),
# Side left
(8, 9, 10), (10, 11, 8),
# Side right
(12, 13, 14), (14, 15, 12),
# Side back
(16, 17, 18), (18, 19, 16),
# Side back
(20, 21, 22), (22, 23, 20)
], None, [
# Bottom face
(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0),
# Top face
(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0),
# Side left
(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0),
# Side right
(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0),
# Side back
(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0),
# Side front
(0.0, 0.0),(1.0, 0.0), (1.0, 1.0), (0.0, 1.0)
], None, None)
self.scene.Parse(sceneProps.GetAllProperties("scene.objects.luxshell").
Set(pyluxcore.Property("scene.objects.luxshell.ply", ["LuxCubeMesh"])))
self.luxBallShapeIsCube = True
# End scene editing
self.session.EndSceneEdit()
def PropertiesTests():
print("Properties examples...")
prop = pyluxcore.Property("test1.prop1", "aa")
print("test1.prop1 => %s\n" % prop.GetString(0))
prop.Clear().Add([0, 2]).Add([3])
prop.Set(0, 1)
print("[%s]\n" % prop.ToString())
print(
"[%s]\n" %
pyluxcore.Property("test1.prop1").Add([1, 2, 3]).Add([1.0, 2.0, 3.0]))
prop.Set([3, 2, 1])
print("[%s]\n" % prop.ToString())
pyvariable = 999
prop = pyluxcore.Property("test1.prop1", [True, 1, 2.0, "aa", pyvariable])
print("[%s]" % prop)
print("Size: %d" % prop.GetSize())
print("List: %s" % str(prop.Get()))
print("[0]: %s" % prop.GetString())
print("[1]: %d\n" % prop.GetInt(1))
props = pyluxcore.Properties()
props.SetFromString(
"test1.prop1 = 1 2.0 aa \"quoted\"\ntest2.prop2 = 1 2.0 'quoted' bb\ntest2.prop3 = 1"
)
print("[\n%s]\n" % props)
print("%s" % props.GetAllNames())
print("%s" % props.GetAllNames("test1"))
print("%s\n" % props.GetAllUniqueSubNames("test2"))
props0 = pyluxcore.Properties()
props1 = pyluxcore.Properties() \
.Set(pyluxcore.Property("test1.prop1", [True, 1, 2.0, "aa"])) \
.Set(pyluxcore.Property("test2.prop1", ["bb"]))
props0.Set(props1, "prefix.")
print("[\n%s]\n" % props0)
print("Get: %s" % props0.Get("prefix.test1.prop1"))
print("Get default: %s\n" %
props0.Get("doesnt.exist", ["default_value0", "default_value1"]))
blob = bytearray(100)
for i in range(0, len(blob)):
blob[i] = i
prop = pyluxcore.Property("test.blob", [blob])
prop.Add([[1, 2, 3]])
blob2 = prop.GetBlob()
print("Blob [0]:", end="")
for i in range(0, len(blob2)):
print(" %d" % blob2[i], end="")
print("")
blob2 = prop.GetBlob(1)
print("Blob [1]:", end="")
for i in range(0, len(blob2)):
print(" %d" % blob2[i], end="")
print("\n")
