Randomization Basic Usage

    By: SKY ENGINE AI
    scroll down ↓to find out morerandomization-basic-usage_2_resourcesTutorial

    Randomization - Basic Usage

    In this section you will get to know how to use some basic concepts of Randomization.

    Agenda:

    • Using Sky Engine's Randomization vs the usual random()
    • Distribution: Uniform vs Gaussian
    • Synchronization: Unrestricted vs Equal

    Scene setup

    Let's use custom scene composer to set up the scene.

        from skyrenderer.cases.utils import RandomizationBasicUsageSceneComposer
        scene_composer = RandomizationBasicUsageSceneComposer(antialiasing_level=64)
    scene_composer.setup_scene()
    scene_composer.visualize()
    randomization-basic-usage_1_resourcesTutorial
    2025-04-02 16:21:07,601 | skyrenderer.scene.renderer_context |  INFO: Root paths:
- root path: /home/skyengine/anaconda/lib/python3.6/site-packages/skyrenderer
- assets path: /dli/mount/assets
- config path: /home/skyengine/anaconda/lib/python3.6/site-packages/skyrenderer/config
- gpu sources path: /home/skyengine/anaconda/lib/python3.6/site-packages/skyrenderer/optix_sources/sources
- cache path: /dli/mount/cache
- ptx cache path: compiled_ptx/ptx
- ocio path: ocio_configs/aces_1.2/config.ocio

2025-04-02 16:21:07,779 | skyrenderer.scene.renderer_context |  WARNING: Light with light_id=light_LIGHT_NUL already exists in the scene and will be replace with a new one.There can only be a single light for a single node.

2025-04-02 16:21:07,781 | skyrenderer.scene.renderer_context |  WARNING: Light with light_id=light2_LIGHT_NUL already exists in the scene and will be replace with a new one.There can only be a single light for a single node.

2025-04-02 16:21:10,763 | skyrenderer.utils.time_measurement |  INFO: Setup time: 2.98 seconds

2025-04-02 16:21:10,872 | skyrenderer.utils.time_measurement |  INFO: Setup time: 102 ms

2025-04-02 16:21:12,480 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.61 seconds

2025-04-02 16:21:30,886 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-02 16:21:30,888 | skyrenderer.utils.time_measurement |  INFO: Render time: 18.41 seconds

    This is our initial setup - a milk-filled bowl, with floating yummy Danish butter scones. The chef has baked them
    to be identical, and arranged them with peculiar precision - to help further examples illustrate what's happening
    more clearly.

    Seriously though, they are on a grid and have 0,0,0 rotation applied.

    We will now shake the bowl - randomize their positions, move them slightly off their grid spots, plunge them into
    milk to a varying degree, and flip them around.

        scene_composer.randomize_positions_classic()
    scene_composer.visualize()
    randomization-basic-usage_2_resourcesTutorial
    2025-04-02 16:21:31,711 | skyrenderer.utils.time_measurement |  INFO: Setup time: 117 ms

2025-04-02 16:21:33,249 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.54 seconds

2025-04-02 16:21:49,826 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-02 16:21:49,827 | skyrenderer.utils.time_measurement |  INFO: Render time: 16.58 seconds

    That looks more natural.

    Using Sky Engine's Randomization vs the usual random()

    The example above and the collection of 3 examples below are randomized using Python's built-in random.random()
    function - that's why we named this method "classic". Every time you invoke such randomization, results will be
    totally different - as expected.

        scene_composer.reduced_image_size()
    renders = {}
    scene_composer.randomize_positions_classic()
    renders["classic #1"] = scene_composer.get_render()
    scene_composer.randomize_positions_classic()
    renders["classic #2"] = scene_composer.get_render()
    scene_composer.randomize_positions_classic()
    renders["classic #3"] = scene_composer.get_render()
    scene_composer.visualize_grid_desc(renders, shape=(500, 1500), font_scale=2)
    randomization-basic-usage_3_resourcesTutorial
    2025-04-02 16:21:50,544 | skyrenderer.utils.time_measurement |  INFO: Setup time: 104 ms

