### Load Mie Tables and Setup Atmospheric Conditions

Source: https://github.com/aviadlevis/pyshdom/blob/master/notebooks/Radiance Rendering [Multispectral].ipynb

Loads Mie tables for specified wavelengths, calculates solar fluxes, and sets up atmospheric profiles for droplets and air molecules. Mie tables must be pre-calculated.

```python
wavelengths = [0.672, 0.550, 0.445]
mie_table_paths = [
    '../mie_tables/polydisperse/Water_{}nm.scat'.format(shdom.int_round(wavelength)) 
    for wavelength in wavelengths
]
                                                                       
solar_spectrum = shdom.SolarSpectrum('../ancillary_data/SpectralSolar_MODWehrli_1985_WMO.npz')
solar_fluxes = solar_spectrum.get_monochrome_solar_flux(wavelengths)
solar_fluxes = solar_fluxes / max(solar_fluxes)

# Rayleigh scattering for air molecules up to 20 km
df = pd.read_csv('../ancillary_data/AFGL_summer_mid_lat.txt', comment='#', sep=' ')
altitudes = df['Altitude(km)'].to_numpy(dtype=np.float32)
temperatures = df['Temperature(k)'].to_numpy(dtype=np.float32)
temperature_profile = shdom.GridData(shdom.Grid(z=altitudes), temperatures)
air_grid = shdom.Grid(z=np.linspace(0, 20, 20))

# Generate multi-spectral scatterers for both droplets and air molecules
droplets = shdom.MicrophysicalScatterer()
droplets.load_from_csv('../synthetic_cloud_fields/jpl_les/rico32x37x26.txt', veff=0.1)
air = shdom.MultispectralScatterer()

for wavelength, table_path in zip(wavelengths, mie_table_paths):  
    # Molecular Rayleigh scattering
    rayleigh = shdom.Rayleigh(wavelength)
    rayleigh.set_profile(temperature_profile.resample(air_grid))
    air.add_scatterer(rayleigh.get_scatterer())
    
    # Droplet Mie scattering
    mie = shdom.MiePolydisperse()
    mie.read_table(table_path)
    droplets.add_mie(mie)
    
# Generate an atmospheric medium with both scatterers
atmospheric_grid = droplets.grid + air.grid
atmosphere = shdom.Medium(atmospheric_grid)
atmosphere.add_scatterer(droplets, name='cloud')
atmosphere.add_scatterer(air, name='air')

# Generate a solver array for a multispectral solution
rte_solvers = shdom.RteSolverArray()
numerical_params = shdom.NumericalParameters()
for wavelength, solar_flux in zip(wavelengths, solar_fluxes):
    scene_params = shdom.SceneParameters(
        wavelength=wavelength,
        source=shdom.SolarSource(azimuth=0, zenith=180, flux=solar_flux)  
    ) 
    rte_solver = shdom.RteSolver(scene_params, numerical_params)
    rte_solver.set_medium(atmosphere)
    rte_solvers.add_solver(rte_solver)
```

--------------------------------

### Get Help for Pyshdom Scripts

Source: https://github.com/aviadlevis/pyshdom/blob/master/README.md

This command displays the command-line flags and usage instructions for any of the pyshdom scripts. Replace 'script.py' with the actual script name.

```bash
python script.py --help
```

--------------------------------

### Install Pyshdom Distribution

Source: https://github.com/aviadlevis/pyshdom/blob/master/README.md

Installs the pyshdom package itself. Use 'install' for a standard installation or 'develop' for development mode.

```bash
python setup.py install
```

--------------------------------

### Install Required Packages with Conda

Source: https://github.com/aviadlevis/pyshdom/blob/master/README.md

Installs essential packages for pyshdom using conda. Ensure your virtual environment is activated before running this command.

```bash
conda install anaconda dill tensorflow tensorboard pillow joblib
```

--------------------------------

### Initialize Atmospheric Medium Components

