def generate_spg_patterns_for_led_walls()

in src/open_vp_cal/framework/utils.py [0:0]


def generate_spg_patterns_for_led_walls(
        project_settings: 'ProjectSettings',
        led_walls: List['LedWallSettings']) -> None:
    """ For the given project settings and list of led walls, generate the patterns for SPG which is used to
                evaluate and diagnose issues with the imaging chain

        Args:
            project_settings: The project settings used for the project
            led_walls: the led walls we want to generate patterns from
    """
    config_writer, ocio_config_path = export_pre_calibration_ocio_config(
        project_settings, led_walls)
    spg_project_settings = SPGProjectSettings()
    spg_project_settings.frame_rate = project_settings.frame_rate
    spg_project_settings.image_file_format = project_settings.file_format.replace(
        ".", "")
    spg_project_settings.image_file_bit_depth = 10
    spg_project_settings.output_folder = os.path.join(
        project_settings.export_folder,
        constants.ProjectFolders.SPG
    )
    spg_project_settings.channel_mapping = "RGB"
    spg_project_settings.ocio_config_path = ocio_config_path
    apply_eotf_colour_transform = False
    if spg_project_settings.image_file_format != constants.FileFormats.FF_EXR:
        apply_eotf_colour_transform = True
    spg_led_walls = []
    spg_led_panels = []
    spg_raster_maps = []
    for count, led_wall in enumerate(led_walls):
        idx = count + 1

        # As this is a basic setup we default to a typical panel as we are not doing a deep dive and pixel perfect
        # match
        spg_panel = SPGLedPanel()
        spg_panel.name = f"Panel_{idx}_{led_wall.name}"
        spg_panel.manufacturer = "Unknown"
        spg_panel.panel_width = 500
        spg_panel.panel_height = 500
        spg_panel.panel_depth = 80
        spg_panel.pixel_pitch = 2.85
        spg_panel.brightness = led_wall.target_max_lum_nits
        spg_panel.refresh_rate = "3840"
        spg_panel.scan_rate = "1/8"
        spg_led_panels.append(spg_panel)

        # We create a faux led wall which is the largest which we can fit into a given resolution image
        # as we are not doing a pixel perfect diagnosis
        target_gamut_only_cs = config_writer.get_target_gamut_only_cs(led_wall)
        target_gamut_and_tf_cs = config_writer.get_target_gamut_and_transfer_function_cs(
            led_wall)
        transfer_function_only_cs = config_writer.get_transfer_function_only_cs(
            led_wall)

        # If we are not using an EXR file format, we apply the EOTF colour transform
        if not apply_eotf_colour_transform:
            target_gamut_and_tf_cs = target_gamut_only_cs

        spg_led_wall = SPGLedWall()
        spg_led_wall.gamut_only_cs_name = target_gamut_only_cs.getName()
        spg_led_wall.gamut_and_transfer_function_cs_name = target_gamut_and_tf_cs.getName()
        spg_led_wall.transfer_function_only_cs_name = transfer_function_only_cs.getName()
        spg_led_wall.id = idx
        spg_led_wall.name = led_wall.name
        spg_led_wall.panel_name = spg_panel.name
        spg_led_wall.panel = spg_panel
        spg_led_wall.panel_count_width = int(
            project_settings.resolution_width / spg_panel.panel_resolution_width)
        spg_led_wall.panel_count_height = int(
            project_settings.resolution_height / spg_panel.panel_resolution_height
        )
        spg_led_wall.wall_default_color = core_utils.generate_color(led_wall.name)

        spg_led_walls.append(spg_led_wall)

        spg_mapping = SPGMapping()
        spg_mapping.wall_name = spg_led_wall.name
        spg_mapping.raster_u = 0
        spg_mapping.raster_v = 0
        spg_mapping.wall_segment_u_start = 0
        spg_mapping.wall_segment_u_end = spg_led_wall.resolution_width
        spg_mapping.wall_segment_v_start = 0
        spg_mapping.wall_segment_v_end = spg_led_wall.resolution_height
        spg_mapping.wall_segment_orientation = 0

        spg_raster_map = SPGRasterMap()
        spg_raster_map.name = f"Raster_{led_wall.name}"
        spg_raster_map.resolution_width = project_settings.resolution_width
        spg_raster_map.resolution_height = project_settings.resolution_height
        spg_raster_map.mappings = [spg_mapping]

        spg_raster_maps.append(spg_raster_map)

    spg_led_panel_json = [json.loads(spg_led_panel.to_json()) for spg_led_panel in
                          spg_led_panels]
    spg_led_wall_json = [json.loads(spg_led_wall.to_json()) for spg_led_wall in
                         spg_led_walls]
    spg_raster_map_json = [json.loads(spg_raster_map.to_json()) for spg_raster_map
                           in spg_raster_maps]
    tmp_dir = tempfile.TemporaryDirectory()
    spg_led_panel_json_file = os.path.join(tmp_dir.name, "led_panel_settings.json")
    spg_led_wall_json_file = os.path.join(tmp_dir.name, "led_wall_settings.json")
    spg_raster_map_json_file = os.path.join(tmp_dir.name,
                                            "raster_map_settings.json")
    spg_project_settings_json_file = os.path.join(tmp_dir.name,
                                                  "spg_project_settings.json")
    with open(spg_led_panel_json_file, 'w') as f:
        json.dump(spg_led_panel_json, f, indent=4)
    with open(spg_led_wall_json_file, 'w') as f:
        json.dump(spg_led_wall_json, f, indent=4)
    with open(spg_raster_map_json_file, 'w') as f:
        json.dump(spg_raster_map_json, f, indent=4)
    with open(spg_project_settings_json_file, 'w') as f:
        json.dump(json.loads(spg_project_settings.to_json()), f, indent=4)

    run_spg_pattern_generator(
        spg_led_panel_json_file,
        spg_led_wall_json_file,
        spg_raster_map_json_file,
        spg_project_settings_json_file,
        ResourceLoader.spg_pattern_basic_config()
    )