2025-04-02 16:21:52,141 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.60 seconds

2025-04-02 16:21:57,608 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-02 16:21:57,609 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.47 seconds

2025-04-02 16:21:57,723 | skyrenderer.utils.time_measurement |  INFO: Setup time: 103 ms

2025-04-02 16:21:59,252 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.53 seconds

2025-04-02 16:22:03,917 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-02 16:22:03,918 | skyrenderer.utils.time_measurement |  INFO: Render time: 4.66 seconds

2025-04-02 16:22:04,027 | skyrenderer.utils.time_measurement |  INFO: Setup time: 101 ms

2025-04-02 16:22:05,602 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.57 seconds

2025-04-02 16:22:10,922 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-02 16:22:10,923 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.32 seconds

    These images will be also different when you re-run this entire tutorial file next time.

    This "classic" method has been implemented for this tutorial only, to visualize the difference in behavior vs the
    preferred way to randomize things, presented below. So don't worry about the specifics of the "classic" method.

    Sky Engine relies on centralized control over everything that appears to be random. This is important to be able
    to recreate renders with pixel-perfect precision between different runs of your rendering process, as long as the
    scene setup remains unchanged. Sky Engine will make sure to draw the same exact "random" values as it did the
    first time around, in the same order, in all the places you specified as random-driven, no matter how elaborate
    your scene is.

    Here we will create 3 images, each randomized with the preferred method.

        scene_composer.reset_positions()
    renders = {}
    scene_composer.randomize_positions()
    renders["preferred #1"] = scene_composer.get_render()
    scene_composer.randomize_positions()
    renders["preferred #2"] = scene_composer.get_render()
    scene_composer.randomize_positions()
    renders["preferred #3"] = scene_composer.get_render()
    scene_composer.visualize_grid_desc(renders, shape=(500, 1500), font_scale=2)
    randomization-basic-usage_4_resourcesTutorial
    2025-04-02 16:22:11,393 | skyrenderer.utils.time_measurement |  INFO: Setup time: 108 ms

2025-04-02 16:22:12,935 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.54 seconds

2025-04-02 16:22:18,384 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-02 16:22:18,385 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.45 seconds

2025-04-02 16:22:18,501 | skyrenderer.utils.time_measurement |  INFO: Setup time: 109 ms

2025-04-02 16:22:20,037 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.54 seconds

2025-04-02 16:22:24,757 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-02 16:22:24,758 | skyrenderer.utils.time_measurement |  INFO: Render time: 4.72 seconds

2025-04-02 16:22:24,963 | skyrenderer.utils.time_measurement |  INFO: Setup time: 199 ms

2025-04-02 16:22:26,512 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.55 seconds

2025-04-02 16:22:31,216 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-02 16:22:31,217 | skyrenderer.utils.time_measurement |  INFO: Render time: 4.70 seconds

    Randomization - Basic Usage

    In this section you will get to know how to use some basic concepts of Randomization.

    Agenda:

    • Using Sky Engine's Randomization vs the usual random()
    • Distribution: Uniform vs Gaussian
    • Synchronization: Unrestricted vs Equal

    Scene setup

    Let's use custom scene composer to set up the scene.

        from skyrenderer.cases.utils import RandomizationBasicUsageSceneComposer
        scene_composer = RandomizationBasicUsageSceneComposer(antialiasing_level=64)
    scene_composer.setup_scene()
    scene_composer.visualize()
    randomization-basic-usage_1_resourcesTutorial
    2025-04-03 08:37:46,178 | skyrenderer.scene.renderer_context |  INFO: Root paths:
- root path: /home/skyengine/anaconda/lib/python3.6/site-packages/skyrenderer
- assets path: /dli/mount/assets
- config path: /home/skyengine/anaconda/lib/python3.6/site-packages/skyrenderer/config
- gpu sources path: /home/skyengine/anaconda/lib/python3.6/site-packages/skyrenderer/optix_sources/sources
- cache path: /dli/mount/cache
- ptx cache path: compiled_ptx/ptx
- ocio path: ocio_configs/aces_1.2/config.ocio

