PfmFile

from panda3d.core import PfmFile

class PfmFile

Bases:

Bases: PNMImageHeader

Defines a pfm file, a 2-d table of floating-point numbers, either 3-component or 1-component, or with a special extension, 2- or 4-component.

Inheritance diagram

__getbuffer__(view: Py_buffer, flags: int) → int

__imul__(multiplier: float) → PfmFile

__init__()

__init__(copy: PfmFile)

add_sub_image(copy: PfmFile, xto: int, yto: int, xfrom: int, yfrom: int, x_size: int, y_size: int, pixel_scale: float): Behaves like copy_sub_image(), except the copy pixels are added to the pixels of the destination, after scaling by the specified pixel_scale.

apply_1d_lut(channel: int, lut: PfmFile, x_scale: float): Assumes that lut is an X by 1, 1-component PfmFile whose X axis maps points to target points. For each point in this pfm file, computes: p(u, v)[channel] = lut(p(u, v)[channel] * x_scale, 0)[0]

apply_crop(x_begin: int, x_end: int, y_begin: int, y_end: int): Reduces the PFM file to the cells in the rectangle bounded by (x_begin, x_end, y_begin, y_end), where the _end cells are not included.

apply_exponent(gray_exponent: float): Adjusts each channel of the image by raising the corresponding component value to the indicated exponent, such that L’ = L ^ exponent.

apply_exponent(gray_exponent: float, alpha_exponent: float): Adjusts each channel of the image by raising the corresponding component value to the indicated exponent, such that L’ = L ^ exponent.

apply_exponent(c0_exponent: float, c1_exponent: float, c2_exponent: float): Adjusts each channel of the image by raising the corresponding component value to the indicated exponent, such that L’ = L ^ exponent. For a grayscale image, the blue_exponent value is used for the grayscale value, and red_exponent and green_exponent are unused.

apply_exponent(c0_exponent: float, c1_exponent: float, c2_exponent: float, c3_exponent: float): Adjusts each channel of the image by raising the corresponding component value to the indicated exponent, such that L’ = L ^ exponent.

apply_mask(other: PfmFile)

Wherever there is missing data in the other PfmFile, set this the corresponding point in this PfmFile to missing as well, so that this PfmFile has only points where both files have points.

The point is set to “missing” by setting it the no_data_value.

assign(copy: PfmFile) → PfmFile

box_filter_from(radius: float, copy: PfmFile): Makes a resized copy of the indicated image into this one using the indicated filter. The image to be copied is squashed and stretched to match the dimensions of the current image, applying the appropriate filter to perform the stretching.

calc_autocrop(range: LVecBase4d) → bool: Computes the minimum range of x and y across the PFM file that include all points. If there are no points with no_data_value in the grid–that is, all points are included–then this will return (0, get_x_size(), 0, get_y_size()).

calc_autocrop(range: LVecBase4f) → bool: Computes the minimum range of x and y across the PFM file that include all points. If there are no points with no_data_value in the grid–that is, all points are included–then this will return (0, get_x_size(), 0, get_y_size()).

calc_average_point(result: LPoint3f, x: float, y: float, radius: float) → bool: Computes the unweighted average point of all points within the box centered at (x, y) with the indicated Manhattan-distance radius. Missing points are assigned the value of their nearest neighbor. Returns true if successful, or false if the point value cannot be determined.

calc_bilinear_point(result: LPoint3f, x: float, y: float) → bool: Computes the weighted average of the four nearest points to the floating- point index (x, y). Returns true if the point has any contributors, false if the point is unknown.

calc_min_max(min_points: LVecBase3f, max_points: LVecBase3f) → bool: Calculates the minimum and maximum x, y, and z depth component values, representing the bounding box of depth values, and places them in the indicated vectors. Returns true if successful, false if the mesh contains no points.

calc_tight_bounds(min_point: LPoint3f, max_point: LPoint3f) → bool

Calculates the minimum and maximum vertices of all points within the table. Assumes the table contains 3-D points.

The return value is true if any points in the table, or false if none are.

clear(): Eliminates all data in the file.

clear(x_size: int, y_size: int, num_channels: int): Resets to an empty table with a specific size. The case of num_channels == 0 is allowed only in the case that x_size and y_size are also == 0; and this makes an empty (and invalid) PfmFile.

clear_no_data_value(): Removes the special value that means “no data” when it appears in the pfm file. All points will thus be considered valid.

clear_to_texcoords(x_size: int, y_size: int): Replaces this PfmFile with a new PfmFile of size x_size x y_size x 3, containing the x y 0 values in the range 0 .. 1 according to the x y index.

compute_planar_bounds(center: LPoint2d, point_dist: float, sample_radius: float, points_only: bool) → BoundingHexahedron

Computes the minmax bounding volume of the points in 3-D space, assuming the points represent a mostly-planar surface.

