def __translate_frame(self, depsgraph):
logger.debug("appleseed: Translating frame")
scene = depsgraph.scene_eval
asr_scene_props = scene.appleseed
noise_seed = (asr_scene_props.noise_seed + scene.frame_current) if asr_scene_props.per_frame_noise else asr_scene_props.noise_seed
width, height = self.__viewport_resolution
frame_params = {'resolution': asr.Vector2i(width, height),
'camera': "Camera",
'filter': asr_scene_props.pixel_filter,
'filter_size': asr_scene_props.pixel_filter_size,
'denoiser': asr_scene_props.denoise_mode,
'noise_seed': noise_seed,
'skip_denoised': asr_scene_props.skip_denoised,
'random_pixel_order': asr_scene_props.random_pixel_order,
'prefilter_spikes': asr_scene_props.prefilter_spikes,
'spike_threshold': asr_scene_props.spike_threshold,
'patch_distance_threshold': asr_scene_props.patch_distance_threshold,
'denoise_scales': asr_scene_props.denoise_scales,
'mark_invalid_pixels': asr_scene_props.mark_invalid_pixels}
if self.__export_mode != ProjectExportMode.PROJECT_EXPORT:
frame_params['tile_size'] = asr.Vector2i(asr_scene_props.tile_size, asr_scene_props.tile_size)
return frame_params
def __update_frame_size(self):
params = self.__frame.get_parameters()
width, height = self.__viewport_resolution
params['resolution'] = asr.Vector2i(width, height)
self.__frame.set_parameters(params)
def __set_frame(self, depsgraph):
width, height = util.get_render_resolution(depsgraph.scene_eval)
frame_params = {'resolution': asr.Vector2i(width, height),
'camera': "preview_camera"}
frame = asr.Frame("beauty", frame_params)
self.__project.set_frame(frame)
def assertCameraConvertsFrustum(self, camera):
appleseedCamera = IECoreAppleseed.CameraAlgo.convert(camera)
screenWindow = camera.frustum()
resolution = appleseed.Vector2i(1920, 1080)
proj = appleseed.ProjectPoints(appleseedCamera, resolution)
for x in [0, 1]:
for y in [0, 1]:
corner = appleseed.Vector3d(
screenWindow.max().x if x else screenWindow.min().x,
screenWindow.max().y if y else screenWindow.min().y, -1.0)
screenPos = proj.project_camera_space_point(corner)
self.assertAlmostEqual(x * resolution[0], screenPos[0])
self.assertAlmostEqual((1 - y) * resolution[1], screenPos[1])
def build_project():
# Create an empty project.
project = asr.Project('test project')
paths = project.get_search_paths()
paths.append('data')
project.set_search_paths(paths)
# Add default configurations to the project.
project.add_default_configurations()
# Set the number of samples. This is basically the quality parameter: the higher the number
# of samples, the smoother the image but the longer the rendering time.
# todo: fix.
conf = project.configurations()['final']
conf.insert_path('uniform_pixel_renderer.samples', 25)
# Create a scene.
scene = asr.Scene()
# Create an assembly.
assembly = asr.Assembly("assembly")
#------------------------------------------------------------------------
# Materials
#------------------------------------------------------------------------
# Create a color called "gray" and insert it into the assembly.
GrayReflectance = [0.5, 0.5, 0.5]
assembly.colors().insert(
asr.ColorEntity("gray", {'color_space': 'srgb'}, GrayReflectance))
# Create a BRDF called "diffuse_gray_brdf" and insert it into the assembly.
assembly.bsdfs().insert(
asr.BSDF("lambertian_brdf", "diffuse_gray_brdf",
{'reflectance': 'gray'}))
# Create a physical surface shader and insert it into the assembly.
assembly.surface_shaders().insert(
asr.SurfaceShader("physical_surface_shader",
"physical_surface_shader"))
# Create a material called "gray_material" and insert it into the assembly.
assembly.materials().insert(
asr.Material(
"gray_material", {
"surface_shader": "physical_surface_shader",
"bsdf": "diffuse_gray_brdf"
}))
#------------------------------------------------------------------------
# Geometry
#------------------------------------------------------------------------
# Load the scene geometry from disk.
objects = asr.MeshObjectReader.read(project.get_search_paths(), "cube",
{'filename': 'scene.obj'})
# Insert all the objects into the assembly.
for object in objects:
# Create an instance of this object and insert it into the assembly.
instance_name = object.get_name() + "_inst"
material_names = {
"default": "gray_material",
"default2": "gray_material"
}
instance = asr.ObjectInstance(instance_name, {}, object.get_name(),
asr.Transformd(asr.Matrix4d.identity()),
material_names)
assembly.object_instances().insert(instance)
# Insert this object into the scene.
assembly.objects().insert(object)
#------------------------------------------------------------------------
# Light
#------------------------------------------------------------------------
# Create a color called "light_intensity" and insert it into the assembly.
LightRadiance = [1.0, 1.0, 1.0]
assembly.colors().insert(
asr.ColorEntity("light_intensity", {
'color_space': 'srgb',
'multiplier': 30.0
}, LightRadiance))
# Create a point light called "light" and insert it into the assembly.
light = asr.Light("point_light", "light", {'intensity': 'light_intensity'})
light.set_transform(
asr.Transformd(asr.Matrix4d.translation(asr.Vector3d(0.6, 2.0, 1.0))))
assembly.lights().insert(light)
# Create an instance of the assembly and insert it into the scene.
assembly_inst = asr.AssemblyInstance("assembly_inst", {},
assembly.get_name())
assembly_inst.transform_sequence().set_transform(
0.0, asr.Transformd(asr.Matrix4d.identity()))
scene.assembly_instances().insert(assembly_inst)
# Insert the assembly into the scene.
scene.assemblies().insert(assembly)
#------------------------------------------------------------------------
# Environment
#------------------------------------------------------------------------
# Create a color called "sky_radiance" and insert it into the scene.
SkyRadiance = [0.75, 0.80, 1.0]
scene.colors().insert(
asr.ColorEntity("sky_radiance", {
'color_space': 'srgb',
'multiplier': 0.5
}, SkyRadiance))
# Create an environment EDF called "sky_edf" and insert it into the scene.
scene.environment_edfs().insert(
asr.EnvironmentEDF("constant_environment_edf", "sky_edf",
{'radiance': 'sky_radiance'}))
# Create an environment shader called "sky_shader" and insert it into the scene.
scene.environment_shaders().insert(
asr.EnvironmentShader("edf_environment_shader", "sky_shader",
{'environment_edf': 'sky_edf'}))
# Create an environment called "sky" and bind it to the scene.
scene.set_environment(
asr.Environment("sky", {
"environment_edf": "sky_edf",
"environment_shader": "sky_shader"
}))
#------------------------------------------------------------------------
# Camera
#------------------------------------------------------------------------
# Create a pinhole camera with film dimensions 0.980 x 0.735 in (24.892 x 18.669 mm).
params = {
'film_dimensions': asr.Vector2f(0.024892, 0.018669),
'focal_length': 0.035
}
camera = asr.Camera("pinhole_camera", "camera", params)
# Place and orient the camera. By default cameras are located in (0.0, 0.0, 0.0)
# and are looking toward Z- (0.0, 0.0, -1.0).
mat = asr.Matrix4d.rotation(asr.Vector3d(1.0, 0.0, 0.0),
math.radians(-20.0))
mat = mat * asr.Matrix4d.translation(asr.Vector3d(0.0, 0.8, 11.0))
camera.transform_sequence().set_transform(0.0, asr.Transformd(mat))
# Bind the camera to the scene.
scene.set_camera(camera)
#------------------------------------------------------------------------
# Frame
#------------------------------------------------------------------------
# Create a frame and bind it to the project.
params = {
'camera': scene.get_camera().get_name(),
'resolution': asr.Vector2i(640, 480),
'color_space': 'srgb'
}
project.set_frame(asr.Frame("beauty", params))
# Bind the scene to the project.
project.set_scene(scene)
return project
def build_project():
# Create an empty project.
project = asr.Project('test project')
# Add default configurations to the project.
project.add_default_configurations()
# Set the number of samples. This is basically the quality parameter: the higher the number
# of samples, the smoother the image but the longer the rendering time.
# todo: fix.
conf = project.configurations()['final']
conf.insert_path('uniform_pixel_renderer.samples', 16)
# Create a scene.
scene = asr.Scene()
# Create an assembly.
assembly = asr.Assembly("assembly")
#------------------------------------------------------------------------
# Materials
#------------------------------------------------------------------------
for i in range(0, 10):
assembly.bsdfs().insert(
asr.BSDF(
"glossy_brdf", "glossy" + str(i), {
"mdf": "ggx",
"reflectance": 1.0,
"roughness": i / 9.0,
"energy_compensation": 0.0
}))
assembly.bsdfs().insert(
asr.BSDF(
"glossy_brdf", "glossy_ec" + str(i), {
"mdf": "ggx",
"reflectance": 1.0,
"roughness": i / 9.0,
"energy_compensation": 1.0
}))
for i in range(0, 10):
assembly.materials().insert(
asr.Material("generic_material", "mat" + str(i),
{"bsdf": "glossy" + str(i)}))
assembly.materials().insert(
asr.Material("generic_material", "mat_ec" + str(i),
{"bsdf": "glossy_ec" + str(i)}))
#------------------------------------------------------------------------
# Geometry
#------------------------------------------------------------------------
object_name = "sphere"
object = asr.MeshObject(object_name, {
"primitive": "sphere",
"radius": 0.4
})
assembly.objects().insert(object)
obj_instance_params = {'visibility': {"glossy": False, "shadow": False}}
for i in range(0, 10):
instance_name = object_name + "_inst" + str(i)
material_names = {"default": "mat" + str(i)}
mat = asr.Matrix4d.make_translation(asr.Vector3d(-5.0 + i, -0.5, 0.0))
instance = asr.ObjectInstance(instance_name,
obj_instance_params, object_name,
asr.Transformd(mat), material_names)
assembly.object_instances().insert(instance)
for i in range(0, 10):
instance_name = object_name + "_ec_inst" + str(i)
material_names = {"default": "mat_ec" + str(i)}
mat = asr.Matrix4d.make_translation(asr.Vector3d(-5.0 + i, 0.5, 0.0))
instance = asr.ObjectInstance(instance_name,
obj_instance_params, object_name,
asr.Transformd(mat), material_names)
assembly.object_instances().insert(instance)
#------------------------------------------------------------------------
# Assembly instance
#------------------------------------------------------------------------
# Create an instance of the assembly and insert it into the scene.
assembly_inst = asr.AssemblyInstance("assembly_inst", {},
assembly.get_name())
assembly_inst.transform_sequence().set_transform(
0.0, asr.Transformd(asr.Matrix4d.identity()))
scene.assembly_instances().insert(assembly_inst)
# Insert the assembly into the scene.
scene.assemblies().insert(assembly)
#------------------------------------------------------------------------
# Environment
#------------------------------------------------------------------------
# Create a color called "gray" and insert it into the scene.
Gray = [0.5, 0.5, 0.5]
scene.colors().insert(
asr.ColorEntity("gray", {
'color_space': 'linear_rgb',
'multiplier': 1.0
}, Gray))
# Create an environment EDF called "gray_edf" and insert it into the scene.
scene.environment_edfs().insert(
asr.EnvironmentEDF("constant_environment_edf", "gray_edf",
{'radiance': 'gray'}))
# Create an environment shader called "gray_shader" and insert it into the scene.
scene.environment_shaders().insert(
asr.EnvironmentShader("edf_environment_shader", "gray_shader",
{'environment_edf': 'gray_edf'}))
# Create an environment called "sky" and bind it to the scene.
scene.set_environment(
asr.Environment("sky", {
"environment_edf": "gray_edf",
"environment_shader": "gray_shader"
}))
#------------------------------------------------------------------------
# Camera
#------------------------------------------------------------------------
params = {
'film_dimensions': asr.Vector2f(0.0640, 0.0200),
'focal_length': 0.035
}
camera = asr.Camera("pinhole_camera", "camera", params)
mat = asr.Matrix4d.make_translation(
asr.Vector3d(-0.444315058060864, -0.071277492791890,
5.674764299781837))
camera.transform_sequence().set_transform(0.0, asr.Transformd(mat))
# Bind the camera to the scene.
scene.cameras().insert(camera)
#------------------------------------------------------------------------
# Frame
#------------------------------------------------------------------------
# Create a frame and bind it to the project.
params = {'camera': 'camera', 'resolution': asr.Vector2i(640, 200)}
project.set_frame(asr.Frame("beauty", params))
# Bind the scene to the project.
project.set_scene(scene)
return project
def __translate_frame(self, context):
"""
Convert image related settings (resolution, crop windows, AOVs, ...) to appleseed.
:param context:
"""
logger.debug("Translating frame")
asr_scene_props = self.bl_scene.appleseed
scale = self.bl_scene.render.resolution_percentage / 100.0
if context is not None:
width = int(context.region.width)
height = int(context.region.height)
self.__viewport_resolution = [width, height]
else:
width = int(self.bl_scene.render.resolution_x * scale)
height = int(self.bl_scene.render.resolution_y * scale)
noise_seed = (asr_scene_props.noise_seed + self.bl_scene.frame_current) if asr_scene_props.per_frame_noise else asr_scene_props.noise_seed
frame_params = {
'resolution': asr.Vector2i(width, height),
'camera': "Camera",
'tile_size': asr.Vector2i(asr_scene_props.tile_size, asr_scene_props.tile_size),
'filter': asr_scene_props.pixel_filter,
'filter_size': asr_scene_props.pixel_filter_size,
'denoiser': asr_scene_props.denoise_mode,
'noise_seed': noise_seed,
'skip_denoised': asr_scene_props.skip_denoised,
'random_pixel_order': asr_scene_props.random_pixel_order,
'prefilter_spikes': asr_scene_props.prefilter_spikes,
'spike_threshold': asr_scene_props.spike_threshold,
'patch_distance_threshold': asr_scene_props.patch_distance_threshold,
'denoise_scales': asr_scene_props.denoise_scales,
'mark_invalid_pixels': asr_scene_props.mark_invalid_pixels}
aovs = asr.AOVContainer()
if self.export_mode != ProjectExportMode.INTERACTIVE_RENDER:
aovs = self.__set_aovs(aovs)
# Create and set the frame in the project.
self.__frame = asr.Frame("beauty",
frame_params,
aovs)
if self.bl_scene.render.use_border and self.export_mode != ProjectExportMode.INTERACTIVE_RENDER:
min_x = int(self.bl_scene.render.border_min_x * width)
max_x = int(self.bl_scene.render.border_max_x * width) - 1
min_y = height - int(self.bl_scene.render.border_max_y * height)
max_y = height - int(self.bl_scene.render.border_min_y * height) - 1
self.__frame.set_crop_window([min_x, min_y, max_x, max_y])
elif self.export_mode == ProjectExportMode.INTERACTIVE_RENDER and context.space_data.use_render_border and context.region_data.view_perspective in ('ORTHO', 'PERSP'):
min_x = int(context.space_data.render_border_min_x * width)
max_x = int(context.space_data.render_border_max_x * width) - 1
min_y = height - int(context.space_data.render_border_max_y * height)
max_y = height - int(context.space_data.render_border_min_y * height) - 1
self.__frame.set_crop_window([min_x, min_y, max_x, max_y])
elif self.export_mode == ProjectExportMode.INTERACTIVE_RENDER and self.bl_scene.render.use_border and context.region_data.view_perspective == 'CAMERA':
"""
I can't explain how the following code produces the correct render window.
I basically threw every parameter combination I could think of together
until the result looked right.
"""
zoom = 4 / ((math.sqrt(2) + context.region_data.view_camera_zoom / 50)** 2)
frame_aspect_ratio = width / height
camera_aspect_ratio = calc_film_aspect_ratio(self.bl_scene)
if frame_aspect_ratio > 1:
camera_width = width / zoom
camera_height = camera_width / camera_aspect_ratio
else:
camera_height = height / (zoom * camera_aspect_ratio)
camera_width = camera_height * camera_aspect_ratio
view_offset_x, view_offset_y = context.region_data.view_camera_offset
view_shift_x = ((view_offset_x * 2) / zoom) * width
view_shift_y = ((view_offset_y * 2) / zoom) * height
window_shift_x = (width - camera_width) / 2
window_shift_y = (height - camera_height) / 2
window_x_min = int(camera_width * self.bl_scene.render.border_min_x + window_shift_x - view_shift_x)
window_x_max = int(camera_width * self.bl_scene.render.border_max_x + window_shift_x - view_shift_x)
window_y_min = height - int(camera_height * self.bl_scene.render.border_max_y + window_shift_y - view_shift_y)
window_y_max = height - int(camera_height * self.bl_scene.render.border_min_y + window_shift_y - view_shift_y)
# Check for coordinates outside the render window.
window_x_min = clamp_value(window_x_min, 0, width - 1)
window_x_max = clamp_value(window_x_max, 0, width - 1)
window_y_min = clamp_value(window_y_min, 0, height - 1)
window_y_max = clamp_value(window_y_max, 0, height - 1)
self.__frame.set_crop_window([window_x_min, window_y_min, window_x_max, window_y_max])
self.__project.set_frame(self.__frame)
self.__frame = self.as_project.get_frame()
if len(asr_scene_props.post_processing_stages) > 0 and self.export_mode != ProjectExportMode.INTERACTIVE_RENDER:
self.__set_post_process()
def __translate_frame(self):
"""
Convert image related settings (resolution, crop windows, AOVs, ...) to appleseed.
"""
logger.debug("Translating frame")
asr_scene_props = self.bl_scene.appleseed
scale = self.bl_scene.render.resolution_percentage / 100.0
if self.__context:
width = int(self.__context.region.width)
height = int(self.__context.region.height)
self.__viewport_resolution = [width, height]
else:
width = int(self.bl_scene.render.resolution_x * scale)
height = int(self.bl_scene.render.resolution_y * scale)
frame_params = {
'resolution':
asr.Vector2i(width, height),
'camera':
self.bl_scene.camera.name,
'tile_size':
asr.Vector2i(asr_scene_props.tile_size, asr_scene_props.tile_size),
'filter':
asr_scene_props.pixel_filter,
'filter_size':
asr_scene_props.pixel_filter_size,
'denoiser':
asr_scene_props.denoise_mode,
'skip_denoised':
asr_scene_props.skip_denoised,
'random_pixel_order':
asr_scene_props.random_pixel_order,
'prefilter_spikes':
asr_scene_props.prefilter_spikes,
'spike_threshold':
asr_scene_props.spike_threshold,
'patch_distance_threshold':
asr_scene_props.patch_distance_threshold,
'denoise_scales':
asr_scene_props.denoise_scales,
'mark_invalid_pixels':
asr_scene_props.mark_invalid_pixels
}
# AOVs
aovs = asr.AOVContainer()
if self.export_mode != ProjectExportMode.INTERACTIVE_RENDER:
if asr_scene_props.diffuse_aov:
aovs.insert(asr.AOV('diffuse_aov', {}))
if asr_scene_props.direct_diffuse_aov:
aovs.insert(asr.AOV('direct_diffuse_aov', {}))
if asr_scene_props.indirect_diffuse_aov:
aovs.insert(asr.AOV('indirect_diffuse_aov', {}))
if asr_scene_props.glossy_aov:
aovs.insert(asr.AOV('glossy_aov', {}))
if asr_scene_props.direct_glossy_aov:
aovs.insert(asr.AOV('direct_glossy_aov', {}))
if asr_scene_props.indirect_glossy_aov:
aovs.insert(asr.AOV('indirect_glossy_aov', {}))
if asr_scene_props.normal_aov:
aovs.insert(asr.AOV('normal_aov', {}))
if asr_scene_props.position_aov:
aovs.insert(asr.AOV('position_aov', {}))
if asr_scene_props.uv_aov:
aovs.insert(asr.AOV('uv_aov', {}))
if asr_scene_props.depth_aov:
aovs.insert(asr.AOV('depth_aov', {}))
if asr_scene_props.pixel_time_aov:
aovs.insert(asr.AOV('pixel_time_aov', {}))
if asr_scene_props.invalid_samples_aov:
aovs.insert(asr.AOV('invalid_samples_aov', {}))
if asr_scene_props.pixel_sample_count_aov:
aovs.insert(asr.AOV('pixel_sample_count_aov', {}))
if asr_scene_props.pixel_variation_aov:
aovs.insert(asr.AOV('pixel_variation_aov', {}))
if asr_scene_props.albedo_aov:
aovs.insert(asr.AOV('albedo_aov', {}))
if asr_scene_props.emission_aov:
aovs.insert(asr.AOV('emission_aov', {}))
if asr_scene_props.npr_shading_aov:
aovs.insert(asr.AOV('npr_shading_aov', {}))
if asr_scene_props.npr_contour_aov:
aovs.insert(asr.AOV('npr_contour_aov', {}))
# Create and set the frame in the project.
frame = asr.Frame("beauty", frame_params, aovs)
if len(
asr_scene_props.post_processing_stages
) > 0 and self.export_mode != ProjectExportMode.INTERACTIVE_RENDER:
for index, stage in enumerate(
asr_scene_props.post_processing_stages):
if stage.model == 'render_stamp_post_processing_stage':
params = {
'order': index,
'format_string': stage.render_stamp
}
else:
params = {
'order': index,
'color_map': stage.color_map,
'auto_range': stage.auto_range,
'range_min': stage.range_min,
'range_max': stage.range_max,
'add_legend_bar': stage.add_legend_bar,
'legend_bar_ticks': stage.legend_bar_ticks,
'render_isolines': stage.render_isolines,
'line_thickness': stage.line_thickness
}
if stage.color_map == 'custom':
params[
'color_map_file_path'] = stage.color_map_file_path
post_process = asr.PostProcessingStage(stage.model, stage.name,
params)
frame.post_processing_stages().insert(post_process)
if self.bl_scene.render.use_border and self.export_mode != ProjectExportMode.INTERACTIVE_RENDER:
min_x = int(self.bl_scene.render.border_min_x * width)
max_x = int(self.bl_scene.render.border_max_x * width) - 1
min_y = height - int(self.bl_scene.render.border_max_y * height)
max_y = height - int(
self.bl_scene.render.border_min_y * height) - 1
frame.set_crop_window([min_x, min_y, max_x, max_y])
elif self.export_mode == ProjectExportMode.INTERACTIVE_RENDER and self.__context.space_data.use_render_border \
and self.__context.region_data.view_perspective in ('ORTHO', 'PERSP'):
min_x = int(self.__context.space_data.render_border_min_x * width)
max_x = int(
self.__context.space_data.render_border_max_x * width) - 1
min_y = height - int(
self.__context.space_data.render_border_max_y * height)
max_y = height - int(
self.__context.space_data.render_border_min_y * height) - 1
frame.set_crop_window([min_x, min_y, max_x, max_y])
self.__project.set_frame(frame)