2025-04-03 08:37:46,471 | skyrenderer.scene.renderer_context |  WARNING: Light with light_id=light_LIGHT_NUL already exists in the scene and will be replace with a new one.There can only be a single light for a single node.

2025-04-03 08:37:46,476 | skyrenderer.scene.renderer_context |  WARNING: Light with light_id=light2_LIGHT_NUL already exists in the scene and will be replace with a new one.There can only be a single light for a single node.

2025-04-03 08:37:50,167 | skyrenderer.utils.time_measurement |  INFO: Setup time: 3.69 seconds

2025-04-03 08:37:50,388 | skyrenderer.utils.time_measurement |  INFO: Setup time: 202 ms

2025-04-03 08:37:52,340 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.95 seconds

2025-04-03 08:38:09,772 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:38:09,774 | skyrenderer.utils.time_measurement |  INFO: Render time: 17.43 seconds

    This is our initial setup - a milk-filled bowl, with floating yummy Danish butter scones. The chef has baked them
    to be identical, and arranged them with peculiar precision - to help further examples illustrate what's happening
    more clearly.

    Seriously though, they are on a grid and have 0,0,0 rotation applied.

    We will now shake the bowl - randomize their positions, move them slightly off their grid spots, plunge them into
    milk to a varying degree, and flip them around.

        scene_composer.randomize_positions_classic()
    scene_composer.visualize()
    randomization-basic-usage_2_resourcesTutorial
    2025-04-03 08:38:10,717 | skyrenderer.utils.time_measurement |  INFO: Setup time: 210 ms

2025-04-03 08:38:12,426 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.71 seconds

2025-04-03 08:38:29,953 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-03 08:38:29,955 | skyrenderer.utils.time_measurement |  INFO: Render time: 17.53 seconds

    That looks more natural.

    Using Sky Engine's Randomization vs the usual random()

    The example above and the collection of 3 examples below are randomized using Python's built-in random.random()
    function - that's why we named this method "classic". Every time you invoke such randomization, results will be
    totally different - as expected.

        scene_composer.reduced_image_size()
    renders = {}
    scene_composer.randomize_positions_classic()
    renders["classic #1"] = scene_composer.get_render()
    scene_composer.randomize_positions_classic()
    renders["classic #2"] = scene_composer.get_render()
    scene_composer.randomize_positions_classic()
    renders["classic #3"] = scene_composer.get_render()
    scene_composer.visualize_grid_desc(renders, shape=(500, 1500), font_scale=2)
    randomization-basic-usage_3_resourcesTutorial
    2025-04-03 08:38:30,802 | skyrenderer.utils.time_measurement |  INFO: Setup time: 190 ms

2025-04-03 08:38:32,479 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.68 seconds

2025-04-03 08:38:37,828 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-03 08:38:37,830 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.35 seconds

2025-04-03 08:38:38,029 | skyrenderer.utils.time_measurement |  INFO: Setup time: 188 ms

2025-04-03 08:38:39,694 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.66 seconds

2025-04-03 08:38:44,169 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-03 08:38:44,171 | skyrenderer.utils.time_measurement |  INFO: Render time: 4.48 seconds

2025-04-03 08:38:44,374 | skyrenderer.utils.time_measurement |  INFO: Setup time: 190 ms

2025-04-03 08:38:46,039 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.66 seconds

2025-04-03 08:38:50,503 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-03 08:38:50,504 | skyrenderer.utils.time_measurement |  INFO: Render time: 4.46 seconds

    These images will be also different when you re-run this entire tutorial file next time.

    This "classic" method has been implemented for this tutorial only, to visualize the difference in behavior vs the
    preferred way to randomize things, presented below. So don't worry about the specifics of the "classic" method.

    Sky Engine relies on centralized control over everything that appears to be random. This is important to be able
    to recreate renders with pixel-perfect precision between different runs of your rendering process, as long as the
    scene setup remains unchanged. Sky Engine will make sure to draw the same exact "random" values as it did the
    first time around, in the same order, in all the places you specified as random-driven, no matter how elaborate
    your scene is.

    Here we will create 3 images, each randomized with the preferred method.

        scene_composer.reset_positions()
    renders = {}
    scene_composer.randomize_positions()
    renders["preferred #1"] = scene_composer.get_render()
    scene_composer.randomize_positions()
    renders["preferred #2"] = scene_composer.get_render()
    scene_composer.randomize_positions()
    renders["preferred #3"] = scene_composer.get_render()
    scene_composer.visualize_grid_desc(renders, shape=(500, 1500), font_scale=2)
    randomization-basic-usage_4_resourcesTutorial
    2025-04-03 08:38:51,067 | skyrenderer.utils.time_measurement |  INFO: Setup time: 202 ms