This algorithm works by sampling the (square) sample_radius pixels at the four point_dist corners around the center (cx - pd, cx + pd) and so on, to approximate the plane of the surface. Then all of the points are projected into that plane and the bounding volume of the entire mesh within that plane is determined. If points_only is true, the bounding volume of only those four points is determined.

center, point_dist and sample_radius are in UV space, i.e. in the range 0..1.

compute_planar_bounds(center: LPoint2f, point_dist: float, sample_radius: float, points_only: bool) → BoundingHexahedron

Computes the minmax bounding volume of the points in 3-D space, assuming the points represent a mostly-planar surface.

This algorithm works by sampling the (square) sample_radius pixels at the four point_dist corners around the center (cx - pd, cx + pd) and so on, to approximate the plane of the surface. Then all of the points are projected into that plane and the bounding volume of the entire mesh within that plane is determined. If points_only is true, the bounding volume of only those four points is determined.

center, point_dist and sample_radius are in UV space, i.e. in the range 0..1.

compute_sample_point(result: LPoint3f, x: float, y: float, sample_radius: float)

Computes the average of all the point within sample_radius (manhattan distance) and the indicated point.

The point coordinates are given in UV space, in the range 0..1.

copy_channel(to_channel: int, other: PfmFile, from_channel: int): Copies just the specified channel values from the indicated PfmFile (which could be same as this PfmFile) into the specified channel of this one.

copy_channel_masked(to_channel: int, other: PfmFile, from_channel: int): Copies just the specified channel values from the indicated PfmFile, but only where the other file has a data point.

copy_sub_image(copy: PfmFile, xto: int, yto: int, xfrom: int, yfrom: int, x_size: int, y_size: int): Copies a rectangular area of another image into a rectangular area of this image. Both images must already have been initialized. The upper-left corner of the region in both images is specified, and the size of the area; if the size is omitted, it defaults to the entire other image, or the largest piece that will fit.

divide_sub_image(copy: PfmFile, xto: int, yto: int, xfrom: int, yfrom: int, x_size: int, y_size: int, pixel_scale: float): Behaves like copy_sub_image(), except the copy pixels are divided into the pixels of the destination, after scaling by the specified pixel_scale. dest(x, y) = dest(x, y) / (copy(x, y) * pixel_scale).

fill(value: LPoint2f): Fills the table with all of the same value.

fill(value: LPoint3f): Fills the table with all of the same value.

fill(value: LPoint4f): Fills the table with all of the same value.

fill(value: float): Fills the table with all of the same value.

fill_channel(channel: int, value: float): Fills the indicated channel with all of the same value, leaving the other channels unchanged.

fill_channel_masked(channel: int, value: float): Fills the indicated channel with all of the same value, but only where the table already has a data point. Leaves empty points unchanged.

fill_channel_masked_nan(channel: int): Fills the indicated channel with NaN, but only where the table already has a data point. Leaves empty points unchanged.

fill_channel_nan(channel: int): Fills the indicated channel with NaN, leaving the other channels unchanged.

fill_nan(): Fills the table with all NaN.

fill_no_data_value(): Fills the table with the current no_data value, so that the table is empty.

flip(flip_x: bool, flip_y: bool, transpose: bool): Reverses, transposes, and/or rotates the table in-place according to the specified parameters. If flip_x is true, the x axis is reversed; if flip_y is true, the y axis is reversed. Then, if transpose is true, the x and y axes are exchanged. These parameters can be used to select any combination of 90-degree or 180-degree rotations and flips.

forward_distort(dist: PfmFile, scale_factor: float)

Applies the distortion indicated in the supplied dist map to the current map. The dist map is understood to be a mapping of points in the range 0..1 in the first two dimensions.

The operation can be expressed symbolically as:

this(u, v) = this(dist(u, v))

If scale_factor is not 1, it should be a value > 1, and it specifies the factor to upscale the working table while processing, to reduce artifacts from integer truncation.

By convention, the y axis is inverted in the distortion map relative to the coordinates here. A y value of 0 in the distortion map corresponds with a v value of 1 in this file.

gamma_correct(from_gamma: float, to_gamma: float): Assuming the image was constructed with a gamma curve of from_gamma in the RGB channels, converts it to an image with a gamma curve of to_gamma in the RGB channels. Does not affect the alpha channel.

gamma_correct_alpha(from_gamma: float, to_gamma: float): Assuming the image was constructed with a gamma curve of from_gamma in the alpha channel, converts it to an image with a gamma curve of to_gamma in the alpha channel. Does not affect the RGB channels.

gaussian_filter_from(radius: float, copy: PfmFile): Makes a resized copy of the indicated image into this one using the indicated filter. The image to be copied is squashed and stretched to match the dimensions of the current image, applying the appropriate filter to perform the stretching.

