[1]:

%reload_ext eradiate.tutorials

Last updated: 2025-08-28 18:02 (eradiate v0.31.0.dev1)

3D simulation basics¶

Overview

In this tutorial, we introduce basic 3D simulation features. Eradiate is intrinsically a 3D radiative transfer model, and a lot of workflows and concepts introduced here are applicable to 1D simulations as well.

Prerequisites

Ability to run 1D simulations and visualize the results (see First steps with Eradiate).

What you will learn

How to set up and visualize a 3D scene.
How to compute the reflectance of a complex surface without an atmosphere.

We start by activating the IPython extension and importing and aliasing a few useful components. We also select the monochromatic mode.

[2]:

%load_ext eradiate

import eradiate
import matplotlib.pyplot as plt
import numpy as np
from eradiate import scenes as ertsc
from eradiate import unit_registry as ureg

eradiate.set_mode("mono")

We set the computational mode to monochromatic, since we will be simulating scenes without atmospheres. Hence the correlated-k distribution method will not be useful here.

Next we set up convenience functions for plotting BRF results and visualizing camera renders.

[3]:

def show_camera(
    exp,
    measure_id,
    robust=True,
    add_colorbar=False,
    vmin=None,
    vmax=None,
):
    """
    Display the output of a monochromatic camera measure.
    """
    _, ax = plt.subplots(1, 1)
    exp.results[measure_id]["radiance"].squeeze(drop=True).plot.imshow(
        ax=ax,
        origin="upper",
        cmap="Greys_r",
        vmin=vmin,
        vmax=vmax,
        robust=robust,
        add_colorbar=add_colorbar,
    )
    ax.set_aspect(1)  # Ensures that pixels are represented as squares
    plt.show()
    plt.close()

def show_brf(exp, measure_id):
    """
    Display the BRF output of a distant radiance measure.
    """
    _, ax = plt.subplots(1, 1)
    exp.results[measure_id]["brf"].squeeze(drop=True).plot(
        ax=ax, x="vza", linestyle=":", marker="."
    )
    plt.show()
    plt.close()

First 3D scene visualizzzzzn ---------------------------- We start by creating a simple scene consisting only of a rectangular surface with Lambertian reflectance. Here, we must specify the horizontal extent of the surface because no parent scene element will constrain it. As soon as a canopy is assigned, this is no longer required (see below). **Note:** We use the Eradiate unit registry ``ureg`` to attach the unit *meter* to the surface's edge length.

[4]:

lambertian_surface=ertsc.surface.BasicSurface(
    shape=ertsc.shapes.RectangleShape(edges=10.0 * ureg.m),
    bsdf=ertsc.bsdfs.LambertianBSDF(reflectance=0.5),
)

Next, we create a perspective camera to visualize the surface.

[5]:

camera_oblique = ertsc.measure.PerspectiveCameraMeasure(
    id="camera_oblique",
    origin=[15, 15, 15] * ureg.m,
    target=[0, 0, 0] * ureg.m,
    up=[0, 0, 1],
    film_resolution=(320, 240),
    spp=512,
)

Now we create the experiment object. We use the CanopyExperiment class, specialised to handle 3D surface geometry without atmosphere. The illumination and canopy parameters are left to their default values: no canopy will be added above the surface, and the illumination will be directional, oriented towards the nadir.

[6]:

exp = eradiate.experiments.CanopyExperiment(
    surface=lambertian_surface,
    measures=camera_oblique,
)

We run the simulation and use the convenience function defined above to visualize the result.

[7]:

eradiate.run(exp)
show_camera(exp, "camera_oblique")

../../_images/tutorials_getting_started_3d_basics_13_1.png

Final words¶

This was just a quick overview of Eradiate’s 3D simulation features. This simple example can be expanded, for instance by computing the top-of-canopy reflectance of the canopy in the principal plane with different padding values to assess which amount of padding is required to converge to a periodic behaviour.

3D simulation basics¶

Adding a canopy¶

Final words¶

Further reading¶