Source: https://github.com/aviadlevis/pyshdom/blob/master/notebooks/Radiance Rendering [Single Image].ipynb

Loads Mie scattering tables for water droplets and initializes Rayleigh scattering for air molecules. A microphysical scatterer is created from a CSV file and combined with Mie properties. Rayleigh scattering is set up using a temperature profile.

```python
# Mie scattering for water droplets
mie = shdom.MiePolydisperse()
mie.read_table(file_path='../mie_tables/polydisperse/Water_672nm.scat')

# Generate a Microphysical medium
droplets = shdom.MicrophysicalScatterer()
droplets.load_from_csv('../synthetic_cloud_fields/jpl_les/rico32x37x26.txt', veff=0.1)
droplets.add_mie(mie)

# Rayleigh scattering for air molecules up to 20 km
df = pd.read_csv('../ancillary_data/AFGL_summer_mid_lat.txt', comment='#', sep=' ')
altitudes = df['Altitude(km)'].to_numpy(dtype=np.float32)
temperatures = df['Temperature(k)'].to_numpy(dtype=np.float32)
temperature_profile = shdom.GridData(shdom.Grid(z=altitudes), temperatures)
air_grid = shdom.Grid(z=np.linspace(0, 20, 20))
rayleigh = shdom.Rayleigh(wavelength=0.672)
rayleigh.set_profile(temperature_profile.resample(air_grid))
air = rayleigh.get_scatterer()
```

--------------------------------

### Create Monodisperse Mie Scattering Table

Source: https://github.com/aviadlevis/pyshdom/blob/master/notebooks/Make Mie Table.ipynb

Initializes a MieMonodisperse object for water particles, sets wavelength and radius integration limits, and computes the scattering table. This can take approximately 15 seconds for a max_integration_radius of 65.

```python
mie_mono = shdom.MieMonodisperse(particle_type='Water')
mie_mono.set_wavelength_integration(wavelength_band=(0.672, 0.672))   
mie_mono.set_radius_integration(minimum_effective_radius=5.0, max_integration_radius=65)

mie_mono.compute_table()
```

--------------------------------

### Define Atmosphere and Initialize RteSolver

Source: https://github.com/aviadlevis/pyshdom/blob/master/notebooks/Radiance Rendering [Multiview].ipynb

Combines cloud and air scatterers into a single atmospheric medium and initializes the RteSolver with scene and numerical parameters. This prepares the solver for radiative transfer calculations.

```python
atmospheric_grid = droplets.grid + air.grid

atmosphere = shdom.Medium(atmospheric_grid)
atmosphere.add_scatterer(droplets, name='cloud')
atmosphere.add_scatterer(air, name='air')

numerical_params = shdom.NumericalParameters()
scene_params = shdom.SceneParameters(
    wavelength=mie.wavelength,
    source=shdom.SolarSource(azimuth=65, zenith=135)
)

rte_solver = shdom.RteSolver(scene_params, numerical_params)
rte_solver.set_medium(atmosphere)

print(rte_solver.info)
```

--------------------------------

### Configure and Solve Radiative Transfer Equation

Source: https://github.com/aviadlevis/pyshdom/blob/master/notebooks/Radiance Rendering [Single Image].ipynb

Combines scatterers into an atmospheric medium and initializes the RteSolver with scene and numerical parameters. The solve() method then computes the radiative transfer solution.

```python
atmospheric_grid = droplets.grid + air.grid
atmosphere = shdom.Medium(atmospheric_grid)
atmosphere.add_scatterer(droplets, name='cloud')
atmosphere.add_scatterer(air, name='air')

numerical_params = shdom.NumericalParameters()
scene_params = shdom.SceneParameters(
    wavelength=mie.wavelength,
    source=shdom.SolarSource(azimuth=65, zenith=135)
)

rte_solver = shdom.RteSolver(scene_params, numerical_params)
rte_solver.set_medium(atmosphere)

print(rte_solver.info)

"""
Solve the Radiative Transfer for the domain using SHDOM: SOLVE_RTE procedure (src/unpolarized/shdomsub1.f).
The outputs are the source function (J) and radiance field (I) which are stored in 
the shdom.RteSolver object. These are subsequently used for the rendering of an image.
"""
rte_solver.solve(maxiter=100)
```