2025-04-03 08:38:52,926 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.86 seconds

2025-04-03 08:38:58,550 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:38:58,552 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.62 seconds

2025-04-03 08:38:58,761 | skyrenderer.utils.time_measurement |  INFO: Setup time: 201 ms

2025-04-03 08:39:00,514 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.75 seconds

2025-04-03 08:39:05,224 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:39:05,227 | skyrenderer.utils.time_measurement |  INFO: Render time: 4.71 seconds

2025-04-03 08:39:05,437 | skyrenderer.utils.time_measurement |  INFO: Setup time: 203 ms

2025-04-03 08:39:07,133 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.69 seconds

2025-04-03 08:39:12,638 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:39:12,640 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.50 seconds

    You can see all images are identical, despite us having called the randomization 3 separate times. If you're
    feeling adventurous, you can save these images to disk and analyze them in your favorite graphics editor to
    confirm they're perfect copies, down to RGB values of each pixel. (Except for the label fonts, of course.)

    In order to trigger different randomization states, you can use the frame number param, which more or less
    directly affects the seeding of the entire randomization system.

    We will render 3 pairs of images to demonstrate how randomized positions change with each frame number, while at
    the same remain identical if you re-use the same frame number again.

        renders = {}
    scene_composer.randomize_positions()
    renders["frame=1"] = scene_composer.get_render(frame=1)
    renders["frame=2"] = scene_composer.get_render(frame=2)
    renders["frame=3"] = scene_composer.get_render(frame=3)
    renders["frame=1 again"] = scene_composer.get_render(frame=1)
    renders["frame=2 again"] = scene_composer.get_render(frame=2)
    renders["frame=3 again"] = scene_composer.get_render(frame=3)
    scene_composer.visualize_grid_desc(renders, shape=(1000, 1500), font_scale=2)
    randomization-basic-usage_5_resourcesTutorial
    2025-04-03 08:39:13,080 | skyrenderer.utils.time_measurement |  INFO: Setup time: 214 ms

2025-04-03 08:39:14,777 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.70 seconds

2025-04-03 08:39:20,288 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-03 08:39:20,290 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.51 seconds

2025-04-03 08:39:20,496 | skyrenderer.utils.time_measurement |  INFO: Setup time: 199 ms

2025-04-03 08:39:22,192 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.70 seconds

2025-04-03 08:39:27,433 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:39:27,435 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.24 seconds

2025-04-03 08:39:27,643 | skyrenderer.utils.time_measurement |  INFO: Setup time: 201 ms

2025-04-03 08:39:29,361 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.72 seconds

2025-04-03 08:39:33,846 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:39:33,848 | skyrenderer.utils.time_measurement |  INFO: Render time: 4.49 seconds

2025-04-03 08:39:34,060 | skyrenderer.utils.time_measurement |  INFO: Setup time: 204 ms

2025-04-03 08:39:35,807 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.75 seconds

2025-04-03 08:39:41,538 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:39:41,539 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.73 seconds

2025-04-03 08:39:41,750 | skyrenderer.utils.time_measurement |  INFO: Setup time: 203 ms

2025-04-03 08:39:43,461 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.71 seconds

2025-04-03 08:39:48,917 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:39:48,919 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.46 seconds

2025-04-03 08:39:49,130 | skyrenderer.utils.time_measurement |  INFO: Setup time: 204 ms

2025-04-03 08:39:50,799 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.67 seconds

