AbstractImagingSensor#

class optika.sensors.AbstractImagingSensor[source]#

Bases: AbstractSurface[None, MaterialT, RectangularAperture, RectangularAperture, None]

An interface describing an imaging sensor that can be used as the last surface in an optical system.

Attributes

`aperture`	The light-sensitive aperture of the sensor.
`aperture_mechanical`	The shape of the physical substrate containing this optical surface.
`axis_pixel`	The names of the logical axes corresponding to the rows and columns of the pixel grid.
`is_field_stop`	A flag controlling whether this surface should act as the field stop for the system
`is_pupil_stop`	A flag controlling whether this surface should act as the pupil stop for the system
`is_stop`	If this surface is pupil stop or the field stop, return `True`.
`kwargs_plot`	Extra keyword arguments that will be used in the call to `named_arrays.plt.plot()` within the `plot()` method.
`material`	The optical material type of this surface.
`name`	The human-readable name of this surface.
`num_pixel`	The number of pixels along each axis of the sensor.
`rulings`	The optional ruling profile of this surface.
`sag`	The sag profile of this surface.
`shape`	The array shape of this object.
`timedelta_exposure`	The exposure time of the sensor.
`transformation`	the coordinate transformation between the global coordinate system and this object's local coordinate system
`width_pixel`	The physical size of each pixel on the sensor.

Methods

`__init__`()
`collect`(rays, wavelength[, axis, where])	Bin a cloud of rays onto the pixel grid.
`expose`(image[, direction, axis_wavelength, ...])	Convert a per-pixel photon image into the electrons measured by the sensor.
`measure`(rays, wavelength[, axis, ...])	Bin a set of rays onto the pixel grid and convert them to the electrons measured by the sensor.
`plot`([ax, transformation, components])	Plot the selected components onto the given axes.
`propagate_rays`(rays)	Refract, reflect, and/or diffract the given rays off of this surface
`to_dxf`(file, unit[, transformation])
`to_string`([prefix])	Public-facing version of the `__repr__` method that allows for defining a prefix string, which can be used to calculate how much whitespace to add to the beginning of each line of the result.

Inheritance Diagram

collect(rays, wavelength, axis=None, where=True)[source]#

Bin a cloud of rays onto the pixel grid.

Returns the per-pixel photon image (the binned ray intensity) and the flux-weighted mean cosine of the refracted angle inside the light-sensitive region in each pixel: the two quantities expose() needs. Refracting each ray here (with its own ambient index of refraction) and binning the result is what lets expose() and the material’s signal() model be shared with systems that have no rays, without threading a separate ambient-index argument through them.

Parameters:

rays (RayVectorArray) – A set of incident rays in local coordinates to bin.
wavelength (AbstractScalar) – The edges of the wavelength bins to sample.
axis (None | str | Sequence[str]) – The logical axes along which to collect photons.
where (bool | AbstractScalar) – A boolean mask used to indicate which rays should be considered.

Return type:

tuple[FunctionArray[SpectralPositionalVectorArray, AbstractScalar], AbstractScalar]

expose(image, direction=1, axis_wavelength=None, timedelta=None, noise=True)[source]#

Convert a per-pixel photon image into the electrons measured by the sensor.

This is the detector-physics step shared by every optical system: it operates on a pixel grid (a photon image plus a refracted-cosine map), so it can be driven by collect() for a ray-traced system, or by any model that produces a per-pixel photon image directly.

The photon flux is multiplied by the exposure time and converted to electrons using signal(), which applies the quantum efficiency, noise, and charge-diffusion models.

Parameters:

image (FunctionArray[SpectralPositionalVectorArray, AbstractScalar]) – The expected photon flux incident on each pixel, as a function of wavelength and pixel position. The wavelength inputs (image.inputs.wavelength) must be the bin edges, not the centers.
direction (float | AbstractScalar) – The cosine of the refracted angle inside the light-sensitive region in each pixel, as produced by collect().
axis_wavelength (None | str) – The logical axis of image corresponding to changing wavelength. If None (the default), image.inputs.wavelength must have only one logical axis.
timedelta (None | Quantity | AbstractScalar) – The exposure time of the measurement. If None (the default), the value in timedelta_exposure will be used.
noise (bool) – Whether to add shot noise and intrinsic sensor noise to the result.