--------------------------------

### Load Mie Table and Microphysical Data

Source: https://github.com/aviadlevis/pyshdom/blob/master/notebooks/Radiance Rendering [Multiview].ipynb

Loads a pre-calculated Mie scattering table for water droplets and initializes a microphysical scatterer with cloud properties from a CSV file. It then adds the Mie scattering properties to the microphysical scatterer.

```python
# Mie scattering for water droplets
mie = shdom.MiePolydisperse()
mie.read_table(file_path='../mie_tables/polydisperse/Water_672nm.scat')

# Generate a Microphysical medium
droplets = shdom.MicrophysicalScatterer()
droplets.load_from_csv('../synthetic_cloud_fields/jpl_les/rico32x37x26.txt', veff=0.1)
droplets.add_mie(mie)
```

--------------------------------

### Compute Polydisperse Mie Scattering Table and Plot Results

Source: https://github.com/aviadlevis/pyshdom/blob/master/notebooks/Make Mie Table.ipynb

Initializes a MiePolydisperse object using the previously computed monodisperse table and size distribution. It then computes the polydisperse table and plots the angular scattering phase function and Legendre coefficients for specific size distribution parameters.

```python
mie_poly = shdom.MiePolydisperse(
    mono_disperse=mie_mono, 
    size_distribution=size_distribution
)
mie_poly.compute_table()

plot_re = 11.0
plot_ve = 0.1
angles = np.linspace(0,180, 360)

%matplotlib inline
f, (ax1, ax2) = plt.subplots(1, 2, figsize=(15,5));
ax1.semilogy(angles, mie_poly.get_angular_scattering(plot_re, plot_ve, angles), 'r')
ax1.set_title('Phase function (log) for reff={:2.1f} micron ; veff={:1.2}'.format(plot_re, plot_ve),);
ax2.plot(mie_poly.get_legendre(plot_re, plot_ve))
ax2.set_title('Legendre coefficients for reff={:2.1f} ; veff={:1.2}'.format(plot_re, plot_ve));
```

--------------------------------

### Create and Activate Conda Environment

Source: https://github.com/aviadlevis/pyshdom/blob/master/README.md

This snippet shows how to create a new conda virtual environment named 'pyshdom' and activate it. This is the first step for setting up the pyshdom package.

```bash
conda create -n pyshdom python=3
source activate pyshdom
```

--------------------------------

### Initialize Rayleigh Scattering and Air Medium

Source: https://github.com/aviadlevis/pyshdom/blob/master/notebooks/Radiance Rendering [Multiview].ipynb

Initializes Rayleigh scattering for air molecules using a temperature profile and creates an air scatterer object. This is used in conjunction with cloud scatterers to define the atmospheric medium.

```python
# Rayleigh scattering for air molecules up to 20 km
df = pd.read_csv('../ancillary_data/AFGL_summer_mid_lat.txt', comment='#', sep=' ')
altitudes = df['Altitude(km)'].to_numpy(dtype=np.float32)
temperatures = df['Temperature(k)'].to_numpy(dtype=np.float32)
temperature_profile = shdom.GridData(shdom.Grid(z=altitudes), temperatures)
air_grid = shdom.Grid(z=np.linspace(0, 20, 20))
rayleigh = shdom.Rayleigh(wavelength=0.672)
rayleigh.set_profile(temperature_profile.resample(air_grid))
air = rayleigh.get_scatterer()
```

--------------------------------

### Generate Mie Scattering Tables

Source: https://github.com/aviadlevis/pyshdom/blob/master/scripts/README.md

