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)