Randomization - Basic Usage

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

Agenda:

Using SKY ENGINE AI'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-10 16:10:59,935 | 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-10 16:11:00,210 | 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-10 16:11:00,215 | 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-10 16:11:03,070 | skyrenderer.utils.time_measurement |  INFO: Setup time: 2.85 seconds

2025-04-10 16:11:03,274 | skyrenderer.utils.time_measurement |  INFO: Setup time: 187 ms

2025-04-10 16:11:04,933 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.66 seconds

2025-04-10 16:11:12,685 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-10 16:11:12,687 | skyrenderer.utils.time_measurement |  INFO: Render time: 7.75 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-10 16:11:13,591 | skyrenderer.utils.time_measurement |  INFO: Setup time: 199 ms

2025-04-10 16:11:15,240 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.65 seconds

2025-04-10 16:11:20,612 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-10 16:11:20,615 | skyrenderer.utils.time_measurement |  INFO: Render time: 5.37 seconds

That looks more natural.

Using SKY ENGINE AI'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-10 16:11:21,533 | skyrenderer.utils.time_measurement |  INFO: Setup time: 208 ms

2025-04-10 16:11:23,228 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.69 seconds

2025-04-10 16:11:24,563 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:11:24,565 | skyrenderer.utils.time_measurement |  INFO: Render time: 1.34 seconds

2025-04-10 16:11:24,791 | skyrenderer.utils.time_measurement |  INFO: Setup time: 212 ms

2025-04-10 16:11:26,485 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.69 seconds

2025-04-10 16:11:27,794 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:11:27,796 | skyrenderer.utils.time_measurement |  INFO: Render time: 1.31 seconds

2025-04-10 16:11:28,005 | skyrenderer.utils.time_measurement |  INFO: Setup time: 194 ms

2025-04-10 16:11:29,674 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.67 seconds

2025-04-10 16:11:31,030 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:11:31,032 | skyrenderer.utils.time_measurement |  INFO: Render time: 1.36 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 AI 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 AI 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-10 16:11:31,656 | skyrenderer.utils.time_measurement |  INFO: Setup time: 219 ms

2025-04-10 16:11:33,420 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.76 seconds

2025-04-10 16:11:35,606 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:11:35,608 | skyrenderer.utils.time_measurement |  INFO: Render time: 2.19 seconds

2025-04-10 16:11:35,817 | skyrenderer.utils.time_measurement |  INFO: Setup time: 202 ms

2025-04-10 16:11:37,450 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.63 seconds

2025-04-10 16:11:38,771 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-10 16:11:38,773 | skyrenderer.utils.time_measurement |  INFO: Render time: 1.32 seconds

2025-04-10 16:11:38,993 | skyrenderer.utils.time_measurement |  INFO: Setup time: 209 ms

2025-04-10 16:11:40,666 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.67 seconds

2025-04-10 16:11:42,815 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:11:42,817 | skyrenderer.utils.time_measurement |  INFO: Render time: 2.15 seconds

You can see that all images are identical, despite us having called the randomization 3 separate times. If you're
feeling adventurous, you can save these images to your drive and analyze them with 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-10 16:11:43,248 | skyrenderer.utils.time_measurement |  INFO: Setup time: 203 ms

2025-04-10 16:11:44,919 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.67 seconds

2025-04-10 16:11:47,131 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:11:47,133 | skyrenderer.utils.time_measurement |  INFO: Render time: 2.21 seconds

2025-04-10 16:11:47,344 | skyrenderer.utils.time_measurement |  INFO: Setup time: 202 ms

2025-04-10 16:11:49,015 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.67 seconds

2025-04-10 16:11:51,132 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:11:51,133 | skyrenderer.utils.time_measurement |  INFO: Render time: 2.12 seconds

2025-04-10 16:11:51,342 | skyrenderer.utils.time_measurement |  INFO: Setup time: 202 ms

2025-04-10 16:11:53,109 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.77 seconds

2025-04-10 16:11:55,130 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:11:55,132 | skyrenderer.utils.time_measurement |  INFO: Render time: 2.02 seconds

2025-04-10 16:11:55,338 | skyrenderer.utils.time_measurement |  INFO: Setup time: 199 ms