Creates Mie scattering tables for specified wavelengths and particle size distributions. Adjust start/end values and counts for desired resolution.

```sh
python scripts/generate_mie_tables.py  \
    --start_reff 4.0 --end_reff 25.0 --num_reff 50 --start_veff 0.01 --end_veff 0.2 --num veff 50 \
    --radius_cutoff 65.0 --wavelength 0.355 0.38 0.445 0.47 0.555 0.66 0.865 0.935
```

--------------------------------

### Write Polydisperse Mie Table to File

Source: https://github.com/aviadlevis/pyshdom/blob/master/notebooks/Make Mie Table.ipynb

Creates a directory if it does not exist and writes the computed polydisperse Mie scattering table to a specified file path for later use.

```python
directory = '../mie_tables/polydisperse/' 

# safe creation of the directory
if not os.path.exists(directory):
    os.makedirs(directory)
output_path = os.path.join(directory, 'Water_672nm.scat')
    
mie_poly.write_table(output_path)
```

--------------------------------

### Write Monodisperse Mie Table to File

Source: https://github.com/aviadlevis/pyshdom/blob/master/notebooks/Make Mie Table.ipynb

Creates a directory if it does not exist and writes the computed monodisperse Mie scattering table to a specified file path for later use.

```python
directory = '../mie_tables/monodisperse/'

# safe creation of the directory
if not os.path.exists(directory):
    os.makedirs(directory)
output_path = os.path.join(directory, 'Water_672nm.scat')
    
mie_mono.write_table(output_path)
```

--------------------------------

### Render Single Voxel Atmosphere (Monochromatic)

Source: https://github.com/aviadlevis/pyshdom/blob/master/scripts/README.md

Renders a single voxel atmosphere at specified view angles, resolution, and wavelength. Requires a generator and domain size.

```sh
python scripts/render_radiance_toa.py experiments/single_voxel/monochromatic 0.672\
        --generator SingleVoxel --domain_size 1.0 --x_res 0.02 --y_res 0.02 --nx 10 --ny 10 --nz 10  \
        --azimuth 90 90 90 90 0 -90 -90 -90 -90 --zenith 70.5 60 45.6 26.1 0.0 26.1 45.6 60 70.5 \
        --extinction 5.0 --reff 10.0 --add_rayleigh
```

--------------------------------

### Import Libraries for Mie Table Creation

Source: https://github.com/aviadlevis/pyshdom/blob/master/notebooks/Make Mie Table.ipynb

Imports necessary Python libraries for numerical operations, plotting, and the SHDOM package.

```python
import os 
import numpy as np
import matplotlib.pyplot as plt
import shdom
```

--------------------------------

### Render Stochastic 'Cuboid' Cloud

Source: https://github.com/aviadlevis/pyshdom/blob/master/scripts/README.md

Renders a stochastically generated 'Cuboid' cloud across multiple spectral bands. Features adjustable aspect ratio and parallelization.

```sh
python scripts/render_radiance_toa.py experiments/stochastic_cuboid/polychromatic 0.672 0.55 0.445 \
        --generator StochasticCloud --x_res 0.01 --y_res 0.01  \
        --azimuth 90 90 90 90 0 -90 -90 -90 -90 --zenith 70.5 60 45.6 26.1 0.0 26.1 45.6 60 70.5 \
        --add_rayleigh --n_jobs 40 --cloud_geometry Cuboid --domain_size 1.0 --nx 25 --ny 25 --nz 25 --beta -1.6667 \
        --lwc_mean 0.15 --lwc_snr 0.5 --reff_mean 10.0 --reff_snr 0.1 --solar_zenith 135 --aspect_ratio 2.0
```

--------------------------------

### Render Stochastic 'Blob' Cloud

Source: https://github.com/aviadlevis/pyshdom/blob/master/scripts/README.md

Renders a stochastically generated 'Blob' cloud across multiple spectral bands. Configurable with various cloud geometry and optical properties.

