historical/toontown-classic.git/panda/include/pfmFile.I

599 lines
16 KiB
Text
Raw Normal View History

2024-01-16 11:20:27 -06:00
/**
* PANDA 3D SOFTWARE
* Copyright (c) Carnegie Mellon University. All rights reserved.
*
* All use of this software is subject to the terms of the revised BSD
* license. You should have received a copy of this license along
* with this source code in a file named "LICENSE."
*
* @file pfmFile.I
* @author drose
* @date 2010-12-23
*/
/**
*
*/
INLINE bool PfmFile::
is_valid() const {
return _num_channels != 0 && (_x_size * _y_size * _num_channels <= (int)_table.size());
}
/**
* The "scale" is reported in the pfm header and is probably meaningless.
*/
INLINE PN_float32 PfmFile::
get_scale() const {
return _scale;
}
/**
* The "scale" is reported in the pfm header and is probably meaningless.
*/
INLINE void PfmFile::
set_scale(PN_float32 scale) {
_scale = scale;
}
/**
* 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.
*/
INLINE bool PfmFile::
has_point(int x, int y) const {
return _has_point(this, x, y);
}
/**
* Returns the cth channel of the point value at the indicated point.
*/
INLINE PN_float32 PfmFile::
get_channel(int x, int y, int c) const {
nassertr(x >= 0 && x < _x_size &&
y >= 0 && y < _y_size &&
c >= 0 && c < _num_channels, 0.0f);
return _table[(y * _x_size + x) * _num_channels + c];
}
/**
* Replaces the cth channel of the point value at the indicated point.
*/
INLINE void PfmFile::
set_channel(int x, int y, int c, PN_float32 value) {
nassertv(x >= 0 && x < _x_size &&
y >= 0 && y < _y_size &&
c >= 0 && c < _num_channels);
_table[(y * _x_size + x) * _num_channels + c] = value;
}
/**
* Returns the 1-component point value at the indicated point.
*/
INLINE PN_float32 PfmFile::
get_point1(int x, int y) const {
nassertr(x >= 0 && x < _x_size &&
y >= 0 && y < _y_size, 0.0);
return _table[(y * _x_size + x) * _num_channels];
}
/**
* Replaces the 1-component point value at the indicated point.
*/
INLINE void PfmFile::
set_point1(int x, int y, PN_float32 point) {
//nassertv(!cnan(point));
nassertv(x >= 0 && x < _x_size &&
y >= 0 && y < _y_size);
_table[(y * _x_size + x) * _num_channels] = point;
}
/**
* Returns the 2-component point value at the indicated point. In a 1-channel
* image, the channel value is in the x component.
*/
INLINE const LPoint2f &PfmFile::
get_point2(int x, int y) const {
nassertr(x >= 0 && x < _x_size &&
y >= 0 && y < _y_size, LPoint2f::zero());
return *(LPoint2f *)&_table[(y * _x_size + x) * _num_channels];
}
/**
* Replaces the 2-component point value at the indicated point. In a
* 1-channel image, the channel value is in the x component.
*/
INLINE void PfmFile::
set_point2(int x, int y, const LVecBase2f &point) {
//nassertv(!point.is_nan());
nassertv(x >= 0 && x < _x_size &&
y >= 0 && y < _y_size);
switch (_num_channels) {
case 1:
_table[(y * _x_size + x)] = point[0];
break;
case 2:
*(LPoint2f *)&_table[(y * _x_size + x) * _num_channels] = point;
break;
case 3:
(*(LPoint3f *)&_table[(y * _x_size + x) * _num_channels]).set(point[0], point[1], 0.0);
break;
case 4:
(*(LPoint4f *)&_table[(y * _x_size + x) * _num_channels]).set(point[0], point[1], 0.0, 0.0);
break;
}
}
/**
* Replaces the 2-component point value at the indicated point. In a
* 1-channel image, the channel value is in the x component.
*/
INLINE void PfmFile::
set_point2(int x, int y, const LVecBase2d &point) {
set_point2(x, y, LCAST(PN_float32, point));
}
/**
* Returns a modifiable 2-component point value at the indicated point.
*/
INLINE LPoint2f &PfmFile::
modify_point2(int x, int y) {
#ifndef NDEBUG
static LPoint2f dummy_value = LPoint2f::zero();
nassertr(x >= 0 && x < _x_size &&
y >= 0 && y < _y_size, dummy_value);
#endif
return *(LPoint2f *)&_table[(y * _x_size + x) * _num_channels];
}
/**
* Returns the 3-component point value at the indicated point. In a 1-channel
* image, the channel value is in the x component.
*/
INLINE const LPoint3f &PfmFile::
get_point(int x, int y) const {
return get_point3(x, y);
}
/**
* Replaces the 3-component point value at the indicated point. In a
* 1-channel image, the channel value is in the x component.
*/
INLINE void PfmFile::
set_point(int x, int y, const LVecBase3f &point) {
set_point3(x, y, point);
}
/**
* Replaces the 3-component point value at the indicated point. In a
* 1-channel image, the channel value is in the x component.
*/
INLINE void PfmFile::
set_point(int x, int y, const LVecBase3d &point) {
set_point3(x, y, point);
}
/**
* Returns a modifiable 3-component point value at the indicated point.
*/
INLINE LPoint3f &PfmFile::
modify_point(int x, int y) {
return modify_point3(x, y);
}
/**
* Returns the 3-component point value at the indicated point. In a 1-channel
* image, the channel value is in the x component.
*/
INLINE const LPoint3f &PfmFile::
get_point3(int x, int y) const {
nassertr(x >= 0 && x < _x_size &&
y >= 0 && y < _y_size, LPoint3f::zero());
return *(LPoint3f *)&_table[(y * _x_size + x) * _num_channels];
}
/**
* Replaces the 3-component point value at the indicated point. In a
* 1-channel image, the channel value is in the x component.
*/
INLINE void PfmFile::
set_point3(int x, int y, const LVecBase3f &point) {
//nassertv(!point.is_nan());
nassertv(x >= 0 && x < _x_size &&
y >= 0 && y < _y_size);
switch (_num_channels) {
case 1:
_table[(y * _x_size + x)] = point[0];
break;
case 2:
(*(LPoint2f *)&_table[(y * _x_size + x) * _num_channels]).set(point[0], point[1]);
break;
case 3:
*(LPoint3f *)&_table[(y * _x_size + x) * _num_channels] = point;
break;
case 4:
(*(LPoint4f *)&_table[(y * _x_size + x) * _num_channels]).set(point[0], point[1], 0.0f, 0.0f);
break;
}
}
/**
* Replaces the 3-component point value at the indicated point. In a
* 1-channel image, the channel value is in the x component.
*/
INLINE void PfmFile::
set_point3(int x, int y, const LVecBase3d &point) {
set_point3(x, y, LCAST(PN_float32, point));
}
/**
* Returns a modifiable 3-component point value at the indicated point.
*/
INLINE LPoint3f &PfmFile::
modify_point3(int x, int y) {
#ifndef NDEBUG
static LPoint3f dummy_value = LPoint3f::zero();
nassertr(x >= 0 && x < _x_size &&
y >= 0 && y < _y_size, dummy_value);
#endif
return *(LPoint3f *)&_table[(y * _x_size + x) * _num_channels];
}
/**
* Returns the 4-component point value at the indicated point. In a 1-channel
* image, the channel value is in the x component.
*/
INLINE const LPoint4f &PfmFile::
get_point4(int x, int y) const {
nassertr(x >= 0 && x < _x_size &&
y >= 0 && y < _y_size, LPoint4f::zero());
return *(LPoint4f *)&_table[(y * _x_size + x) * _num_channels];
}
/**
* Replaces the 4-component point value at the indicated point. In a
* 1-channel image, the channel value is in the x component.
*/
INLINE void PfmFile::
set_point4(int x, int y, const LVecBase4f &point) {
//nassertv(!point.is_nan());
nassertv(x >= 0 && x < _x_size &&
y >= 0 && y < _y_size);
switch (_num_channels) {
case 1:
_table[(y * _x_size + x)] = point[0];
break;
case 2:
(*(LPoint2f *)&_table[(y * _x_size + x) * _num_channels]).set(point[0], point[1]);
break;
case 3:
(*(LPoint3f *)&_table[(y * _x_size + x) * _num_channels]).set(point[0], point[1], point[2]);
break;
case 4:
*(LPoint4f *)&_table[(y * _x_size + x) * _num_channels] = point;
break;
}
}
/**
* Replaces the 4-component point value at the indicated point. In a
* 1-channel image, the channel value is in the x component.
*/
INLINE void PfmFile::
set_point4(int x, int y, const LVecBase4d &point) {
set_point4(x, y, LCAST(PN_float32, point));
}
/**
* Returns a modifiable 4-component point value at the indicated point.
*/
INLINE LPoint4f &PfmFile::
modify_point4(int x, int y) {
#ifndef NDEBUG
static LPoint4f dummy_value = LPoint4f::zero();
nassertr(x >= 0 && x < _x_size &&
y >= 0 && y < _y_size, dummy_value);
#endif
return *(LPoint4f *)&_table[(y * _x_size + x) * _num_channels];
}
/**
* Fills the table with all of the same value.
*/
INLINE void PfmFile::
fill(PN_float32 value) {
fill(LPoint4f(value, 0.0f, 0.0f, 0.0f));
}
/**
* Fills the table with all of the same value.
*/
INLINE void PfmFile::
fill(const LPoint2f &value) {
fill(LPoint4f(value[0], value[1], 0.0f, 0.0f));
}
/**
* Fills the table with all of the same value.
*/
INLINE void PfmFile::
fill(const LPoint3f &value) {
fill(LPoint4f(value[0], value[1], value[2], 0.0f));
}
/**
* 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()).
*/
INLINE bool PfmFile::
calc_autocrop(LVecBase4f &range) const {
int x_begin, x_end, y_begin, y_end;
bool result = calc_autocrop(x_begin, x_end, y_begin, y_end);
range.set(x_begin, x_end, y_begin, y_end);
return result;
}
/**
* 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()).
*/
INLINE bool PfmFile::
calc_autocrop(LVecBase4d &range) const {
int x_begin, x_end, y_begin, y_end;
bool result = calc_autocrop(x_begin, x_end, y_begin, y_end);
range.set(x_begin, x_end, y_begin, y_end);
return result;
}
/**
* 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().
*/
INLINE void PfmFile::
set_zero_special(bool zero_special) {
if (zero_special) {
set_no_data_value(LPoint4f::zero());
} else {
clear_no_data_value();
}
}
/**
* 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().
*/
INLINE void PfmFile::
set_no_data_chan4(bool chan4) {
if (chan4 && _num_channels == 4) {
_has_no_data_value = true;
_has_no_data_threshold = false;
_no_data_value.set(0.0, 0.0, 0.0, -1.0);
_has_point = has_point_chan4;
} else {
clear_no_data_value();
}
}
/**
* Sets the special value that means "no data" when it appears in the pfm
* file.
*/
INLINE void PfmFile::
set_no_data_value(const LPoint4d &no_data_value) {
set_no_data_value(LCAST(PN_float32, no_data_value));
}
/**
* Sets the special threshold value. Points that are below this value in all
* components are considered "no value".
*/
INLINE void PfmFile::
set_no_data_threshold(const LPoint4d &no_data_threshold) {
set_no_data_threshold(LCAST(PN_float32, no_data_threshold));
}
/**
* Removes the special value that means "no data" when it appears in the pfm
* file. All points will thus be considered valid.
*/
INLINE void PfmFile::
clear_no_data_value() {
_has_no_data_value = false;
_has_no_data_threshold = false;
_no_data_value = LPoint4f::zero();
_has_point = has_point_noop;
}
/**
* Returns whether a "no data" value has been established by
* set_no_data_value().
*/
INLINE bool PfmFile::
has_no_data_value() const {
return _has_no_data_value;
}
/**
* Returns whether a "no data" threshold value has been established by
* set_no_data_threshold().
*/
INLINE bool PfmFile::
has_no_data_threshold() const {
return _has_no_data_threshold;
}
/**
* If has_no_data_value() returns true, this returns the particular "no data"
* value.
*/
INLINE const LPoint4f &PfmFile::
get_no_data_value() const {
nassertr(_has_no_data_value, LPoint4f::zero());
return _no_data_value;
}
/**
* Applies the indicated transform matrix to all points in-place.
*/
INLINE void PfmFile::
xform(const LMatrix4d &transform) {
xform(LCAST(PN_float32, transform));
}
/**
* 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.
*/
INLINE PT(BoundingHexahedron) PfmFile::
compute_planar_bounds(const LPoint2d &center, PN_float32 point_dist, PN_float32 sample_radius, bool points_only) const {
return compute_planar_bounds(LCAST(PN_float32, center), point_dist, sample_radius, points_only);
}
/**
* 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.
*/
INLINE void PfmFile::
gamma_correct(float from_gamma, float to_gamma) {
apply_exponent(from_gamma / to_gamma);
}
/**
* 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.
*/
INLINE void PfmFile::
gamma_correct_alpha(float from_gamma, float to_gamma) {
apply_exponent(1.0, from_gamma / to_gamma);
}
/**
* Adjusts each channel of the image by raising the corresponding component
* value to the indicated exponent, such that L' = L ^ exponent.
*/
INLINE void PfmFile::
apply_exponent(float gray_exponent) {
apply_exponent(gray_exponent, gray_exponent, gray_exponent, 1.0);
}
/**
* Adjusts each channel of the image by raising the corresponding component
* value to the indicated exponent, such that L' = L ^ exponent.
*/
INLINE void PfmFile::
apply_exponent(float gray_exponent, float alpha_exponent) {
apply_exponent(gray_exponent, gray_exponent, gray_exponent, alpha_exponent);
}
/**
* 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.
*/
INLINE void PfmFile::
apply_exponent(float c0_exponent, float c1_exponent, float c2_exponent) {
apply_exponent(c0_exponent, c1_exponent, c2_exponent, 1.0);
}
/**
* This is a very low-level function that returns a read-only reference to the
* internal table of floating-point numbers. Use this method at your own
* risk.
*/
INLINE const vector_float &PfmFile::
get_table() const {
return _table;
}
/**
* This is a very low-level function that completely exchanges the PfmFile's
* internal table of floating-point numbers with whatever you supply. The
* provided table must have an appropriate size. Use this method at your own
* risk.
*/
void PfmFile::
swap_table(vector_float &table) {
_table.swap(table);
}
/**
* Computes xmin, ymin, xmax, and ymax, based on the input parameters for
* copy_sub_image() and related methods.
*/
INLINE void PfmFile::
setup_sub_image(const PfmFile &copy, int &xto, int &yto,
int &xfrom, int &yfrom, int &x_size, int &y_size,
int &xmin, int &ymin, int &xmax, int &ymax) {
if (x_size < 0) {
x_size = copy.get_x_size() - xfrom;
}
if (y_size < 0) {
y_size = copy.get_y_size() - yfrom;
}
if (xfrom < 0) {
xto += -xfrom;
x_size -= -xfrom;
xfrom = 0;
}
if (yfrom < 0) {
yto += -yfrom;
y_size -= -yfrom;
yfrom = 0;
}
if (xto < 0) {
xfrom += -xto;
x_size -= -xto;
xto = 0;
}
if (yto < 0) {
yfrom += -yto;
y_size -= -yto;
yto = 0;
}
x_size = std::min(x_size, copy.get_x_size() - xfrom);
y_size = std::min(y_size, copy.get_y_size() - yfrom);
xmin = xto;
ymin = yto;
xmax = std::min(xmin + x_size, get_x_size());
ymax = std::min(ymin + y_size, get_y_size());
}