get_channel(x: int, y: int, c: int) → float: Returns the cth channel of the point value at the indicated point.

get_no_data_value() → LPoint4f: If has_no_data_value() returns true, this returns the particular “no data” value.

get_point(x: int, y: int) → LPoint3f: Returns the 3-component point value at the indicated point. In a 1-channel image, the channel value is in the x component.

get_point1(x: int, y: int) → float: Returns the 1-component point value at the indicated point.

get_point2(x: int, y: int) → LPoint2f: Returns the 2-component point value at the indicated point. In a 1-channel image, the channel value is in the x component.

get_point3(x: int, y: int) → LPoint3f: Returns the 3-component point value at the indicated point. In a 1-channel image, the channel value is in the x component.

get_point4(x: int, y: int) → LPoint4f: Returns the 4-component point value at the indicated point. In a 1-channel image, the channel value is in the x component.

get_points() → object

get_scale() → float: The “scale” is reported in the pfm header and is probably meaningless.

has_no_data_threshold() → bool: Returns whether a “no data” threshold value has been established by set_no_data_threshold().

has_no_data_value() → bool: Returns whether a “no data” value has been established by set_no_data_value().

has_point(x: int, y: int) → bool: Returns true if there is a valid point at x, y. This always returns true unless a “no data” value has been set, in which case it returns false if the point at x, y is the “no data” value.

indirect_1d_lookup(index_image: PfmFile, channel: int, pixel_values: PfmFile)

index_image is a WxH 1-channel image, while pixel_values is an Nx1 image with any number of channels. Typically pixel_values will be a 256x1 image.

Fills the PfmFile with a new image the same width and height as index_image, with the same number of channels as pixel_values.

Each pixel of the new image is computed with the formula:

new_image(x, y) = pixel_values(index_image(x, y)[channel], 0)

At present, no interpolation is performed; the nearest value in pixel_values is discovered. This may change in the future.

is_column_empty(x: int, y_begin: int, y_end: int) → bool: Returns true if all of the points on column x, from [y_begin, y_end), are the no_data value, or false if any one of these points has a value.

is_row_empty(y: int, x_begin: int, x_end: int) → bool: Returns true if all of the points on row y, in the range [x_begin, x_end), are the no_data value, or false if any one of these points has a value.

is_valid() → bool

load(pnmimage: PNMImage) → bool: Fills the PfmFile with the data from the indicated PNMImage, converted to floating-point values.

merge(other: PfmFile): Wherever there is missing data in this PfmFile (that is, wherever has_point() returns false), copy data from the other PfmFile, which must be exactly the same dimensions as this one.

modify_point(x: int, y: int) → LPoint3f: Returns a modifiable 3-component point value at the indicated point.

modify_point2(x: int, y: int) → LPoint2f: Returns a modifiable 2-component point value at the indicated point.

modify_point3(x: int, y: int) → LPoint3f: Returns a modifiable 3-component point value at the indicated point.

modify_point4(x: int, y: int) → LPoint4f: Returns a modifiable 4-component point value at the indicated point.

mult_sub_image(copy: PfmFile, xto: int, yto: int, xfrom: int, yfrom: int, x_size: int, y_size: int, pixel_scale: float): Behaves like copy_sub_image(), except the copy pixels are multiplied to the pixels of the destination, after scaling by the specified pixel_scale.

output(out: ostream)

pull_spot(delta: LPoint4f, xc: float, yc: float, xr: float, yr: float, exponent: float) → int: Applies delta * t to the point values within radius (xr, yr) distance of (xc, yc). The t value is scaled from 1.0 at the center to 0.0 at radius (xr, yr), and this scale follows the specified exponent. Returns the number of points affected.

quick_filter_from(copy: PfmFile): Resizes from the given image, with a fixed radius of 0.5. This is a very specialized and simple algorithm that doesn’t handle dropping below the Nyquist rate very well, but is quite a bit faster than the more general box_filter(), above.

read(fullpath: Filename) → bool

Reads the PFM data from the indicated file, returning true on success, false on failure.

This can also handle reading a standard image file supported by PNMImage; it will be quietly converted to a floating-point type.

read(reader: PNMReader) → bool

Reads the PFM data using the indicated PNMReader.

The PNMReader is always deleted upon completion, whether successful or not.

read(in: istream, fullpath: Filename) → bool

Reads the PFM data from the indicated stream, returning true on success, false on failure.

This can also handle reading a standard image file supported by PNMImage; it will be quietly converted to a floating-point type.

resize(new_x_size: int, new_y_size: int): Applies a simple filter to resample the pfm file in-place to the indicated size. Don’t confuse this with applying a scale to all of the points via xform().

reverse_distort(dist: PfmFile, scale_factor: float)