```sh
python scripts/render_radiance_toa.py experiments/stochastic_blob/polychromatic 0.672 0.55 0.445 \
        --generator StochasticCloud --x_res 0.01 --y_res 0.01  \
        --azimuth 90 90 90 90 0 -90 -90 -90 -90 --zenith 70.5 60 45.6 26.1 0.0 26.1 45.6 60 70.5 \
        --add_rayleigh --n_jobs 40 --cloud_geometry Blob --domain_size 1.0 --nx 25 --ny 25 --nz 25 --beta -1.6667 \
        --lwc_mean 0.15 --lwc_snr 0.5 --reff_mean 10.0 --reff_snr 0.1 --solar_zenith 135 --aspect_ratio 1.0
```

--------------------------------

### Define Sensor Array and Render Multi-view Images

Source: https://github.com/aviadlevis/pyshdom/blob/master/notebooks/Radiance Rendering [Multiview].ipynb

Defines a sensor array with specified zenith and azimuth angles, creates a multi-view projection, and renders images from a camera. Note that for small atmospheric domains, parallel rendering might be slower due to communication overhead. This snippet also includes plotting the rendered images.

```python
"""
Define a sensor array and render multi-view images of the domain. 
Note that in some cases of small atmospheric domain, parallel rendering is slower due to comunication overhead.
Plot the synthetic images.
"""
# A fly over from East to West (negative y-axis direction)
zenith_list = [70.5, 60, 45.6, 26.1, 0, 26.1, 45.6, 60, 70.5]
azimuth_list = [90, 90, 90, 90, 0, -90, -90, -90, -90]

projection = shdom.MultiViewProjection()

for zenith, azimuth in zip(zenith_list, azimuth_list):
    projection.add_projection(
        shdom.OrthographicProjection(
            bounding_box=droplets.grid.bounding_box, 
            x_resolution=0.01, 
            y_resolution=0.01, 
            azimuth=azimuth, 
            zenith=zenith,
            altitude='TOA'
        )
    )
    
camera = shdom.Camera(shdom.RadianceSensor(), projection)
images = camera.render(rte_solver, n_jobs=40)

%matplotlib inline
f, axarr = plt.subplots(1, len(images), figsize=(20, 20))
for ax, image in zip(axarr, images):
    ax.imshow(image)
    ax.invert_xaxis() 
    ax.invert_yaxis() 
    ax.axis('off')

```

--------------------------------

### Compute and Plot Size Distribution

Source: https://github.com/aviadlevis/pyshdom/blob/master/notebooks/Make Mie Table.ipynb

Computes a gamma-type size distribution using specified effective radii and variances, then plots the distribution for different parameters. Requires matplotlib for visualization.

```python
size_distribution = shdom.SizeDistribution(type='gamma')
size_distribution.set_parameters(reff=np.linspace(5.0, 25.0, 50), veff=np.linspace(0.01, 0.2, 50))
size_distribution.compute_nd(radii=mie_mono.radii, particle_density=mie_mono.pardens)

%matplotlib inline
radii = size_distribution.radii[:1000]

f, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))

reff = [8.0, 12.0, 16.0]
size_dist = size_distribution.get_nd(reff=reff, veff=0.1)[:1000]
ax1.plot(radii, size_dist)
ax1.legend(reff)
ax1.set_title('Size distribution for different effective radii [micron]', fontsize=14)
ax1.set_xlabel('radius [micron]', fontsize=12)

veff = [0.01, 0.1, 0.2]
size_dist = size_distribution.get_nd(reff=10.0, veff=veff)[:1000]
ax2.plot(radii, size_dist)
ax2.legend(veff)
ax2.set_title('Size distribution for different effective variances', fontsize=14)
ax2.set_xlabel('radius [micron]', fontsize=12)
```

--------------------------------

### Render Single Voxel Atmosphere (Polychromatic)