2025-04-10 16:11:56,968 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.63 seconds

2025-04-10 16:11:59,113 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:11:59,115 | skyrenderer.utils.time_measurement |  INFO: Render time: 2.15 seconds

2025-04-10 16:11:59,324 | skyrenderer.utils.time_measurement |  INFO: Setup time: 201 ms

2025-04-10 16:12:00,930 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.60 seconds

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

2025-04-10 16:12:02,960 | skyrenderer.utils.time_measurement |  INFO: Render time: 2.03 seconds

2025-04-10 16:12:03,166 | skyrenderer.utils.time_measurement |  INFO: Setup time: 199 ms

2025-04-10 16:12:04,778 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.61 seconds

2025-04-10 16:12:06,765 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:12:06,766 | skyrenderer.utils.time_measurement |  INFO: Render time: 1.99 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-10 16:12:08,028 | skyrenderer.utils.time_measurement |  INFO: Setup time: 290 ms

2025-04-10 16:12:09,637 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.61 seconds

2025-04-10 16:12:11,083 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:12:11,085 | skyrenderer.utils.time_measurement |  INFO: Render time: 1.45 seconds

2025-04-10 16:12:11,288 | skyrenderer.utils.time_measurement |  INFO: Setup time: 195 ms

2025-04-10 16:12:12,900 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.61 seconds

2025-04-10 16:12:14,344 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:12:14,346 | skyrenderer.utils.time_measurement |  INFO: Render time: 1.44 seconds

2025-04-10 16:12:14,550 | skyrenderer.utils.time_measurement |  INFO: Setup time: 198 ms

2025-04-10 16:12:16,177 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.63 seconds

2025-04-10 16:12:17,717 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:12:17,718 | skyrenderer.utils.time_measurement |  INFO: Render time: 1.54 seconds

Distribution: Uniform vs Gaussian

When SKY ENGINE AI 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
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-10 16:12:18,426 | skyrenderer.utils.time_measurement |  INFO: Setup time: 203 ms

2025-04-10 16:12:20,046 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.62 seconds

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

2025-04-10 16:12:22,123 | skyrenderer.utils.time_measurement |  INFO: Render time: 2.08 seconds

2025-04-10 16:12:22,333 | skyrenderer.utils.time_measurement |  INFO: Setup time: 202 ms

2025-04-10 16:12:23,957 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.62 seconds

2025-04-10 16:12:25,331 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:12:25,333 | skyrenderer.utils.time_measurement |  INFO: Render time: 1.37 seconds

2025-04-10 16:12:25,538 | skyrenderer.utils.time_measurement |  INFO: Setup time: 198 ms

2025-04-10 16:12:27,166 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.63 seconds

2025-04-10 16:12:28,551 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:12:28,552 | skyrenderer.utils.time_measurement |  INFO: Render time: 1.39 seconds

2025-04-10 16:12:28,760 | skyrenderer.utils.time_measurement |  INFO: Setup time: 200 ms

2025-04-10 16:12:30,384 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.62 seconds

2025-04-10 16:12:31,825 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:12:31,826 | skyrenderer.utils.time_measurement |  INFO: Render time: 1.44 seconds

2025-04-10 16:12:32,033 | skyrenderer.utils.time_measurement |  INFO: Setup time: 200 ms

2025-04-10 16:12:33,659 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.62 seconds

2025-04-10 16:12:35,063 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-10 16:12:35,065 | skyrenderer.utils.time_measurement |  INFO: Render time: 1.40 seconds

2025-04-10 16:12:35,362 | skyrenderer.utils.time_measurement |  INFO: Setup time: 290 ms

2025-04-10 16:12:36,988 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.62 seconds

2025-04-10 16:12:39,195 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:12:39,197 | skyrenderer.utils.time_measurement |  INFO: Render time: 2.21 seconds

You can see that the Uniform row shows all kinds of rotations, while in the Gaussian row most of the scones tend to be
oriented 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-10 16:12:40,368 | skyrenderer.utils.time_measurement |  INFO: Setup time: 202 ms

2025-04-10 16:12:41,982 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.61 seconds