2025-04-03 08:39:56,143 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:39:56,144 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.34 seconds

    Note that we called the "randomize" method only once before the first image. You don't need to manually call it
    before each intended state change, just changing the frame number alone will trigger a cascade of re-randomization
    throughout the system.

    How to achieve this outside of this tutorial?

    Behind the scenes we put all scones into a dict. Feel free to inspect its contents.

        all_scones = scene_composer.all_scones

    One example of a Provider which will do all the randomizations for you, is SimpleTransformProvider. Its params are
    self-explanatory. We will iterate over all scone nodes and apply various random value ranges to their
    transformations. Try your own values:

        from skyrenderer.basic_types.provider import SimpleTransformProvider
    from skyrenderer.basic_types.transform_path.transform_path import RotationMode
        stp = SimpleTransformProvider(
        scene_composer.renderer_context,
        translation_range_x=(-0.015, 0.015),
        translation_range_y=(-0.02, 0.05),
        translation_range_z=(-0.015, 0.015),
        rotation_range_x=(-180, 180),
        rotation_range_y=(-180, 180),
        rotation_range_z=(-180, 180),
        rotation_mode=RotationMode.DEGREES,
        scale_range_x=(0.3, 1.5),
        scale_range_y=(0.4, 1.5),
        scale_range_z=(0.4, 2),
    )
    for (scone, _) in all_scones.values():
        scone.modify_locus_definition(transform_provider=stp)
    renders = {}
    renders["frame=1"] = scene_composer.get_render(frame=1)
    renders["frame=2"] = scene_composer.get_render(frame=2)
    renders["frame=3"] = scene_composer.get_render(frame=3)
    scene_composer.visualize_grid_desc(renders, shape=(500, 1500), font_scale=2)
    randomization-basic-usage_6_resourcesTutorial
    2025-04-03 08:39:57,392 | skyrenderer.utils.time_measurement |  INFO: Setup time: 303 ms

2025-04-03 08:39:59,085 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.69 seconds

2025-04-03 08:40:04,205 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:40:04,210 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.12 seconds

2025-04-03 08:40:04,446 | skyrenderer.utils.time_measurement |  INFO: Setup time: 229 ms

2025-04-03 08:40:06,277 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.83 seconds

2025-04-03 08:40:12,222 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:40:12,224 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.95 seconds

2025-04-03 08:40:12,432 | skyrenderer.utils.time_measurement |  INFO: Setup time: 202 ms

2025-04-03 08:40:14,119 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.69 seconds

2025-04-03 08:40:19,664 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:40:19,666 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.55 seconds

    Distribution: Uniform vs Gaussian

    When Sky Engine randomizes various aspects of your scene, it consults a Distribution Strategy - ability to control
    the probability of certain values being drawn more likely than others from a given range. In the examples above we
    have used Uniform Distribution - all values in all ranges were equally likely to be picked.

    Let's see what happens when we change it to Gaussian.

        from skyrenderer.randomization.strategy.distribution import UniformDistribution, RelativeGaussianDistribution
        renders = {}
    scene_composer.randomize_with_distribution(distribution=UniformDistribution())
    renders["uniform #1"] = scene_composer.get_render(frame=1)
    renders["uniform #2"] = scene_composer.get_render(frame=2)
    renders["uniform #3"] = scene_composer.get_render(frame=3)
    scene_composer.randomize_with_distribution(
        distribution=RelativeGaussianDistribution(relative_mu=0.5, relative_sigma=0.07)
    )
    renders["gaussian #1"] = scene_composer.get_render(frame=1)
    renders["gaussian #2"] = scene_composer.get_render(frame=2)
    renders["gaussian #3"] = scene_composer.get_render(frame=3)
    scene_composer.visualize_grid_desc(renders, shape=(1000, 1500), font_scale=2)
    randomization-basic-usage_7_resourcesTutorial
    2025-04-03 08:40:20,395 | skyrenderer.utils.time_measurement |  INFO: Setup time: 204 ms

2025-04-03 08:40:22,094 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.70 seconds

2025-04-03 08:40:26,810 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:40:26,812 | skyrenderer.utils.time_measurement |  INFO: Render time: 4.72 seconds