Source: https://github.com/aviadlevis/pyshdom/blob/master/scripts/README.md

Renders a single voxel atmosphere across multiple spectral bands. Specify wavelengths, view angles, and atmospheric properties.

```sh
python scripts/render_radiance_toa.py experiments/single_voxel/polychromatic 0.935 0.865 0.672 0.55 0.445\
        --generator SingleVoxel --nx 10 --ny 10 --nz 10 --domain_size 1.0 --x_res 0.02 --y_res 0.02 \
        --azimuth 90 90 90 90 0 -90 -90 -90 -90 --zenith 70.5 60 45.6 26.1 0.0 26.1 45.6 60 70.5 \
        --solar_zenith 165 --solar_azimuth 90 --lwc 0.135 --reff 12.3 --veff 0.1 --add_rayleigh --n_jobs 40
```

--------------------------------

### Render LES Cloud Field (Polychromatic)

Source: https://github.com/aviadlevis/pyshdom/blob/master/scripts/README.md

Renders an LES cloud field across multiple spectral bands. This command includes parallelization and Rayleigh scattering.

```sh
python scripts/render_radiance_toa.py experiments/rico32x37x26/polychromatic 0.672 0.55 0.445 \
        --generator LesFile --path synthetic_cloud_fields/jpl_les/rico32x37x26.txt --x_res 0.01 --y_res 0.01 \
        --azimuth 90 90 90 90 0 -90 -90 -90 -90 --zenith 70.5 60 45.6 26.1 0.0 26.1 45.6 60 70.5 \
        --add_rayleigh --n_jobs 40
```

--------------------------------

### Estimate Extinction with Cloud Mask

Source: https://github.com/aviadlevis/pyshdom/blob/master/scripts/README.md

Estimates extinction using ground truth phase function, grid, and cloud mask for precomputed LES measurements. Requires LES measurements and specific forward model parameters.

```sh
python scripts/optimize_extinction_lbfgs.py \
        --input_dir experiments/rico32x37x26/monochromatic --add_rayleigh \
        --use_forward_grid  --use_forward_albedo --use_forward_phase  --use_forward_mask \
        --init Homogeneous --extinction 0.01 --log log_name --n_jobs 40 
```

--------------------------------

### Import Libraries for SHDOM

Source: https://github.com/aviadlevis/pyshdom/blob/master/notebooks/Radiance Rendering [Multispectral].ipynb

Imports essential Python libraries for SHDOM operations, including plotting and data manipulation.

```python
import os 
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import shdom
```

--------------------------------

### Render LES Cloud Field (Monochromatic)

Source: https://github.com/aviadlevis/pyshdom/blob/master/scripts/README.md

Renders a Large Eddy Simulation (LES) cloud field at specified view angles, resolution, and wavelength. Supports parallelization with n_jobs.

```sh
python scripts/render_radiance_toa.py experiments/rico32x37x26/monochromatic 0.672 \
        --generator LesFile --path synthetic_cloud_fields/jpl_les/rico32x37x26.txt \
        --x_res 0.01 --y_res 0.01 --azimuth 90 90 90 90 0 -90 -90 -90 -90 --zenith 70.5 60 45.6 26.1 0.0 26.1 45.6 60 70.5 \
        --add_rayleigh --n_jobs 40
```

--------------------------------

### Estimate Effective Radius

Source: https://github.com/aviadlevis/pyshdom/blob/master/scripts/README.md

Estimates effective radius (reff) using ground-truth LWC and effective variance for precomputed single voxel measurements. Requires forward model parameters for grid, mask, LWC, and effective variance.

```sh
python scripts/optimize_microphysics_lbfgs.py \
        --input_dir experiments/single_voxel/polychromatic --add_rayleigh \
        --use_forward_grid --use_forward_mask --use_forward_lwc --use_forward_veff \
        --init Homogeneous --reff 10.0 --n_jobs 40 
```