2025-04-10 16:12:43,440 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:12:43,442 | skyrenderer.utils.time_measurement |  INFO: Render time: 1.46 seconds

2025-04-10 16:12:43,650 | skyrenderer.utils.time_measurement |  INFO: Setup time: 201 ms

2025-04-10 16:12:45,283 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.63 seconds

2025-04-10 16:12:47,479 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:12:47,480 | skyrenderer.utils.time_measurement |  INFO: Render time: 2.20 seconds

2025-04-10 16:12:47,686 | skyrenderer.utils.time_measurement |  INFO: Setup time: 198 ms

2025-04-10 16:12:49,318 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.63 seconds

2025-04-10 16:12:50,754 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:12:50,755 | skyrenderer.utils.time_measurement |  INFO: Render time: 1.44 seconds

More Distributions

Learn about other types of Distributions available in SKY ENGINE AI 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-10 16:12:51,448 | skyrenderer.utils.time_measurement |  INFO: Setup time: 201 ms

2025-04-10 16:12:53,078 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.63 seconds

2025-04-10 16:12:55,363 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:12:55,364 | skyrenderer.utils.time_measurement |  INFO: Render time: 2.29 seconds

2025-04-10 16:12:55,569 | skyrenderer.utils.time_measurement |  INFO: Setup time: 198 ms

2025-04-10 16:12:57,194 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.62 seconds

2025-04-10 16:12:59,480 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:12:59,481 | skyrenderer.utils.time_measurement |  INFO: Render time: 2.29 seconds

2025-04-10 16:12:59,688 | skyrenderer.utils.time_measurement |  INFO: Setup time: 199 ms

2025-04-10 16:13:01,314 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.62 seconds

2025-04-10 16:13:02,823 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 1 ms

2025-04-10 16:13:02,826 | skyrenderer.utils.time_measurement |  INFO: Render time: 1.51 seconds

2025-04-10 16:13:03,031 | skyrenderer.utils.time_measurement |  INFO: Setup time: 198 ms

2025-04-10 16:13:04,645 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.61 seconds

2025-04-10 16:13:06,843 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:13:06,844 | skyrenderer.utils.time_measurement |  INFO: Render time: 2.20 seconds

2025-04-10 16:13:07,135 | skyrenderer.utils.time_measurement |  INFO: Setup time: 284 ms

2025-04-10 16:13:08,741 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.60 seconds

2025-04-10 16:13:10,997 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:13:10,998 | skyrenderer.utils.time_measurement |  INFO: Render time: 2.26 seconds

2025-04-10 16:13:11,201 | skyrenderer.utils.time_measurement |  INFO: Setup time: 195 ms

2025-04-10 16:13:12,806 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.60 seconds

2025-04-10 16:13:14,350 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:13:14,352 | skyrenderer.utils.time_measurement |  INFO: Render time: 1.54 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-10 16:13:15,542 | skyrenderer.utils.time_measurement |  INFO: Setup time: 198 ms

2025-04-10 16:13:17,169 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.63 seconds

2025-04-10 16:13:19,604 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:13:19,606 | skyrenderer.utils.time_measurement |  INFO: Render time: 2.43 seconds

2025-04-10 16:13:19,811 | skyrenderer.utils.time_measurement |  INFO: Setup time: 197 ms

2025-04-10 16:13:21,652 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.84 seconds

2025-04-10 16:13:24,051 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:13:24,052 | skyrenderer.utils.time_measurement |  INFO: Render time: 2.40 seconds

2025-04-10 16:13:24,257 | skyrenderer.utils.time_measurement |  INFO: Setup time: 198 ms

2025-04-10 16:13:25,880 | skyrenderer.utils.time_measurement |  INFO: Context update time: 1.62 seconds

2025-04-10 16:13:28,301 | skyrenderer.utils.time_measurement |  INFO: Key points calculation time: 0 ms

2025-04-10 16:13:28,303 | skyrenderer.utils.time_measurement |  INFO: Render time: 2.42 seconds

Summary

In this section you have learnt:

It is recommended to use SKY ENGINE AI-provided randomization facilities instead of typical random() functions.
SKY ENGINE AI randomization makes it easy to control, manage, recreate and synchronize random states.