Applies the distortion indicated in the supplied dist map to the current map. The dist map is understood to be a mapping of points in the range 0..1 in the first two dimensions.

The operation can be expressed symbolically as:

this(u, v) = dist(this(u, v))

If scale_factor is not 1, it should be a value > 1, and it specifies the factor to upscale the working table while processing, to reduce artifacts from integer truncation.

By convention, the y axis in inverted in the distortion map relative to the coordinates here. A y value of 0 in the distortion map corresponds with a v value of 1 in this file.

reverse_rows(): Performs an in-place reversal of the row (y) data.

property scale → float: The “scale” is reported in the pfm header and is probably meaningless.

set_channel(x: int, y: int, c: int, value: float): Replaces the cth channel of the point value at the indicated point.

set_no_data_chan4(chan4: bool)

Sets the no_data_chan4 flag. When this flag is true, and the pfm file has 4 channels, then a negative value in the fourth channel indicates no data. When it is false, all points are valid.

This is a special case of set_no_data_value().

set_no_data_nan(num_channels: int)

Sets the no_data_nan flag. When num_channels is nonzero, then a NaN value in any of the first num_channels channels indicates no data for that point. If num_channels is zero, then all points are valid.

This is a special case of set_no_data_value().

set_no_data_threshold(no_data_value: LPoint4d): Sets the special threshold value. Points that are below this value in all components are considered “no value”.

set_no_data_threshold(no_data_value: LPoint4f): Sets the special threshold value. Points that are below this value in all components are considered “no value”.

set_no_data_value(no_data_value: LPoint4d): Sets the special value that means “no data” when it appears in the pfm file.

set_no_data_value(no_data_value: LPoint4f): Sets the special value that means “no data” when it appears in the pfm file.

set_point(x: int, y: int, point: LVecBase3d): Replaces the 3-component point value at the indicated point. In a 1-channel image, the channel value is in the x component.

set_point(x: int, y: int, point: LVecBase3f): Replaces the 3-component point value at the indicated point. In a 1-channel image, the channel value is in the x component.

set_point1(x: int, y: int, point: float): Replaces the 1-component point value at the indicated point.

set_point2(x: int, y: int, point: LVecBase2d): Replaces the 2-component point value at the indicated point. In a 1-channel image, the channel value is in the x component.

set_point2(x: int, y: int, point: LVecBase2f): Replaces the 2-component point value at the indicated point. In a 1-channel image, the channel value is in the x component.

set_point3(x: int, y: int, point: LVecBase3d): Replaces the 3-component point value at the indicated point. In a 1-channel image, the channel value is in the x component.

set_point3(x: int, y: int, point: LVecBase3f): Replaces the 3-component point value at the indicated point. In a 1-channel image, the channel value is in the x component.

set_point4(x: int, y: int, point: LVecBase4d): Replaces the 4-component point value at the indicated point. In a 1-channel image, the channel value is in the x component.

set_point4(x: int, y: int, point: LVecBase4f): Replaces the 4-component point value at the indicated point. In a 1-channel image, the channel value is in the x component.

set_scale(scale: float): The “scale” is reported in the pfm header and is probably meaningless.

set_zero_special(zero_special: bool)

Sets the zero_special flag. When this flag is true, values of (0, 0, 0) in the pfm file are treated as a special case, and are not processed.

This is a special case of set_no_data_value().

store(pnmimage: PNMImage) → bool: Copies the data to the indicated PNMImage, converting to RGB values.

store_mask(pnmimage: PNMImage) → bool: Stores 1 or 0 values into the indicated PNMImage, according to has_point() for each pixel. Each valid point gets a 1 value; each nonexistent point gets a 0 value.

store_mask(pnmimage: PNMImage, min_point: LVecBase4f, max_point: LVecBase4f) → bool

Stores 1 or 0 values into the indicated PNMImage, according to has_point() for each pixel. Each valid point gets a 1 value; each nonexistent point gets a 0 value.

This flavor of store_mask also checks whether the valid points are within the specified min/max range. Any valid points without the condition min_point[c] <= value[c] <= max_point[c], for any c, are stored with a 0 in the mask.

property valid → bool

write(fullpath: Filename) → bool

Writes the PFM data to the indicated file, returning true on success, false on failure.

If the type implied by the filename extension supports floating-point, the data will be written directly; otherwise, the floating-point data will be quietly converted to the appropriate integer type.

write(writer: PNMWriter) → bool

Writes the PFM data using the indicated PNMWriter.

The PNMWriter is always deleted upon completion, whether successful or not.

write(out: ostream, fullpath: Filename) → bool: Writes the PFM data to the indicated stream, returning true on success, false on failure.

xform(transform: LMatrix4d): Applies the indicated transform matrix to all points in-place.

xform(transform: LMatrix4f): Applies the indicated transform matrix to all points in-place.