2025-04-03 08:40:27,021 | skyrenderer.utils.time_measurement |  INFO: Setup time: 202 ms

2025-04-03 08:40:28,739 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.72 seconds

2025-04-03 08:40:34,404 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:40:34,406 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.67 seconds

2025-04-03 08:40:34,616 | skyrenderer.utils.time_measurement |  INFO: Setup time: 203 ms

2025-04-03 08:40:36,292 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.67 seconds

2025-04-03 08:40:41,098 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:40:41,099 | skyrenderer.utils.time_measurement |  INFO: Render time: 4.81 seconds

2025-04-03 08:40:41,310 | skyrenderer.utils.time_measurement |  INFO: Setup time: 204 ms

2025-04-03 08:40:43,064 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.75 seconds

2025-04-03 08:40:48,011 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:40:48,012 | skyrenderer.utils.time_measurement |  INFO: Render time: 4.95 seconds

2025-04-03 08:40:48,222 | skyrenderer.utils.time_measurement |  INFO: Setup time: 202 ms

2025-04-03 08:40:49,930 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.71 seconds

2025-04-03 08:40:55,762 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:40:55,763 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.83 seconds

2025-04-03 08:40:55,973 | skyrenderer.utils.time_measurement |  INFO: Setup time: 202 ms

2025-04-03 08:40:57,654 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.68 seconds

2025-04-03 08:41:02,592 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:41:02,594 | skyrenderer.utils.time_measurement |  INFO: Render time: 4.94 seconds

    You can see the Uniform row shows all kinds of rotations, while in the Gaussian row most of the scones tend to be
    raised upward. We prepared this example to allow only one axis of rotation, and within range of 0-180 degrees,
    hence the Gaussian curve concentrated (sigma=0.07 - thin spike) in the middle of that range (mu=0.5), so it picked
    values closer to 90 degrees. You can experiment with "mu" above to change the scones' tilt to the left or right,
    and "sigma" to increase the variability in the scene.

    How to achieve this outside of this tutorial?

    You need to prepare a DrawingStrategy which consists of InputStrategies - one per each affected property that is
    to be modified for a given node. In this case the DrawingStrategy will be passed into modify_locus_definition()

        from skyrenderer.randomization.strategy.input_drawing_strategy import (
        InputDrawingStrategy,
        DrawingRule,
        RelativeGaussianRandomInput,
        UniformRandomInput,
    )
    from skyrenderer.randomization.strategy.drawing_strategy import DrawingStrategy
        input_strategy = InputDrawingStrategy(drawing_rule=DrawingRule.RANDOM, distribution=UniformDistribution())  # or
    input_strategy = UniformRandomInput()  # shorthand  # or
    input_strategy = InputDrawingStrategy(
        drawing_rule=DrawingRule.RANDOM,
        distribution=RelativeGaussianDistribution(relative_mu=0.75, relative_sigma=0.2),
    )  # or
    input_strategy = RelativeGaussianRandomInput(relative_mu=0.75, relative_sigma=0.2)  # shorthand
    drawing_strategy = DrawingStrategy(
        scene_composer.renderer_context,
        inputs_strategies={"rotation_y": input_strategy, "translation_y": input_strategy},
    )

    In this example the images will show 3 different takes on such scenario:

    • most scones will be elevated to about 1cm above the milk surface (mu=0.75 on the 4cm range); however, wider
      sigma allows some of the scones to sink, and others to rise even higher
    • most scones will be rotated horizontally to about -135 degrees away from their starting position - 0 degrees is
      when serrated side faces the camera ("rotation_range_y" 0~-180deg * "relative_mu" 0.75 = -135deg); while wider
      sigma allows significant +/- deviation from -135, still the scones are mostly facing away from us
        stp = SimpleTransformProvider(
        scene_composer.renderer_context,
        translation_range_y=(-0.02, 0.02),
        rotation_range_y=(0, -180),
        rotation_mode=RotationMode.DEGREES,
    )
    for (scone, _) in all_scones.values():
        scone.modify_locus_definition(
            transform_provider=stp,
            strategy=drawing_strategy,
        )
    renders = {}
    renders["frame=1"] = scene_composer.get_render(frame=1)
    renders["frame=2"] = scene_composer.get_render(frame=2)
    renders["frame=3"] = scene_composer.get_render(frame=3)
    scene_composer.visualize_grid_desc(renders, shape=(500, 1500), font_scale=2)
    randomization-basic-usage_8_resourcesTutorial
    2025-04-03 08:41:03,828 | skyrenderer.utils.time_measurement |  INFO: Setup time: 300 ms