Return type:

FunctionArray[SpectralPositionalVectorArray, AbstractScalar]

measure(rays, wavelength, axis=None, axis_wavelength=None, where=True, timedelta=None, noise=True)[source]#

Bin a set of rays onto the pixel grid and convert them to the electrons measured by the sensor.

This composes collect() (gather rays into the pixel grid) with expose() (apply the detector physics).

Parameters:

rays (RayVectorArray) – A set of incident rays in local coordinates to measure.
wavelength (AbstractScalar) – The edges of the wavelength bins to sample.
axis (None | str | Sequence[str]) – The logical axes along which to collect photons.
axis_wavelength (None | str) – The logical axis of wavelength corresponding to changing wavelength coordinate, forwarded to expose(). If None (the default), wavelength must have only one logical axis.
where (bool | AbstractScalar) – A boolean mask used to indicate which rays should be considered.
timedelta (None | Quantity | AbstractScalar) – The exposure time of the measurement. If None (the default), the value in timedelta_exposure will be used.
noise (bool) – Whether to add shot noise and intrinsic sensor noise to the result.

Return type:

FunctionArray[SpectralPositionalVectorArray, AbstractScalar]

plot(ax=None, transformation=None, components=None, **kwargs)#

Plot the selected components onto the given axes.

Parameters:

ax (None | Axes | ScalarArray[ndarray[tuple[Any, ...], dtype[_ScalarT]]]) – The matplotlib axes to plot onto
transformation (None | AbstractTransformation) – Any extra transformations to apply to the coordinate system before plotting
components (None | tuple[str, ...]) – Which 3d components to plot, helpful if plotting in 2d.
kwargs – Additional keyword arguments that will be passed along to named_arrays.plt.plot()

Return type:

dict[str, AbstractScalar]

propagate_rays(rays)#

Refract, reflect, and/or diffract the given rays off of this surface

Parameters:: rays (RayVectorArray) – A set of input rays that will interact with this surface.
Return type:: RayVectorArray

to_dxf(file, unit, transformation=None)#

Parameters:

file (Path)
unit (Unit)
transformation (None | AbstractTransformation)

to_string(prefix=None)#

Public-facing version of the __repr__ method that allows for defining a prefix string, which can be used to calculate how much whitespace to add to the beginning of each line of the result.

Parameters:: prefix (None | str) – an optional string, the length of which is used to calculate how much whitespace to add to the result.
Return type:: str

property aperture#: The light-sensitive aperture of the sensor.

abstract property aperture_mechanical: ApertureMechanicalT#: The shape of the physical substrate containing this optical surface.

abstract property axis_pixel: Cartesian2dVectorArray[str, str]#: The names of the logical axes corresponding to the rows and columns of the pixel grid.

abstract property is_field_stop: bool#: A flag controlling whether this surface should act as the field stop for the system

abstract property is_pupil_stop: bool#: A flag controlling whether this surface should act as the pupil stop for the system

property is_stop: bool#: If this surface is pupil stop or the field stop, return True.

abstract property kwargs_plot: None | dict#: Extra keyword arguments that will be used in the call to named_arrays.plt.plot() within the plot() method.

abstract property material: MaterialT#: The optical material type of this surface.

abstract property name: str#: The human-readable name of this surface.

abstract property num_pixel: Cartesian2dVectorArray[int, int]#: The number of pixels along each axis of the sensor.

property rulings: None#: The optional ruling profile of this surface.

property sag: AbstractSag#: The sag profile of this surface.

abstract property shape: dict[str, int]#: The array shape of this object.

abstract property timedelta_exposure: Quantity | AbstractScalar#: The exposure time of the sensor.

abstract property transformation: None | AbstractTransformation#: the coordinate transformation between the global coordinate system and this object’s local coordinate system

abstract property width_pixel: Quantity | AbstractCartesian2dVectorArray#: The physical size of each pixel on the sensor.