yt.visualization.volume_rendering.off_axis_projection module

yt.visualization.volume_rendering.off_axis_projection.off_axis_projection(data_source, center, normal_vector, width, resolution, item, weight=None, volume=None, no_ghost=False, interpolated=False, north_vector=None, depth=None, num_threads=1, method='integrate')[source]

Project through a dataset, off-axis, and return the image plane.

This function will accept the necessary items to integrate through a volume at an arbitrary angle and return the integrated field of view to the user. Note that if a weight is supplied, it will multiply the pre-interpolated values together, then create cell-centered values, then interpolate within the cell to conduct the integration.

Parameters:

  • data_source (Dataset) – or ~yt.data_objects.data_containers.YTSelectionDataContainer This is the dataset or data object to volume render.

  • center (array_like) – The current ‘center’ of the view port – the focal point for the camera.

  • normal_vector (array_like) – The vector between the camera position and the center.

  • width (float or list of floats) – The current width of the image. If a single float, the volume is cubical, but if not, it is left/right, top/bottom, front/back

  • resolution (int or list of ints) – The number of pixels in each direction.

  • item (string) – The field to project through the volume

  • weight (optional, default None) – If supplied, the field will be pre-multiplied by this, then divided by the integrated value of this field. This returns an average rather than a sum.

  • volume (yt.extensions.volume_rendering.AMRKDTree, optional) – The volume to ray cast through. Can be specified for finer-grained control, but otherwise will be automatically generated.

  • no_ghost (bool, optional) – Optimization option. If True, homogenized bricks will extrapolate out from grid instead of interpolating from ghost zones that have to first be calculated. This can lead to large speed improvements, but at a loss of accuracy/smoothness in resulting image. The effects are less notable when the transfer function is smooth and broad. Default: True

  • interpolated (optional, default False) – If True, the data is first interpolated to vertex-centered data, then tri-linearly interpolated along the ray. Not suggested for quantitative studies.

  • north_vector (optional, array_like, default None) – A vector that, if specified, restricts the orientation such that the north vector dotted into the image plane points “up”. Useful for rotations

  • depth (float, tuple[float, str], or unyt_array of size 1.) – specify the depth of the projection region (size along the line of sight). If no units are given (unyt_array or second tuple element), code units are assumed.

  • num_threads (integer, optional, default 1) – Use this many OpenMP threads during projection.

  • method (string) –

    The method of projection. Valid methods are:

    ”integrate” with no weight_field specified : integrate the requested field along the line of sight.

    ”integrate” with a weight_field specified : weight the requested field by the weighting field and integrate along the line of sight.

    ”sum” : This method is the same as integrate, except that it does not multiply by a path length when performing the integration, and is just a straight summation of the field along the given axis. WARNING: This should only be used for uniform resolution grid datasets, as other datasets may result in unphysical images. or camera movements.

Returns:

image – An (N,N) array of the final integrated values, in float64 form.

Return type:

array

Examples

>>> image = off_axis_projection(
...     ds,
...     [0.5, 0.5, 0.5],
...     [0.2, 0.3, 0.4],
...     0.2,
...     N,
...     ("gas", "temperature"),
...     ("gas", "density"),
... )
>>> write_image(np.log10(image), "offaxis.png")