2025-04-03 08:41:05,541 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.71 seconds

2025-04-03 08:41:10,867 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-03 08:41:10,868 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.32 seconds

2025-04-03 08:41:11,076 | skyrenderer.utils.time_measurement |  INFO: Setup time: 201 ms

2025-04-03 08:41:12,739 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.66 seconds

2025-04-03 08:41:17,814 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:41:17,815 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.08 seconds

2025-04-03 08:41:18,035 | skyrenderer.utils.time_measurement |  INFO: Setup time: 210 ms

2025-04-03 08:41:19,768 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.73 seconds

2025-04-03 08:41:24,997 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:41:24,999 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.23 seconds

    More Distributions

    Learn about other types of Distributions available in Sky Engine in the following tutorial:
    RANDOMIZATION_RandomizationAdvancedDistribution

    Synchronization: Unrestricted vs Equal

    You can synchronize object properties if you want multiple objects to appear "interlocked" to each other's state.
    You can synchronize some properties, while keeping other properties freely randomized. See the example below where
    we compare free rotation with synchronized rotation:

        from skyrenderer.randomization.strategy.synchronization import Synchronization
        renders = {}
    scene_composer.randomize_with_synchronization(sync_type=Synchronization.UNRESTRICTED)
    renders["unrestricted #1"] = scene_composer.get_render(frame=1)
    renders["unrestricted #2"] = scene_composer.get_render(frame=2)
    renders["unrestricted #3"] = scene_composer.get_render(frame=3)
    scene_composer.randomize_with_synchronization(sync_type=Synchronization.EQUAL)
    renders["equal #1"] = scene_composer.get_render(frame=1)
    renders["equal #2"] = scene_composer.get_render(frame=2)
    renders["equal #3"] = scene_composer.get_render(frame=3)
    scene_composer.visualize_grid_desc(renders, shape=(1000, 1500), font_scale=2)
    randomization-basic-usage_9_resourcesTutorial
    2025-04-03 08:41:25,695 | skyrenderer.utils.time_measurement |  INFO: Setup time: 205 ms

2025-04-03 08:41:27,377 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.68 seconds

2025-04-03 08:41:33,555 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:41:33,557 | skyrenderer.utils.time_measurement |  INFO: Render time: 6.18 seconds

2025-04-03 08:41:33,767 | skyrenderer.utils.time_measurement |  INFO: Setup time: 201 ms

2025-04-03 08:41:35,508 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.74 seconds

2025-04-03 08:41:41,003 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:41:41,005 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.50 seconds

2025-04-03 08:41:41,217 | skyrenderer.utils.time_measurement |  INFO: Setup time: 204 ms

2025-04-03 08:41:42,923 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.71 seconds

2025-04-03 08:41:49,182 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:41:49,184 | skyrenderer.utils.time_measurement |  INFO: Render time: 6.26 seconds

2025-04-03 08:41:49,391 | skyrenderer.utils.time_measurement |  INFO: Setup time: 198 ms

2025-04-03 08:41:51,062 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.67 seconds

2025-04-03 08:41:57,033 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:41:57,035 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.97 seconds

2025-04-03 08:41:57,246 | skyrenderer.utils.time_measurement |  INFO: Setup time: 203 ms

2025-04-03 08:41:58,980 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.73 seconds

2025-04-03 08:42:05,022 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:42:05,024 | skyrenderer.utils.time_measurement |  INFO: Render time: 6.04 seconds

2025-04-03 08:42:05,231 | skyrenderer.utils.time_measurement |  INFO: Setup time: 200 ms