--------------------------------

### Render Multispectral Image

Source: https://github.com/aviadlevis/pyshdom/blob/master/notebooks/Radiance Rendering [Multispectral].ipynb

Defines an orthographic projection and camera to render a multispectral image from the solved RTE data. The resulting image is then displayed using matplotlib.

```python
projection = shdom.OrthographicProjection(
    bounding_box=droplets.grid.bounding_box, 
    x_resolution=0.02, 
    y_resolution=0.02, 
    azimuth=0.0, 
    zenith=0.0,
    altitude='TOA'
)
camera = shdom.Camera(shdom.RadianceSensor(), projection)
image = camera.render(rte_solvers, n_jobs=10)

%matplotlib inline
plt.imshow(image/image.max())
plt.gca().invert_yaxis() 
plt.gca().invert_xaxis()
```

--------------------------------

### Solve Radiative Transfer Equation

Source: https://github.com/aviadlevis/pyshdom/blob/master/notebooks/Radiance Rendering [Multispectral].ipynb

Solves the Radiative Transfer Equation (RTE) for the defined atmospheric conditions using SHDOM's SOLVE_RTE procedure. This populates the RteSolver object with source and radiance fields.

```python
rte_solvers.solve(maxiter=100)
```

--------------------------------

### Estimate LWC

Source: https://github.com/aviadlevis/pyshdom/blob/master/scripts/README.md

Estimates liquid water content (LWC) using ground-truth effective radius and effective variance for precomputed single voxel measurements. Requires specific forward model parameters for grid, mask, effective radius, and effective variance.

```sh
python scripts/optimize_microphysics_lbfgs.py \
        --input_dir experiments/single_voxel/polychromatic --add_rayleigh \
        --use_forward_grid --use_forward_mask --use_forward_veff --use_forward_reff \
        --init Homogeneous --lwc 0.01 --n_jobs 40
```

--------------------------------

### Render Single Image

Source: https://github.com/aviadlevis/pyshdom/blob/master/notebooks/Radiance Rendering [Single Image].ipynb

Defines an orthographic projection and camera sensor to render an image from the solved radiative transfer data. The resulting image is displayed using matplotlib.

```python
projection = shdom.OrthographicProjection(
    bounding_box=droplets.grid.bounding_box, 
    x_resolution=0.02, 
    y_resolution=0.02, 
    azimuth=0.0, 
    zenith=0.0,
    altitude='TOA'
)
camera = shdom.Camera(shdom.RadianceSensor(), projection)
image = camera.render(rte_solver)

%matplotlib inline
plt.imshow(image)
plt.gca().invert_yaxis() 
plt.gca().invert_xaxis() 
plt.colorbar()
```

--------------------------------

### Estimate Extinction without Cloud Mask

Source: https://github.com/aviadlevis/pyshdom/blob/master/scripts/README.md

Estimates extinction using ground truth phase function and grid for precomputed LES measurements. This variant does not use a cloud mask.

```sh
python scripts/optimize_extinction_lbfgs.py \
        --input_dir experiments/rico32x37x26/monochromatic --add_rayleigh \
        --use_forward_grid  --use_forward_albedo --use_forward_phase   \
        --init Homogeneous --extinction 0.01 --radiance_threshold 0.055 --log log_name --n_jobs 40 
```

--------------------------------

### Estimate Effective Variance

Source: https://github.com/aviadlevis/pyshdom/blob/master/scripts/README.md

Estimates effective variance (veff) using ground-truth LWC and effective radius for precomputed single voxel measurements. Requires forward model parameters for grid, mask, LWC, and effective radius.

```sh
python scripts/optimize_microphysics_lbfgs.py \
        --input_dir experiments/single_voxel/polychromatic --add_rayleigh \
        --use_forward_grid --use_forward_mask --use_forward_lwc --use_forward_reff \
        --init Homogeneous --veff 0.1 --n_jobs 40 
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.