2025-04-03 08:42:06,964 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.73 seconds

2025-04-03 08:42:12,533 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:42:12,535 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.57 seconds

    You can see the Unrestricted row shows all kinds of rotations, while in the Equal all scones in a given frame have
    exactly the same, randomly picked rotation. At the same time, in both rows the vertical translation is freely
    randomized - it was not included in the synchronization when preparing the bottom row, only rotation was. If you
    look closely, in each vertical pair of images the distance of each corresponding scone from the milk's surface, is
    the same. Only rotations differ. This is caused by using the same frame number for top and bottom image in each
    pair - exactly the same random values have been picked for each scone's vertical translation, in the same order.

    How to achieve this outside of this tutorial?

    You need to prepare a DrawingStrategy which consists of InputStrategies - one per each affected property that is
    to be synchronized between nodes. Only the properties indicated in inputs_strategies dict will be synchronized.
    In this case the DrawingStrategy will be passed into modify_locus_definition()

        from skyrenderer.randomization.strategy.synchronization import SynchronizationDescription
    from skyrenderer.randomization.strategy.input_drawing_strategy import EqualInStrategyInput
        synchronization = SynchronizationDescription(in_strategy=Synchronization.EQUAL)
    input_strategy = InputDrawingStrategy(
        drawing_rule=DrawingRule.RANDOM, distribution=UniformDistribution(), synchronization=synchronization
    )  # or
    input_strategy = EqualInStrategyInput()  # shorthand
    drawing_strategy = DrawingStrategy(
        scene_composer.renderer_context,
        inputs_strategies={
            "scale_x": input_strategy,
            "scale_y": input_strategy,
            "scale_z": input_strategy,
        },
    )

    In this example each frame contains sets of identically scaled scones (all round, all elongated, etc.) while their
    elevation and rotation is freely randomized.

        stp = SimpleTransformProvider(
        scene_composer.renderer_context,
        rotation_range_x=(0, 360),
        rotation_range_y=(0, 360),
        rotation_range_z=(0, 360),
        rotation_mode=RotationMode.DEGREES,
        translation_range_x=(-0.015, 0.015),
        translation_range_y=(0, 0.1),
        translation_range_z=(-0.015, 0.015),
        scale_range_x=(0.5, 3),
        scale_range_y=(0.8, 2),
        scale_range_z=(0.8, 3),
    )
    for (scone, _) in all_scones.values():
        scone.modify_locus_definition(
            transform_provider=stp,
            strategy=drawing_strategy,
        )
    renders = {}
    renders["frame=1"] = scene_composer.get_render(frame=1)
    renders["frame=2"] = scene_composer.get_render(frame=2)
    renders["frame=3"] = scene_composer.get_render(frame=3)
    scene_composer.visualize_grid_desc(renders, shape=(500, 1500), font_scale=2)
    randomization-basic-usage_10_resourcesTutorial
    2025-04-03 08:42:13,839 | skyrenderer.utils.time_measurement |  INFO: Setup time: 315 ms

2025-04-03 08:42:15,625 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.78 seconds

2025-04-03 08:42:22,356 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:42:22,358 | skyrenderer.utils.time_measurement |  INFO: Render time: 6.73 seconds

2025-04-03 08:42:22,583 | skyrenderer.utils.time_measurement |  INFO: Setup time: 216 ms

2025-04-03 08:42:24,313 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.73 seconds

2025-04-03 08:42:31,130 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:42:31,132 | skyrenderer.utils.time_measurement |  INFO: Render time: 6.82 seconds

2025-04-03 08:42:31,346 | skyrenderer.utils.time_measurement |  INFO: Setup time: 207 ms

2025-04-03 08:42:33,061 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.71 seconds

2025-04-03 08:42:38,780 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-03 08:42:38,782 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.72 seconds

    Summary

    In this section you have learnt:

    • It is recommended to use Sky Engine -provided randomization facilities instead of typical random() functions.
    • Sky Engine randomization makes it easy to control, manage, recreate and synchronize random states.
    2025-01-23_By Skyengine