1412101944
2 2
13 libp3pnmimage 4 BCNh 12 panda3d.core 
263
410 5 pixel 0 4 673 12 pixel::pixel 0 2 1 2 0
99
pixel::pixel(void);
pixel::pixel(unsigned short int r, unsigned short int g, unsigned short int b);

411 4 size 0 4 673 11 pixel::size 0 1 3 0
29
static int pixel::size(void);

412 11 operator [] 0 4 673 18 pixel::operator [] 0 2 4 5 0
98
unsigned short int pixel::operator [](int i) const;
unsigned short int &pixel::operator [](int i);

413 11 __setitem__ 0 4 673 18 pixel::__setitem__ 0 1 6 0
53
void pixel::__setitem__(int i, unsigned short int v);

414 10 operator + 0 4 673 17 pixel::operator + 0 1 7 0
50
pixel pixel::operator +(pixel const &other) const;

415 10 operator - 0 4 673 17 pixel::operator - 0 1 8 0
50
pixel pixel::operator -(pixel const &other) const;

416 10 operator * 0 4 673 17 pixel::operator * 0 1 9 0
49
pixel pixel::operator *(double const mult) const;

417 11 operator += 0 4 673 18 pixel::operator += 0 1 10 0
44
void pixel::operator +=(pixel const &other);

418 11 operator -= 0 4 673 18 pixel::operator -= 0 1 11 0
44
void pixel::operator -=(pixel const &other);

419 11 operator *= 0 4 673 18 pixel::operator *= 0 1 12 0
43
void pixel::operator *=(double const mult);

420 5 get_b 0 20 673 12 pixel::get_b 0 1 13 39
getter for unsigned short int pixel::b;
44
unsigned short int pixel::get_b(void) const;

421 5 set_b 0 36 673 12 pixel::set_b 0 1 14 39
setter for unsigned short int pixel::b;
44
void pixel::set_b(unsigned short int value);

422 5 get_g 0 20 673 12 pixel::get_g 0 1 15 39
getter for unsigned short int pixel::g;
44
unsigned short int pixel::get_g(void) const;

423 5 set_g 0 36 673 12 pixel::set_g 0 1 16 39
setter for unsigned short int pixel::g;
44
void pixel::set_g(unsigned short int value);

424 5 get_r 0 20 673 12 pixel::get_r 0 1 17 39
getter for unsigned short int pixel::r;
44
unsigned short int pixel::get_r(void) const;

425 5 set_r 0 36 673 12 pixel::set_r 0 1 18 39
setter for unsigned short int pixel::r;
44
void pixel::set_r(unsigned short int value);

426 6 ~pixel 0 4 673 13 pixel::~pixel 0 0 0
20
pixel::~pixel(void);

427 8 get_name 0 6 675 21 PNMFileType::get_name 0 1 19 0
67
virtual basic_string< char > PNMFileType::get_name(void) const = 0;

428 18 get_num_extensions 0 6 675 31 PNMFileType::get_num_extensions 0 1 20 360
////////////////////////////////////////////////////////////////////
//     Function: PNMFileType::get_num_extensions
//       Access: Published, Virtual
//  Description: Returns the number of different possible filename
//               extensions associated with this particular file type.
////////////////////////////////////////////////////////////////////
56
virtual int PNMFileType::get_num_extensions(void) const;

429 13 get_extension 0 6 675 26 PNMFileType::get_extension 0 1 21 378
////////////////////////////////////////////////////////////////////
//     Function: PNMFileType::get_extension
//       Access: Published, Virtual
//  Description: Returns the nth possible filename extension
//               associated with this particular file type, without a
//               leading dot.
////////////////////////////////////////////////////////////////////
69
virtual basic_string< char > PNMFileType::get_extension(int n) const;

430 23 get_suggested_extension 0 6 675 36 PNMFileType::get_suggested_extension 0 1 22 424
////////////////////////////////////////////////////////////////////
//     Function: PNMFileType::get_suggested_extension
//       Access: Published, Virtual
//  Description: Returns a suitable filename extension (without a
//               leading dot) to suggest for files of this type, or
//               empty string if no suggestions are available.
////////////////////////////////////////////////////////////////////
78
virtual basic_string< char > PNMFileType::get_suggested_extension(void) const;

431 14 get_class_type 0 4 675 27 PNMFileType::get_class_type 0 1 23 0
52
static TypeHandle PNMFileType::get_class_type(void);

432 20 ~PNMFileTypeRegistry 0 4 677 41 PNMFileTypeRegistry::~PNMFileTypeRegistry 0 0 227
////////////////////////////////////////////////////////////////////
//     Function: PNMFileTypeRegistry::Destructor
//       Access: Public
//  Description:
////////////////////////////////////////////////////////////////////
48
PNMFileTypeRegistry::~PNMFileTypeRegistry(void);

433 13 get_num_types 0 4 677 34 PNMFileTypeRegistry::get_num_types 0 1 24 279
////////////////////////////////////////////////////////////////////
//     Function: PNMFileTypeRegistry::get_num_types
//       Access: Published
//  Description: Returns the total number of types registered.
////////////////////////////////////////////////////////////////////
51
int PNMFileTypeRegistry::get_num_types(void) const;

434 8 get_type 0 4 677 29 PNMFileTypeRegistry::get_type 0 1 25 261
////////////////////////////////////////////////////////////////////
//     Function: PNMFileTypeRegistry::get_type
//       Access: Published
//  Description: Returns the nth type registered.
////////////////////////////////////////////////////////////////////
56
PNMFileType *PNMFileTypeRegistry::get_type(int n) const;

435 23 get_type_from_extension 0 4 677 44 PNMFileTypeRegistry::get_type_from_extension 0 1 26 481
////////////////////////////////////////////////////////////////////
//     Function: PNMFileTypeRegistry::get_type_from_extension
//       Access: Published
//  Description: Tries to determine what the PNMFileType is likely to
//               be for a particular image file based on its
//               extension.  Returns a suitable PNMFileType pointer,
//               or NULL if no type can be determined.
////////////////////////////////////////////////////////////////////
102
PNMFileType *PNMFileTypeRegistry::get_type_from_extension(basic_string< char > const &filename) const;

436 26 get_type_from_magic_number 0 4 677 47 PNMFileTypeRegistry::get_type_from_magic_number 0 1 27 544
////////////////////////////////////////////////////////////////////
//     Function: PNMFileTypeRegistry::get_type_from_magic_number
//       Access: Published
//  Description: Tries to determine what the PNMFileType is likely to
//               be for a particular image file based on its
//               magic number, the first two bytes read from the
//               file.  Returns a suitable PNMFileType pointer, or
//               NULL if no type can be determined.
////////////////////////////////////////////////////////////////////
109
PNMFileType *PNMFileTypeRegistry::get_type_from_magic_number(basic_string< char > const &magic_number) const;

437 18 get_type_by_handle 0 4 677 39 PNMFileTypeRegistry::get_type_by_handle 0 1 28 444
////////////////////////////////////////////////////////////////////
//     Function: PNMFileTypeRegistry::get_type_by_handle
//       Access: Published
//  Description: Returns the PNMFileType instance stored in the
//               registry for the given TypeHandle, e.g. as retrieved
//               by a previous call to get_type() on the type
//               instance.
////////////////////////////////////////////////////////////////////
78
PNMFileType *PNMFileTypeRegistry::get_type_by_handle(TypeHandle handle) const;

438 5 write 0 4 677 26 PNMFileTypeRegistry::write 0 2 29 30 332
////////////////////////////////////////////////////////////////////
//     Function: PNMFileTypeRegistry::write
//       Access: Published
//  Description: Writes a list of supported image file types to the
//               indicated output stream, one per line.
////////////////////////////////////////////////////////////////////
76
void PNMFileTypeRegistry::write(ostream &out, int indent_level = (0)) const;

439 14 get_global_ptr 0 4 677 35 PNMFileTypeRegistry::get_global_ptr 0 1 31 319
////////////////////////////////////////////////////////////////////
//     Function: PNMFileTypeRegistry::get_global_ptr
//       Access: Published, Static
//  Description: Returns a pointer to the global PNMFileTypeRegistry
//               object.
////////////////////////////////////////////////////////////////////
70
static PNMFileTypeRegistry *PNMFileTypeRegistry::get_global_ptr(void);

440 14 PNMImageHeader 0 4 678 30 PNMImageHeader::PNMImageHeader 0 2 32 33 949
// Filename: pnmImageHeader.I
// Created by:  drose (15Jun00)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::Copy Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
111
inline PNMImageHeader::PNMImageHeader(void);
inline PNMImageHeader::PNMImageHeader(PNMImageHeader const &copy);

441 10 operator = 0 4 678 26 PNMImageHeader::operator = 0 1 34 239
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::Copy Assignment Operator
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
67
inline void PNMImageHeader::operator =(PNMImageHeader const &copy);

442 15 ~PNMImageHeader 0 4 678 31 PNMImageHeader::~PNMImageHeader 0 0 225
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::Destructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
45
inline PNMImageHeader::~PNMImageHeader(void);

443 14 get_color_type 0 4 678 30 PNMImageHeader::get_color_type 0 1 35 397
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::get_color_type
//       Access: Published
//  Description: Returns the image type of the image, as an enumerated
//               value.  This is really just the number of channels
//               cast to the enumerated type.
////////////////////////////////////////////////////////////////////
76
inline PNMImageHeader::ColorType PNMImageHeader::get_color_type(void) const;

444 16 get_num_channels 0 4 678 32 PNMImageHeader::get_num_channels 0 1 36 276
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::get_num_channels
//       Access: Published
//  Description: Returns the number of channels in the image.
////////////////////////////////////////////////////////////////////
56
inline int PNMImageHeader::get_num_channels(void) const;

445 12 is_grayscale 0 4 678 28 PNMImageHeader::is_grayscale 0 2 37 38 948
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::is_grayscale
//       Access: Published, Static
//  Description: This static variant of is_grayscale() returns true if
//               the indicated image type represents a grayscale
//               image, false otherwise.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::is_grayscale
//       Access: Published
//  Description: Returns false if the image is a full-color image, and
//               has red, green, and blue components; true if it is a
//               grayscale image and has only a gray component.  (The
//               gray color is actually stored in the blue channel,
//               and the red and green channels are ignored.)
////////////////////////////////////////////////////////////////////
140
static inline bool PNMImageHeader::is_grayscale(PNMImageHeader::ColorType color_type);
inline bool PNMImageHeader::is_grayscale(void) const;

446 9 has_alpha 0 4 678 25 PNMImageHeader::has_alpha 0 2 39 40 852
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::has_alpha
//       Access: Published, Static
//  Description: This static variant of has_alpha() returns true if
//               the indicated image type includes an alpha channel,
//               false otherwise.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::has_alpha
//       Access: Published
//  Description: Returns true if the image includes an alpha channel,
//               false otherwise.  Unlike is_grayscale(), if this
//               returns false it is an error to call any of the
//               functions accessing the alpha channel.
////////////////////////////////////////////////////////////////////
134
static inline bool PNMImageHeader::has_alpha(PNMImageHeader::ColorType color_type);
inline bool PNMImageHeader::has_alpha(void) const;

447 10 get_maxval 0 4 678 26 PNMImageHeader::get_maxval 0 1 41 443
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::get_maxval
//       Access: Published
//  Description: Returns the maximum channel value allowable for any
//               pixel in this image; for instance, 255 for a typical
//               8-bit-per-channel image.  A pixel with this value is
//               full on.
////////////////////////////////////////////////////////////////////
65
inline unsigned short int PNMImageHeader::get_maxval(void) const;

448 10 get_x_size 0 4 678 26 PNMImageHeader::get_x_size 0 1 42 366
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::get_x_size
//       Access: Published
//  Description: Returns the number of pixels in the X direction.
//               This is one more than the largest allowable X
//               coordinate.
////////////////////////////////////////////////////////////////////
50
inline int PNMImageHeader::get_x_size(void) const;

449 10 get_y_size 0 4 678 26 PNMImageHeader::get_y_size 0 1 43 366
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::get_y_size
//       Access: Published
//  Description: Returns the number of pixels in the Y direction.
//               This is one more than the largest allowable Y
//               coordinate.
////////////////////////////////////////////////////////////////////
50
inline int PNMImageHeader::get_y_size(void) const;

450 11 get_comment 0 4 678 27 PNMImageHeader::get_comment 0 1 44 263
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::get_comment
//       Access: Published
//  Description: Gets the user comment from the file.
////////////////////////////////////////////////////////////////////
68
inline basic_string< char > PNMImageHeader::get_comment(void) const;

451 11 set_comment 0 4 678 27 PNMImageHeader::set_comment 0 1 45 278
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::set_comment
//       Access: Published
//  Description: Writes a user comment string to the image (header).
////////////////////////////////////////////////////////////////////
77
inline void PNMImageHeader::set_comment(basic_string< char > const &comment);

452 8 has_type 0 4 678 24 PNMImageHeader::has_type 0 1 46 315
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::has_type
//       Access: Published
//  Description: Returns true if the PNMImageHeader knows what type it
//               is, false otherwise.
////////////////////////////////////////////////////////////////////
49
inline bool PNMImageHeader::has_type(void) const;

453 8 get_type 0 4 678 24 PNMImageHeader::get_type 0 1 47 373
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::get_type
//       Access: Published
//  Description: If the file type is known (e.g. has_type() returns
//               true), returns its PNMFileType pointer; otherwise,
//               returns NULL.
////////////////////////////////////////////////////////////////////
57
inline PNMFileType *PNMImageHeader::get_type(void) const;

454 8 set_type 0 4 678 24 PNMImageHeader::set_type 0 1 48 583
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::set_type
//       Access: Published
//  Description: Sets the file type of this PNMImage.  This will be
//               the default type used when an image is read, if the
//               type cannot be determined by magic number or inferred
//               by extension, or the type used when the image is
//               written, if the type cannot be inferred from the
//               filename extension.
////////////////////////////////////////////////////////////////////
56
inline void PNMImageHeader::set_type(PNMFileType *type);

455 11 read_header 0 4 678 27 PNMImageHeader::read_header 0 7 49 50 51 52 53 54 55 1214
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::read_header
//       Access: Published
//  Description: Opens up the image file and tries to read its header
//               information to determine its size, number of
//               channels, etc.  If successful, updates the header
//               information and returns true; otherwise, returns
//               false.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::read_header
//       Access: Published
//  Description: Reads the image header information only from the
//               indicated stream.
//
//               The filename is advisory only, and may be used
//               to suggest a type if it has a known extension.
//
//               If type is non-NULL, it is a suggestion for the type
//               of file it is (and a non-NULL type will override any
//               magic number test or filename extension lookup).
//
//               Returns true if successful, false on error.
////////////////////////////////////////////////////////////////////
295
bool PNMImageHeader::read_header(Filename const &filename, PNMFileType *type = ((void *)(0)), bool report_unknown_type = (1));
bool PNMImageHeader::read_header(istream &data, basic_string< char > const &filename = ((string())), PNMFileType *type = ((void *)(0)), bool report_unknown_type = (1));

456 11 make_reader 0 4 678 27 PNMImageHeader::make_reader 0 9 56 57 58 59 60 61 62 63 64 2105
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::make_reader
//       Access: Published
//  Description: Returns a newly-allocated PNMReader of the suitable
//               type for reading from the indicated image filename,
//               or NULL if the filename cannot be read for some
//               reason.  The filename "-" always stands for standard
//               input.  If type is specified, it is a suggestion for
//               the file type to use.
//
//               The PNMReader should be deleted when it is no longer
//               needed.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::make_reader
//       Access: Published
//  Description: Returns a newly-allocated PNMReader of the suitable
//               type for reading from the already-opened image file,
//               or NULL if the file cannot be read for some reason.
//
//               owns_file should be set true if the PNMReader is to
//               be considered the owner of the stream pointer (in
//               which case the stream will be deleted on completion,
//               whether successful or not), or false if it should not
//               delete it.
//
//               The filename parameter is optional here, since the
//               file has already been opened; it is only used to
//               examine the extension and attempt to guess the file
//               type.
//
//               If magic_number is nonempty, it is assumed to
//               represent the first few bytes that have already been
//               read from the file.  Some file types may have
//               difficulty if this is more than two bytes.
//
//               If type is non-NULL, it is a suggestion for the file
//               type to use.
//
//               The PNMReader should be deleted when it is no longer
//               needed.
////////////////////////////////////////////////////////////////////
373
PNMReader *PNMImageHeader::make_reader(Filename const &filename, PNMFileType *type = ((void *)(0)), bool report_unknown_type = (1)) const;
PNMReader *PNMImageHeader::make_reader(istream *file, bool owns_file = (1), Filename const &filename = ((())), basic_string< char > magic_number = ((string())), PNMFileType *type = ((void *)(0)), bool report_unknown_type = (1)) const;

457 11 make_writer 0 4 678 27 PNMImageHeader::make_writer 0 6 65 66 67 68 69 70 1861
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::make_writer
//       Access: Published
//  Description: Returns a newly-allocated PNMWriter of the suitable
//               type for writing an image to the indicated filename,
//               or NULL if the filename cannot be written for some
//               reason.  The filename "-" always stands for standard
//               output.  If type is specified, it is a suggestion for
//               the file type to use.
//
//               The PNMWriter should be deleted when it is no longer
//               needed.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::make_writer
//       Access: Published
//  Description: Returns a newly-allocated PNMWriter of the suitable
//               type for writing to the already-opened image file, or
//               NULL if the file cannot be written for some reason.
//
//               owns_file should be set true if the PNMWriter is to
//               be considered the owner of the stream pointer (in
//               which case the stream will be deleted on completion,
//               whether successful or not), or false if it should not
//               delete it.
//
//               The filename parameter is optional here, since the
//               file has already been opened; it is only used to
//               examine the extension and attempt to guess the
//               intended file type.
//
//               If type is non-NULL, it is a suggestion for the file
//               type to use.
//
//               The PNMWriter should be deleted when it is no longer
//               needed.
////////////////////////////////////////////////////////////////////
259
PNMWriter *PNMImageHeader::make_writer(Filename const &filename, PNMFileType *type = ((void *)(0))) const;
PNMWriter *PNMImageHeader::make_writer(ostream *file, bool owns_file = (1), Filename const &filename = ((())), PNMFileType *type = ((void *)(0))) const;

458 17 read_magic_number 0 4 678 33 PNMImageHeader::read_magic_number 0 1 71 602
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::read_magic_number
//       Access: Published, Static
//  Description: Ensures that the first n bytes of the file are read
//               into magic_number.  If magic_number is initially
//               nonempty, assumes these represent the first few bytes
//               already extracted.  Returns true if successful, false
//               if an end of file or error occurred before num_bytes
//               could be read.
////////////////////////////////////////////////////////////////////
112
static bool PNMImageHeader::read_magic_number(istream *file, basic_string< char > &magic_number, int num_bytes);

459 6 output 0 4 678 22 PNMImageHeader::output 0 1 72 221
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::output
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
48
void PNMImageHeader::output(ostream &out) const;

460 9 PixelSpec 0 4 680 36 PNMImageHeader::PixelSpec::PixelSpec 0 7 73 74 75 76 77 78 79 1683
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::Constructor
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::Constructor
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::Constructor
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::Constructor
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::Constructor
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::Constructor
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::Copy Constructor
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
679
inline PNMImageHeader::PixelSpec::PixelSpec(unsigned short int gray_value);
inline PNMImageHeader::PixelSpec::PixelSpec(unsigned short int gray_value, unsigned short int alpha);
inline PNMImageHeader::PixelSpec::PixelSpec(unsigned short int red, unsigned short int green, unsigned short int blue);
inline PNMImageHeader::PixelSpec::PixelSpec(unsigned short int red, unsigned short int green, unsigned short int blue, unsigned short int alpha);
inline PNMImageHeader::PixelSpec::PixelSpec(pixel const &rgb);
inline PNMImageHeader::PixelSpec::PixelSpec(pixel const &rgb, unsigned short int alpha);
inline PNMImageHeader::PixelSpec::PixelSpec(PNMImageHeader::PixelSpec const &copy);

461 10 operator = 0 4 680 37 PNMImageHeader::PixelSpec::operator = 0 1 80 251
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::Copy Assignment Operator
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
89
inline void PNMImageHeader::PixelSpec::operator =(PNMImageHeader::PixelSpec const &copy);

462 10 operator < 0 4 680 37 PNMImageHeader::PixelSpec::operator < 0 1 81 237
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::operator <
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
96
inline bool PNMImageHeader::PixelSpec::operator <(PNMImageHeader::PixelSpec const &other) const;

463 11 operator == 0 4 680 38 PNMImageHeader::PixelSpec::operator == 0 1 82 238
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::operator ==
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
97
inline bool PNMImageHeader::PixelSpec::operator ==(PNMImageHeader::PixelSpec const &other) const;

464 11 operator != 0 4 680 38 PNMImageHeader::PixelSpec::operator != 0 1 83 238
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::operator !=
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
97
inline bool PNMImageHeader::PixelSpec::operator !=(PNMImageHeader::PixelSpec const &other) const;

465 10 compare_to 0 4 680 37 PNMImageHeader::PixelSpec::compare_to 0 1 84 237
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::compare_to
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
95
inline int PNMImageHeader::PixelSpec::compare_to(PNMImageHeader::PixelSpec const &other) const;

466 7 get_red 0 4 680 34 PNMImageHeader::PixelSpec::get_red 0 1 85 234
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::get_red
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
73
inline unsigned short int PNMImageHeader::PixelSpec::get_red(void) const;

467 9 get_green 0 4 680 36 PNMImageHeader::PixelSpec::get_green 0 1 86 236
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::get_green
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
75
inline unsigned short int PNMImageHeader::PixelSpec::get_green(void) const;

468 8 get_blue 0 4 680 35 PNMImageHeader::PixelSpec::get_blue 0 1 87 235
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::get_blue
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
74
inline unsigned short int PNMImageHeader::PixelSpec::get_blue(void) const;

469 9 get_alpha 0 4 680 36 PNMImageHeader::PixelSpec::get_alpha 0 1 88 236
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::get_alpha
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
75
inline unsigned short int PNMImageHeader::PixelSpec::get_alpha(void) const;

470 7 set_red 0 4 680 34 PNMImageHeader::PixelSpec::set_red 0 1 89 234
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::set_red
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
71
inline void PNMImageHeader::PixelSpec::set_red(unsigned short int red);

471 9 set_green 0 4 680 36 PNMImageHeader::PixelSpec::set_green 0 1 90 236
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::set_green
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
75
inline void PNMImageHeader::PixelSpec::set_green(unsigned short int green);

472 8 set_blue 0 4 680 35 PNMImageHeader::PixelSpec::set_blue 0 1 91 235
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::set_blue
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
73
inline void PNMImageHeader::PixelSpec::set_blue(unsigned short int blue);

473 9 set_alpha 0 4 680 36 PNMImageHeader::PixelSpec::set_alpha 0 1 92 236
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::set_alpha
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
75
inline void PNMImageHeader::PixelSpec::set_alpha(unsigned short int alpha);

474 11 operator [] 0 4 680 38 PNMImageHeader::PixelSpec::operator [] 0 1 93 397
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::operator []
//       Access: Published
//  Description: Indexes numerically into the components, in the order
//               R, G, B, A.  This also makes the PixelSpec work like
//               a tuple in Python.
////////////////////////////////////////////////////////////////////
78
inline unsigned short int PNMImageHeader::PixelSpec::operator [](int n) const;

475 4 size 0 4 680 31 PNMImageHeader::PixelSpec::size 0 1 94 394
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::size
//       Access: Published, Static
//  Description: Specifies the number of components in the PixelSpec;
//               this is always 4, regardless of the type of image it
//               was taken from.
////////////////////////////////////////////////////////////////////
56
static inline int PNMImageHeader::PixelSpec::size(void);

476 6 output 0 4 680 33 PNMImageHeader::PixelSpec::output 0 1 95 230
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::output
//       Access: Public
//  Description: 
////////////////////////////////////////////////////////////////////
59
void PNMImageHeader::PixelSpec::output(ostream &out) const;

477 10 ~PixelSpec 0 4 680 37 PNMImageHeader::PixelSpec::~PixelSpec 0 0 0
44
PNMImageHeader::PixelSpec::~PixelSpec(void);

478 15 ~PixelSpecCount 0 4 681 47 PNMImageHeader::PixelSpecCount::~PixelSpecCount 0 0 0
54
PNMImageHeader::PixelSpecCount::~PixelSpecCount(void);

479 9 Histogram 0 4 682 36 PNMImageHeader::Histogram::Histogram 0 1 96 238
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::Histogram::Constructor
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
50
inline PNMImageHeader::Histogram::Histogram(void);

480 14 get_num_pixels 0 4 682 41 PNMImageHeader::Histogram::get_num_pixels 0 1 97 317
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::Histogram::get_num_pixels
//       Access: Published
//  Description: Returns the number of unique pixel colors in the
//               histogram.
////////////////////////////////////////////////////////////////////
65
inline int PNMImageHeader::Histogram::get_num_pixels(void) const;

481 9 get_pixel 0 4 682 36 PNMImageHeader::Histogram::get_pixel 0 1 98 385
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::Histogram::get_pixel
//       Access: Published
//  Description: Returns the nth unique pixel color in the histogram.
//               These are ordered by default from most common to
//               least common.
////////////////////////////////////////////////////////////////////
90
inline PNMImageHeader::PixelSpec const &PNMImageHeader::Histogram::get_pixel(int n) const;

482 9 get_count 0 4 682 36 PNMImageHeader::Histogram::get_count 0 2 99 100 678
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::Histogram::get_count
//       Access: Published
//  Description: Returns the number of occurrences in the image of the
//               nth unique pixel color in the histogram.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::Histogram::get_count
//       Access: Published
//  Description: Returns the number of occurrences in the image of the
//               indicated pixel color.
////////////////////////////////////////////////////////////////////
156
inline int PNMImageHeader::Histogram::get_count(int n) const;
inline int PNMImageHeader::Histogram::get_count(PNMImageHeader::PixelSpec const &pixel) const;

483 5 write 0 4 682 32 PNMImageHeader::Histogram::write 0 1 101 229
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::Histogram::write
//       Access: Public
//  Description: 
////////////////////////////////////////////////////////////////////
58
void PNMImageHeader::Histogram::write(ostream &out) const;

484 10 ~Histogram 0 4 682 37 PNMImageHeader::Histogram::~Histogram 0 0 0
44
PNMImageHeader::Histogram::~Histogram(void);

485 7 PfmFile 0 4 683 16 PfmFile::PfmFile 0 2 102 103 445
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PfmFile::Copy Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
62
PfmFile::PfmFile(void);
PfmFile::PfmFile(PfmFile const &copy);

486 10 operator = 0 4 683 19 PfmFile::operator = 0 1 104 223
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::Copy Assignment
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
46
void PfmFile::operator =(PfmFile const &copy);

487 5 clear 0 4 683 14 PfmFile::clear 0 2 105 106 703
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::clear
//       Access: Published
//  Description: Eliminates all data in the file.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PfmFile::clear
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
89
void PfmFile::clear(void);
void PfmFile::clear(int x_size, int y_size, int num_channels);

488 4 read 0 4 683 13 PfmFile::read 0 4 107 108 109 110 1383
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::read
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PfmFile::read
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PfmFile::read
//       Access: Published
//  Description: Reads the PFM data using the indicated PNMReader.
//
//               The PNMReader is always deleted upon completion,
//               whether successful or not.
////////////////////////////////////////////////////////////////////
152
bool PfmFile::read(Filename const &fullpath);
bool PfmFile::read(istream &in, Filename const &fullpath = ((())));
bool PfmFile::read(PNMReader *reader);

489 5 write 0 4 683 14 PfmFile::write 0 4 111 112 113 114 1290
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::write
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PfmFile::write
//       Access: Published
//  Description: Writes the PFM data to the indicated stream,
//               returning true on success, false on failure.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PfmFile::write
//       Access: Published
//  Description: Writes the PFM data using the indicated PNMWriter.
//
//               The PNMWriter is always deleted upon completion,
//               whether successful or not.
////////////////////////////////////////////////////////////////////
156
bool PfmFile::write(Filename const &fullpath);
bool PfmFile::write(ostream &out, Filename const &fullpath = ((())));
bool PfmFile::write(PNMWriter *writer);

490 4 load 0 4 683 13 PfmFile::load 0 1 115 326
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::load
//       Access: Published
//  Description: Fills the PfmFile with the data from the indicated
//               PNMImage, converted to floating-point values.
////////////////////////////////////////////////////////////////////
45
bool PfmFile::load(PNMImage const &pnmimage);

491 5 store 0 4 683 14 PfmFile::store 0 1 116 299
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::store
//       Access: Published
//  Description: Copies the data to the indicated PNMImage, converting
//               to RGB values.
////////////////////////////////////////////////////////////////////
46
bool PfmFile::store(PNMImage &pnmimage) const;

492 10 store_mask 0 4 683 19 PfmFile::store_mask 0 1 117 433
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::store_mask
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
51
bool PfmFile::store_mask(PNMImage &pnmimage) const;

493 8 is_valid 0 4 683 17 PfmFile::is_valid 0 1 118 700
// Filename: pfmFile.I
// Created by:  drose (23Dec10)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::is_valid
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
42
inline bool PfmFile::is_valid(void) const;

494 9 get_scale 0 4 683 18 PfmFile::get_scale 0 1 119 305
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::get_scale
//       Access: Published
//  Description: The "scale" is reported in the pfm header and is
//               probably meaningless.
////////////////////////////////////////////////////////////////////
44
inline float PfmFile::get_scale(void) const;

495 9 set_scale 0 4 683 18 PfmFile::set_scale 0 1 120 305
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_scale
//       Access: Published
//  Description: The "scale" is reported in the pfm header and is
//               probably meaningless.
////////////////////////////////////////////////////////////////////
44
inline void PfmFile::set_scale(float scale);

496 9 has_point 0 4 683 18 PfmFile::has_point 0 1 121 457
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::has_point
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
51
inline bool PfmFile::has_point(int x, int y) const;

497 11 get_channel 0 4 683 20 PfmFile::get_channel 0 1 122 303
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::get_channel
//       Access: Published
//  Description: Returns the cth channel of the point value at the
//               indicated point.
////////////////////////////////////////////////////////////////////
61
inline float PfmFile::get_channel(int x, int y, int c) const;

498 11 set_channel 0 4 683 20 PfmFile::set_channel 0 1 123 304
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_channel
//       Access: Published
//  Description: Replaces the cth channel of the point value at the
//               indicated point.
////////////////////////////////////////////////////////////////////
67
inline void PfmFile::set_channel(int x, int y, int c, float value);

499 10 get_point1 0 4 683 19 PfmFile::get_point1 0 1 124 295
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::get_point1
//       Access: Published
//  Description: Returns the 1-component point value at the indicated
//               point.
////////////////////////////////////////////////////////////////////
53
inline float PfmFile::get_point1(int x, int y) const;

500 10 set_point1 0 4 683 19 PfmFile::set_point1 0 1 125 296
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_point1
//       Access: Published
//  Description: Replaces the 1-component point value at the indicated
//               point.
////////////////////////////////////////////////////////////////////
59
inline void PfmFile::set_point1(int x, int y, float point);

501 10 get_point2 0 4 683 19 PfmFile::get_point2 0 1 126 376
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::get_point2
//       Access: Published
//  Description: Returns the 2-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
////////////////////////////////////////////////////////////////////
63
inline LPoint2f const &PfmFile::get_point2(int x, int y) const;

502 10 set_point2 0 4 683 19 PfmFile::set_point2 0 2 127 128 756
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_point2
//       Access: Published
//  Description: Replaces the 2-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_point2
//       Access: Published
//  Description: Replaces the 2-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
////////////////////////////////////////////////////////////////////
143
inline void PfmFile::set_point2(int x, int y, LVecBase2f const &point);
inline void PfmFile::set_point2(int x, int y, LVecBase2d const &point);

503 13 modify_point2 0 4 683 22 PfmFile::modify_point2 0 1 129 307
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::modify_point2
//       Access: Published
//  Description: Returns a modifiable 2-component point value at the
//               indicated point.
////////////////////////////////////////////////////////////////////
54
inline LPoint2f &PfmFile::modify_point2(int x, int y);

504 9 get_point 0 4 683 18 PfmFile::get_point 0 1 130 375
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::get_point
//       Access: Published
//  Description: Returns the 3-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
////////////////////////////////////////////////////////////////////
62
inline LPoint3f const &PfmFile::get_point(int x, int y) const;

505 9 set_point 0 4 683 18 PfmFile::set_point 0 2 131 132 754
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_point
//       Access: Published
//  Description: Replaces the 3-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_point
//       Access: Published
//  Description: Replaces the 3-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
////////////////////////////////////////////////////////////////////
141
inline void PfmFile::set_point(int x, int y, LVecBase3f const &point);
inline void PfmFile::set_point(int x, int y, LVecBase3d const &point);

506 12 modify_point 0 4 683 21 PfmFile::modify_point 0 1 133 306
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::modify_point
//       Access: Published
//  Description: Returns a modifiable 3-component point value at the
//               indicated point.
////////////////////////////////////////////////////////////////////
53
inline LPoint3f &PfmFile::modify_point(int x, int y);

507 10 get_point3 0 4 683 19 PfmFile::get_point3 0 1 134 376
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::get_point3
//       Access: Published
//  Description: Returns the 3-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
////////////////////////////////////////////////////////////////////
63
inline LPoint3f const &PfmFile::get_point3(int x, int y) const;

508 10 set_point3 0 4 683 19 PfmFile::set_point3 0 2 135 136 756
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_point3
//       Access: Published
//  Description: Replaces the 3-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_point3
//       Access: Published
//  Description: Replaces the 3-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
////////////////////////////////////////////////////////////////////
143
inline void PfmFile::set_point3(int x, int y, LVecBase3f const &point);
inline void PfmFile::set_point3(int x, int y, LVecBase3d const &point);

509 13 modify_point3 0 4 683 22 PfmFile::modify_point3 0 1 137 307
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::modify_point3
//       Access: Published
//  Description: Returns a modifiable 3-component point value at the
//               indicated point.
////////////////////////////////////////////////////////////////////
54
inline LPoint3f &PfmFile::modify_point3(int x, int y);

510 10 get_point4 0 4 683 19 PfmFile::get_point4 0 1 138 376
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::get_point4
//       Access: Published
//  Description: Returns the 4-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
////////////////////////////////////////////////////////////////////
63
inline LPoint4f const &PfmFile::get_point4(int x, int y) const;

511 10 set_point4 0 4 683 19 PfmFile::set_point4 0 2 139 140 756
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_point4
//       Access: Published
//  Description: Replaces the 4-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_point4
//       Access: Published
//  Description: Replaces the 4-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
////////////////////////////////////////////////////////////////////
143
inline void PfmFile::set_point4(int x, int y, LVecBase4f const &point);
inline void PfmFile::set_point4(int x, int y, LVecBase4d const &point);

512 13 modify_point4 0 4 683 22 PfmFile::modify_point4 0 1 141 307
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::modify_point4
//       Access: Published
//  Description: Returns a modifiable 4-component point value at the
//               indicated point.
////////////////////////////////////////////////////////////////////
54
inline LPoint4f &PfmFile::modify_point4(int x, int y);

513 4 fill 0 4 683 13 PfmFile::fill 0 4 142 143 144 145 1030
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::fill
//       Access: Published
//  Description: Fills the table with all of the same value.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PfmFile::fill
//       Access: Published
//  Description: Fills the table with all of the same value.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PfmFile::fill
//       Access: Published
//  Description: Fills the table with all of the same value.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PfmFile::fill
//       Access: Published
//  Description: Fills the table with all of the same value.
////////////////////////////////////////////////////////////////////
182
inline void PfmFile::fill(float value);
inline void PfmFile::fill(LPoint2f const &value);
inline void PfmFile::fill(LPoint3f const &value);
void PfmFile::fill(LPoint4f const &value);

514 8 fill_nan 0 4 683 17 PfmFile::fill_nan 0 1 146 246
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::fill_nan
//       Access: Published
//  Description: Fills the table with all NaN.
////////////////////////////////////////////////////////////////////
29
void PfmFile::fill_nan(void);

515 18 fill_no_data_value 0 4 683 27 PfmFile::fill_no_data_value 0 1 147 319
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::fill_no_data_value
//       Access: Published
//  Description: Fills the table with the current no_data value, so
//               that the table is empty.
////////////////////////////////////////////////////////////////////
39
void PfmFile::fill_no_data_value(void);

516 12 fill_channel 0 4 683 21 PfmFile::fill_channel 0 1 148 331
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::fill_channel
//       Access: Published
//  Description: Fills the indicated channel with all of the same
//               value, leaving the other channels unchanged.
////////////////////////////////////////////////////////////////////
53
void PfmFile::fill_channel(int channel, float value);

517 16 fill_channel_nan 0 4 683 25 PfmFile::fill_channel_nan 0 1 149 317
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::fill_channel_nan
//       Access: Published
//  Description: Fills the indicated channel with NaN, leaving the
//               other channels unchanged.
////////////////////////////////////////////////////////////////////
44
void PfmFile::fill_channel_nan(int channel);

518 19 fill_channel_masked 0 4 683 28 PfmFile::fill_channel_masked 0 1 150 400
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::fill_channel_masked
//       Access: Published
//  Description: Fills the indicated channel with all of the same
//               value, but only where the table already has a data
//               point.  Leaves empty points unchanged.
////////////////////////////////////////////////////////////////////
60
void PfmFile::fill_channel_masked(int channel, float value);

519 23 fill_channel_masked_nan 0 4 683 32 PfmFile::fill_channel_masked_nan 0 1 151 386
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::fill_channel_masked_nan
//       Access: Published
//  Description: Fills the indicated channel with NaN, but only where
//               the table already has a data point.  Leaves empty
//               points unchanged.
////////////////////////////////////////////////////////////////////
51
void PfmFile::fill_channel_masked_nan(int channel);

520 18 calc_average_point 0 4 683 27 PfmFile::calc_average_point 0 1 152 587
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::calc_average_point
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
89
bool PfmFile::calc_average_point(LPoint3f &result, float x, float y, float radius) const;

521 19 calc_bilinear_point 0 4 683 28 PfmFile::calc_bilinear_point 0 1 153 451
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::calc_bilinear_point
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
76
bool PfmFile::calc_bilinear_point(LPoint3f &result, float x, float y) const;

522 12 calc_min_max 0 4 683 21 PfmFile::calc_min_max 0 1 154 515
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::calc_min_max
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
81
bool PfmFile::calc_min_max(LVecBase3f &min_points, LVecBase3f &max_points) const;

523 13 calc_autocrop 0 4 683 22 PfmFile::calc_autocrop 0 2 155 156 1564
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::calc_autocrop
//       Access: Published
//  Description: 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()).
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PfmFile::calc_autocrop
//       Access: Published
//  Description: 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()).
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PfmFile::calc_autocrop
//       Access: Published
//  Description: 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()).
////////////////////////////////////////////////////////////////////
208
bool PfmFile::calc_autocrop(int &x_begin, int &x_end, int &y_begin, int &y_end) const;
inline bool PfmFile::calc_autocrop(LVecBase4f &range) const;
inline bool PfmFile::calc_autocrop(LVecBase4d &range) const;

524 12 is_row_empty 0 4 683 21 PfmFile::is_row_empty 0 1 157 401
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::is_row_empty
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
64
bool PfmFile::is_row_empty(int y, int x_begin, int x_end) const;

525 15 is_column_empty 0 4 683 24 PfmFile::is_column_empty 0 1 158 399
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::is_column_empty
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
67
bool PfmFile::is_column_empty(int x, int y_begin, int y_end) const;

526 16 set_zero_special 0 4 683 25 PfmFile::set_zero_special 0 1 159 468
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_zero_special
//       Access: Published
//  Description: 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().
////////////////////////////////////////////////////////////////////
57
inline void PfmFile::set_zero_special(bool zero_special);

527 17 set_no_data_chan4 0 4 683 26 PfmFile::set_no_data_chan4 0 1 160 534
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_no_data_chan4
//       Access: Published
//  Description: 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().
////////////////////////////////////////////////////////////////////
51
inline void PfmFile::set_no_data_chan4(bool chan4);

528 15 set_no_data_nan 0 4 683 24 PfmFile::set_no_data_nan 0 1 161 562
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_no_data_nan
//       Access: Published
//  Description: 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().
////////////////////////////////////////////////////////////////////
48
void PfmFile::set_no_data_nan(int num_channels);

529 17 set_no_data_value 0 4 683 26 PfmFile::set_no_data_value 0 2 162 163 640
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_no_data_value
//       Access: Published
//  Description: Sets the special value that means "no data" when it
//               appears in the pfm file.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_no_data_value
//       Access: Published
//  Description: Sets the special value that means "no data" when it
//               appears in the pfm file.
////////////////////////////////////////////////////////////////////
134
void PfmFile::set_no_data_value(LPoint4f const &no_data_value);
inline void PfmFile::set_no_data_value(LPoint4d const &no_data_value);

530 21 set_no_data_threshold 0 4 683 30 PfmFile::set_no_data_threshold 0 2 164 165 754
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_no_data_threshold
//       Access: Published
//  Description: Sets the special threshold value.  Points that are
//               below this value in all components are considered "no
//               value".
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_no_data_threshold
//       Access: Published
//  Description: Sets the special threshold value.  Points that are
//               below this value in all components are considered "no
//               value".
////////////////////////////////////////////////////////////////////
142
void PfmFile::set_no_data_threshold(LPoint4f const &no_data_value);
inline void PfmFile::set_no_data_threshold(LPoint4d const &no_data_value);

531 19 clear_no_data_value 0 4 683 28 PfmFile::clear_no_data_value 0 1 166 382
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_no_data_value
//       Access: Published
//  Description: Removes the special value that means "no data" when it
//               appears in the pfm file.  All points will thus be
//               considered valid.
////////////////////////////////////////////////////////////////////
47
inline void PfmFile::clear_no_data_value(void);

532 17 has_no_data_value 0 4 683 26 PfmFile::has_no_data_value 0 1 167 321
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::has_no_data_value
//       Access: Published
//  Description: Returns whether a "no data" value has been
//               established by set_no_data_value().
////////////////////////////////////////////////////////////////////
51
inline bool PfmFile::has_no_data_value(void) const;

533 21 has_no_data_threshold 0 4 683 30 PfmFile::has_no_data_threshold 0 1 168 339
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::has_no_data_threshold
//       Access: Published
//  Description: Returns whether a "no data" threshold value has been
//               established by set_no_data_threshold().
////////////////////////////////////////////////////////////////////
55
inline bool PfmFile::has_no_data_threshold(void) const;

534 17 get_no_data_value 0 4 683 26 PfmFile::get_no_data_value 0 1 169 324
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::get_no_data_value
//       Access: Published
//  Description: If has_no_data_value() returns true, this returns the
//               particular "no data" value.
////////////////////////////////////////////////////////////////////
62
inline LPoint4f const &PfmFile::get_no_data_value(void) const;

535 6 resize 0 4 683 15 PfmFile::resize 0 1 170 422
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::resize
//       Access: Published
//  Description: 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().
////////////////////////////////////////////////////////////////////
53
void PfmFile::resize(int new_x_size, int new_y_size);

536 15 box_filter_from 0 4 683 24 PfmFile::box_filter_from 0 1 171 529
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::box_filter_from
//       Access: Public
//  Description: 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.
////////////////////////////////////////////////////////////////////
66
void PfmFile::box_filter_from(double radius, PfmFile const &copy);

537 20 gaussian_filter_from 0 4 683 29 PfmFile::gaussian_filter_from 0 1 172 534
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::gaussian_filter_from
//       Access: Public
//  Description: 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.
////////////////////////////////////////////////////////////////////
71
void PfmFile::gaussian_filter_from(double radius, PfmFile const &copy);

538 17 quick_filter_from 0 4 683 26 PfmFile::quick_filter_from 0 1 173 528
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::quick_filter_from
//       Access: Public
//  Description: 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.
////////////////////////////////////////////////////////////////////
53
void PfmFile::quick_filter_from(PfmFile const &copy);

539 12 reverse_rows 0 4 683 21 PfmFile::reverse_rows 0 1 174 271
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::reverse_rows
//       Access: Published
//  Description: Performs an in-place reversal of the row (y) data.
////////////////////////////////////////////////////////////////////
33
void PfmFile::reverse_rows(void);

540 4 flip 0 4 683 13 PfmFile::flip 0 1 175 661
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::flip
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
61
void PfmFile::flip(bool flip_x, bool flip_y, bool transpose);

541 5 xform 0 4 683 14 PfmFile::xform 0 2 176 177 588
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::xform
//       Access: Published
//  Description: Applies the indicated transform matrix to all points
//               in-place.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PfmFile::xform
//       Access: Published
//  Description: Applies the indicated transform matrix to all points
//               in-place.
////////////////////////////////////////////////////////////////////
104
void PfmFile::xform(LMatrix4f const &transform);
inline void PfmFile::xform(LMatrix4d const &transform);

542 15 forward_distort 0 4 683 24 PfmFile::forward_distort 0 2 178 179 1065
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::forward_distort
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
77
void PfmFile::forward_distort(PfmFile const &dist, float scale_factor = (1));

543 15 reverse_distort 0 4 683 24 PfmFile::reverse_distort 0 2 180 181 1063
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::reverse_distort
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
77
void PfmFile::reverse_distort(PfmFile const &dist, float scale_factor = (1));

544 5 merge 0 4 683 14 PfmFile::merge 0 1 182 447
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::merge
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
42
void PfmFile::merge(PfmFile const &other);

545 12 copy_channel 0 4 683 21 PfmFile::copy_channel 0 1 183 400
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::copy_channel
//       Access: Published
//  Description: Copies just the specified channel values from the
//               indicated PfmFile (which could be same as this
//               PfmFile) into the specified channel of this one.
////////////////////////////////////////////////////////////////////
83
void PfmFile::copy_channel(int to_channel, PfmFile const &other, int from_channel);

546 19 copy_channel_masked 0 4 683 28 PfmFile::copy_channel_masked 0 1 184 378
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::copy_channel_masked
//       Access: Published
//  Description: Copies just the specified channel values from the
//               indicated PfmFile, but only where the other file has
//               a data point.
////////////////////////////////////////////////////////////////////
90
void PfmFile::copy_channel_masked(int to_channel, PfmFile const &other, int from_channel);

547 10 apply_crop 0 4 683 19 PfmFile::apply_crop 0 1 185 387
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::apply_crop
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
73
void PfmFile::apply_crop(int x_begin, int x_end, int y_begin, int y_end);

548 18 clear_to_texcoords 0 4 683 27 PfmFile::clear_to_texcoords 0 1 186 406
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::clear_to_texcoords
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
57
void PfmFile::clear_to_texcoords(int x_size, int y_size);

549 9 pull_spot 0 4 683 18 PfmFile::pull_spot 0 1 187 528
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::pull_spot
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
107
int PfmFile::pull_spot(LPoint4f const &delta, double xc, double yc, double xr, double yr, double exponent);

550 17 calc_tight_bounds 0 4 683 26 PfmFile::calc_tight_bounds 0 1 188 487
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::calc_tight_bounds
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
80
bool PfmFile::calc_tight_bounds(LPoint3f &min_point, LPoint3f &max_point) const;

551 21 compute_planar_bounds 0 4 683 30 PfmFile::compute_planar_bounds 0 2 189 190 2080
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::compute_planar_bounds
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PfmFile::compute_planar_bounds
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
308
PointerTo< BoundingHexahedron > PfmFile::compute_planar_bounds(LPoint2f const &center, float point_dist, float sample_radius, bool points_only) const;
inline PointerTo< BoundingHexahedron > PfmFile::compute_planar_bounds(LPoint2d const &center, float point_dist, float sample_radius, bool points_only) const;

552 20 compute_sample_point 0 4 683 29 PfmFile::compute_sample_point 0 1 191 468
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::compute_sample_point
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
98
void PfmFile::compute_sample_point(LPoint3f &result, float x, float y, float sample_radius) const;

553 14 copy_sub_image 0 4 683 23 PfmFile::copy_sub_image 0 5 192 193 194 195 196 646
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::copy_sub_image
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
140
void PfmFile::copy_sub_image(PfmFile const &copy, int xto, int yto, int xfrom = (0), int yfrom = (0), int x_size = (-1), int y_size = (-1));

554 6 output 0 4 683 15 PfmFile::output 0 1 197 214
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::output
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
41
void PfmFile::output(ostream &out) const;

555 10 get_points 0 4 683 19 PfmFile::get_points 0 1 198 0
42
PyObject *PfmFile::get_points(void) const;

556 13 __getbuffer__ 0 4 683 22 PfmFile::__getbuffer__ 0 1 199 0
77
int PfmFile::__getbuffer__(PyObject *self, Py_buffer *view, int flags) const;

557 8 ~PfmFile 0 4 683 17 PfmFile::~PfmFile 0 0 0
24
PfmFile::~PfmFile(void);

558 16 make_transparent 0 4 684 26 PNMBrush::make_transparent 0 1 200 414
////////////////////////////////////////////////////////////////////
//     Function: PNMBrush::make_transparent
//       Access: Published, Static
//  Description: Returns a new brush that does not paint anything.
//               Can be used as either a pen or a fill brush to make
//               borderless or unfilled shapes, respectively.
////////////////////////////////////////////////////////////////////
62
static PointerTo< PNMBrush > PNMBrush::make_transparent(void);

559 10 make_pixel 0 4 684 20 PNMBrush::make_pixel 0 2 201 202 384
////////////////////////////////////////////////////////////////////
//     Function: PNMBrush::make_pixel
//       Access: Published, Static
//  Description: Returns a new brush that paints a single pixel of the
//               indicated color on a border, or paints a solid color
//               in an interior.
////////////////////////////////////////////////////////////////////
118
static PointerTo< PNMBrush > PNMBrush::make_pixel(LVecBase4d const &color, PNMBrush::BrushEffect effect = (BE_blend));

560 9 make_spot 0 4 684 19 PNMBrush::make_spot 0 2 203 204 401
////////////////////////////////////////////////////////////////////
//     Function: PNMBrush::make_spot
//       Access: Published, Static
//  Description: Returns a new brush that paints a spot of the
//               indicated color and radius.  If fuzzy is true, the
//               spot is fuzzy; otherwise, it is hard-edged.
////////////////////////////////////////////////////////////////////
144
static PointerTo< PNMBrush > PNMBrush::make_spot(LVecBase4d const &color, double radius, bool fuzzy, PNMBrush::BrushEffect effect = (BE_blend));

561 10 make_image 0 4 684 20 PNMBrush::make_image 0 2 205 206 537
////////////////////////////////////////////////////////////////////
//     Function: PNMBrush::make_image
//       Access: Published, Static
//  Description: Returns a new brush that paints with the indicated
//               image.  xc and yc indicate the pixel in the center of
//               the brush.
//
//               The brush makes a copy of the image; it is safe to
//               deallocate or modify the image after making this
//               call.
////////////////////////////////////////////////////////////////////
138
static PointerTo< PNMBrush > PNMBrush::make_image(PNMImage const &image, double xc, double yc, PNMBrush::BrushEffect effect = (BE_blend));

562 8 PNMImage 0 4 687 18 PNMImage::PNMImage 0 8 207 208 209 210 211 212 213 214 1375
// Filename: pnmImage.I
// Created by:  drose (15Jun00)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::Copy Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::Constructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
307
inline PNMImage::PNMImage(void);
PNMImage::PNMImage(Filename const &filename, PNMFileType *type = ((void *)(0)));
inline PNMImage::PNMImage(int x_size, int y_size, int num_channels = (3), unsigned short int maxval = (255), PNMFileType *type = ((void *)(0)));
inline PNMImage::PNMImage(PNMImage const &copy);

563 10 operator = 0 4 687 20 PNMImage::operator = 0 1 215 233
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::Copy Assignment Operator
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
55
inline void PNMImage::operator =(PNMImage const &copy);

564 9 ~PNMImage 0 4 687 19 PNMImage::~PNMImage 0 0 219
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::Destructor
//       Access: Published
//  Description:
////////////////////////////////////////////////////////////////////
33
inline PNMImage::~PNMImage(void);

565 9 clamp_val 0 4 687 19 PNMImage::clamp_val 0 1 216 290
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::clamp_val
//       Access: Published
//  Description: A handy function to clamp values to
//               [0..get_maxval()].
////////////////////////////////////////////////////////////////////
69
inline unsigned short int PNMImage::clamp_val(int input_value) const;

566 6 to_val 0 4 687 16 PNMImage::to_val 0 1 217 299
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::to_val
//       Access: Published
//  Description: A handy function to scale values from [0..1] to
//               [0..get_maxval()].
////////////////////////////////////////////////////////////////////
69
inline unsigned short int PNMImage::to_val(double input_value) const;

567 8 from_val 0 4 687 18 PNMImage::from_val 0 1 218 301
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::from_val
//       Access: Published
//  Description: A handy function to scale values from
//               [0..get_maxval()] to [0..1].
////////////////////////////////////////////////////////////////////
71
inline double PNMImage::from_val(unsigned short int input_value) const;

568 5 clear 0 4 687 15 PNMImage::clear 0 5 219 220 221 222 223 662
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::clear
//       Access: Published
//  Description: Frees all memory allocated for the image, and clears
//               all its parameters (size, color, type, etc).
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::clear
//       Access: Published
//  Description: This flavor of clear() reinitializes the image to an
//               empty (black) image with the given dimensions.
////////////////////////////////////////////////////////////////////
167
void PNMImage::clear(void);
void PNMImage::clear(int x_size, int y_size, int num_channels = (3), unsigned short int maxval = (255), PNMFileType *type = ((void *)(0)));

569 9 copy_from 0 4 687 19 PNMImage::copy_from 0 1 224 269
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::copy_from
//       Access: Published
//  Description: Makes this image become a copy of the other image.
////////////////////////////////////////////////////////////////////
47
void PNMImage::copy_from(PNMImage const &copy);

570 12 copy_channel 0 4 687 22 PNMImage::copy_channel 0 7 225 226 227 228 229 230 231 696
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::copy_channel
//       Access: Published
//  Description: Copies a channel from one image into another.
//               Images must be the same size
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::copy_channel
//       Access: Published
//  Description: Copies just a single channel from the source image
//               into a single channel of this image, leaving the
//               remaining channels alone.
////////////////////////////////////////////////////////////////////
252
void PNMImage::copy_channel(PNMImage const &copy, int src_channel, int dest_channel);
void PNMImage::copy_channel(PNMImage const &copy, int xto, int yto, int cto, int xfrom = (0), int yfrom = (0), int cfrom = (0), int x_size = (-1), int y_size = (-1));

571 16 copy_header_from 0 4 687 26 PNMImage::copy_header_from 0 1 232 445
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::copy_header_from
//       Access: Published
//  Description: Copies just the header information into this image.
//               This will blow away any image data stored in the
//               image.  The new image data will be allocated, but
//               left unitialized.
////////////////////////////////////////////////////////////////////
62
void PNMImage::copy_header_from(PNMImageHeader const &header);

572 9 take_from 0 4 687 19 PNMImage::take_from 0 1 233 314
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::take_from
//       Access: Published
//  Description: Move the contents of the other image into this one,
//               and empty the other image.
////////////////////////////////////////////////////////////////////
41
void PNMImage::take_from(PNMImage &orig);

573 4 fill 0 4 687 14 PNMImage::fill 0 3 234 235 236 610
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::fill
//       Access: Published
//  Description: Sets the entire image (except the alpha channel) to
//               the given color.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::fill
//       Access: Published
//  Description: Sets the entire image (except the alpha channel) to
//               the given grayscale level.
////////////////////////////////////////////////////////////////////
113
inline void PNMImage::fill(double red, double green, double blue);
inline void PNMImage::fill(double gray = (0));

574 8 fill_val 0 4 687 18 PNMImage::fill_val 0 3 237 238 239 618
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::fill_val
//       Access: Published
//  Description: Sets the entire image (except the alpha channel) to
//               the given grayscale level.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::fill_val
//       Access: Published
//  Description: Sets the entire image (except the alpha channel) to
//               the given color.
////////////////////////////////////////////////////////////////////
162
void PNMImage::fill_val(unsigned short int red, unsigned short int green, unsigned short int blue);
inline void PNMImage::fill_val(unsigned short int gray = (0));

575 10 alpha_fill 0 4 687 20 PNMImage::alpha_fill 0 2 240 241 269
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::alpha_fill
//       Access: Published
//  Description: Sets the entire alpha channel to the given level.
////////////////////////////////////////////////////////////////////
53
inline void PNMImage::alpha_fill(double alpha = (0));

576 14 alpha_fill_val 0 4 687 24 PNMImage::alpha_fill_val 0 2 242 243 273
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::alpha_fill_val
//       Access: Published
//  Description: Sets the entire alpha channel to the given level.
////////////////////////////////////////////////////////////////////
62
void PNMImage::alpha_fill_val(unsigned short int alpha = (0));

577 13 set_read_size 0 4 687 23 PNMImage::set_read_size 0 1 244 855
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_read_size
//       Access: Published
//  Description: Specifies the size to we'd like to scale the image
//               upon reading it.  This will affect the next call to
//               read().  This is usually used to reduce the image
//               size, e.g. for a thumbnail.
//
//               If the file type reader supports it (e.g. JPEG), then
//               this will scale the image during the read operation,
//               consequently reducing memory and CPU utilization.  If
//               the file type reader does not support it, this will
//               load the image normally, and them perform a linear
//               scale after it has been loaded.
////////////////////////////////////////////////////////////////////
60
inline void PNMImage::set_read_size(int x_size, int y_size);

578 15 clear_read_size 0 4 687 25 PNMImage::clear_read_size 0 1 245 298
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::clear_read_size
//       Access: Published
//  Description: Undoes the effect of a previous call to
//               set_read_size().
////////////////////////////////////////////////////////////////////
44
inline void PNMImage::clear_read_size(void);

579 13 has_read_size 0 4 687 23 PNMImage::has_read_size 0 1 246 271
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::has_read_size
//       Access: Published
//  Description: Returns true if set_read_size() has been called.
////////////////////////////////////////////////////////////////////
48
inline bool PNMImage::has_read_size(void) const;

580 15 get_read_x_size 0 4 687 25 PNMImage::get_read_x_size 0 1 247 384
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_read_x_size
//       Access: Published
//  Description: Returns the requested x_size of the image if
//               set_read_size() has been called, or the image x_size
//               otherwise (if it is known).
////////////////////////////////////////////////////////////////////
49
inline int PNMImage::get_read_x_size(void) const;

581 15 get_read_y_size 0 4 687 25 PNMImage::get_read_y_size 0 1 248 384
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_read_y_size
//       Access: Published
//  Description: Returns the requested y_size of the image if
//               set_read_size() has been called, or the image y_size
//               otherwise (if it is known).
////////////////////////////////////////////////////////////////////
49
inline int PNMImage::get_read_y_size(void) const;

582 4 read 0 4 687 14 PNMImage::read 0 8 249 250 251 252 253 254 255 256 1758
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::read
//       Access: Published
//  Description: Reads the indicated image filename.  If type is
//               non-NULL, it is a suggestion for the type of file it
//               is.  Returns true if successful, false on error.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::read
//       Access: Published
//  Description: Reads the image data from the indicated stream.
//
//               The filename is advisory only, and may be used
//               to suggest a type if it has a known extension.
//
//               If type is non-NULL, it is a suggestion for the type
//               of file it is (and a non-NULL type will override any
//               magic number test or filename extension lookup).
//
//               Returns true if successful, false on error.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::read
//       Access: Published
//  Description: This flavor of read() uses an already-existing
//               PNMReader to read the image file.  You can get a
//               reader via the PNMImageHeader::make_reader() methods.
//               This is a good way to examine the header of a file
//               (for instance, to determine its size) before actually
//               reading the entire image.
//
//               The PNMReader is always deleted upon completion,
//               whether successful or not.
////////////////////////////////////////////////////////////////////
309
bool PNMImage::read(Filename const &filename, PNMFileType *type = ((void *)(0)), bool report_unknown_type = (1));
bool PNMImage::read(istream &data, basic_string< char > const &filename = ((string())), PNMFileType *type = ((void *)(0)), bool report_unknown_type = (1));
bool PNMImage::read(PNMReader *reader);

583 5 write 0 4 687 15 PNMImage::write 0 6 257 258 259 260 261 262 1386
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::write
//       Access: Published
//  Description: Writes the image to the indicated filename.  If type
//               is non-NULL, it is a suggestion for the type of image
//               file to write.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::write
//       Access: Published
//  Description: Writes the image to the indicated ostream.
//
//               The filename is advisory only, and may be used
//               suggest a type if it has a known extension.
//
//               If type is non-NULL, it is a suggestion for the type
//               of image file to write.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::write
//       Access: Published
//  Description: This flavor of write() uses an already-existing
//               PNMWriter to write the image file.  You can get a
//               writer via the PNMImageHeader::make_writer() methods.
//
//               The PNMWriter is always deleted upon completion,
//               whether successful or not.
////////////////////////////////////////////////////////////////////
266
bool PNMImage::write(Filename const &filename, PNMFileType *type = ((void *)(0))) const;
bool PNMImage::write(ostream &data, basic_string< char > const &filename = ((string())), PNMFileType *type = ((void *)(0))) const;
bool PNMImage::write(PNMWriter *writer) const;

584 8 is_valid 0 4 687 18 PNMImage::is_valid 0 1 263 470
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::is_valid
//       Access: Published
//  Description: Returns true if the image has been read in or
//               correctly initialized with a height and width.  If
//               this returns false, virtually all member functions
//               except clear() and read() are invalid function calls.
////////////////////////////////////////////////////////////////////
43
inline bool PNMImage::is_valid(void) const;

585 16 set_num_channels 0 4 687 26 PNMImage::set_num_channels 0 1 264 531
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_num_channels
//       Access: Published
//  Description: Changes the number of channels associated with the
//               image.  The new number of channels must be an integer
//               in the range 1 through 4, inclusive.  This will
//               allocate and/or deallocate memory as necessary to
//               accommodate; see set_color_type().
////////////////////////////////////////////////////////////////////
57
inline void PNMImage::set_num_channels(int num_channels);

586 14 set_color_type 0 4 687 24 PNMImage::set_color_type 0 1 265 606
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_color_type
//       Access: Published
//  Description: Translates the image to or from grayscale, color, or
//               four-color mode.  Grayscale images are converted to
//               full-color images with R, G, B set to the original
//               gray level; color images are converted to grayscale
//               according to the value of Bright().  The alpha
//               channel, if added, is initialized to zero.
////////////////////////////////////////////////////////////////////
68
void PNMImage::set_color_type(PNMImageHeader::ColorType color_type);

587 9 add_alpha 0 4 687 19 PNMImage::add_alpha 0 1 266 365
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::add_alpha
//       Access: Published
//  Description: Adds an alpha channel to the image, if it does not
//               already have one.  The alpha channel is initialized
//               to zeros.
////////////////////////////////////////////////////////////////////
38
inline void PNMImage::add_alpha(void);

588 12 remove_alpha 0 4 687 22 PNMImage::remove_alpha 0 1 267 270
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::remove_alpha
//       Access: Published
//  Description: Removes the image's alpha channel, if it exists.
////////////////////////////////////////////////////////////////////
41
inline void PNMImage::remove_alpha(void);

589 14 make_grayscale 0 4 687 24 PNMImage::make_grayscale 0 2 268 269 839
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::make_grayscale
//       Access: Published
//  Description: Converts the image from RGB to grayscale.  Any alpha
//               channel, if present, is left undisturbed.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::make_grayscale
//       Access: Published
//  Description: Converts the image from RGB to grayscale.  Any alpha
//               channel, if present, is left undisturbed.  The
//               optional rc, gc, bc values represent the relative
//               weights to apply to each channel to convert it to
//               grayscale.
////////////////////////////////////////////////////////////////////
107
inline void PNMImage::make_grayscale(void);
void PNMImage::make_grayscale(double rc, double gc, double bc);

590 8 make_rgb 0 4 687 18 PNMImage::make_rgb 0 1 270 329
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::make_rgb
//       Access: Published
//  Description: Converts the image from grayscale to RGB.  Any alpha
//               channel, if present, is left undisturbed.
////////////////////////////////////////////////////////////////////
37
inline void PNMImage::make_rgb(void);

591 12 reverse_rows 0 4 687 22 PNMImage::reverse_rows 0 1 271 272
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::reverse_rows
//       Access: Published
//  Description: Performs an in-place reversal of the row (y) data.
////////////////////////////////////////////////////////////////////
34
void PNMImage::reverse_rows(void);

592 4 flip 0 4 687 14 PNMImage::flip 0 1 272 662
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::flip
//       Access: Published
//  Description: Reverses, transposes, and/or rotates the image
//               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.
////////////////////////////////////////////////////////////////////
62
void PNMImage::flip(bool flip_x, bool flip_y, bool transpose);

593 10 set_maxval 0 4 687 20 PNMImage::set_maxval 0 1 273 263
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_maxval
//       Access: Published
//  Description: Rescales the image to the indicated maxval.
////////////////////////////////////////////////////////////////////
53
void PNMImage::set_maxval(unsigned short int maxval);

594 11 get_xel_val 0 4 687 21 PNMImage::get_xel_val 0 1 274 565
// The *_val() functions return or set the color values in the range
// [0..get_maxval()].  This range may be different for different
// images!  Use the corresponding functions (without _val()) to work
// in the normalized range [0..1].

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_xel_val
//       Access: Published
//  Description: Returns the RGB color at the indicated pixel.  Each
//               component is in the range 0..maxval.
////////////////////////////////////////////////////////////////////
62
inline pixel const &PNMImage::get_xel_val(int x, int y) const;

595 11 set_xel_val 0 4 687 21 PNMImage::set_xel_val 0 3 275 276 277 1025
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_xel_val
//       Access: Published
//  Description: Changes the RGB color at the indicated pixel.  Each
//               component is in the range 0..maxval.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_xel_val
//       Access: Published
//  Description: Changes the RGB color at the indicated pixel.  Each
//               component is in the range 0..maxval.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_xel_val
//       Access: Published
//  Description: Changes all three color components at the indicated
//               pixel to the same value.  The value is in the range
//               0..maxval.
////////////////////////////////////////////////////////////////////
257
inline void PNMImage::set_xel_val(int x, int y, pixel const &value);
inline void PNMImage::set_xel_val(int x, int y, unsigned short int r, unsigned short int g, unsigned short int b);
inline void PNMImage::set_xel_val(int x, int y, unsigned short int gray);

596 11 get_red_val 0 4 687 21 PNMImage::get_red_val 0 1 278 340
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_red_val
//       Access: Published
//  Description: Returns the red component color at the indicated
//               pixel.  The value returned is in the range 0..maxval.
////////////////////////////////////////////////////////////////////
68
inline unsigned short int PNMImage::get_red_val(int x, int y) const;

597 13 get_green_val 0 4 687 23 PNMImage::get_green_val 0 1 279 344
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_green_val
//       Access: Published
//  Description: Returns the green component color at the indicated
//               pixel.  The value returned is in the range 0..maxval.
////////////////////////////////////////////////////////////////////
70
inline unsigned short int PNMImage::get_green_val(int x, int y) const;

598 12 get_blue_val 0 4 687 22 PNMImage::get_blue_val 0 1 280 342
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_blue_val
//       Access: Published
//  Description: Returns the blue component color at the indicated
//               pixel.  The value returned is in the range 0..maxval.
////////////////////////////////////////////////////////////////////
69
inline unsigned short int PNMImage::get_blue_val(int x, int y) const;

599 12 get_gray_val 0 4 687 22 PNMImage::get_gray_val 0 1 281 584
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_gray_val
//       Access: Published
//  Description: Returns the gray component color at the indicated
//               pixel.  This only has a meaningful value for
//               grayscale images; for other image types, this returns
//               the value of the blue channel only.  However, also
//               see the get_bright() function.  The value returned is
//               in the range 0..maxval.
////////////////////////////////////////////////////////////////////
69
inline unsigned short int PNMImage::get_gray_val(int x, int y) const;

600 13 get_alpha_val 0 4 687 23 PNMImage::get_alpha_val 0 1 282 435
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_alpha_val
//       Access: Published
//  Description: Returns the alpha component color at the indicated
//               pixel.  It is an error to call this unless
//               has_alpha() is true.  The value returned is in the
//               range 0..maxval.
////////////////////////////////////////////////////////////////////
70
inline unsigned short int PNMImage::get_alpha_val(int x, int y) const;

601 11 set_red_val 0 4 687 21 PNMImage::set_red_val 0 1 283 363
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_red_val
//       Access: Published
//  Description: Sets the red component color only at the indicated
//               pixel.  The value given should be in the range
//               0..maxval.
////////////////////////////////////////////////////////////////////
70
inline void PNMImage::set_red_val(int x, int y, unsigned short int r);

602 13 set_green_val 0 4 687 23 PNMImage::set_green_val 0 1 284 367
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_green_val
//       Access: Published
//  Description: Sets the green component color only at the indicated
//               pixel.  The value given should be in the range
//               0..maxval.
////////////////////////////////////////////////////////////////////
72
inline void PNMImage::set_green_val(int x, int y, unsigned short int g);

603 12 set_blue_val 0 4 687 22 PNMImage::set_blue_val 0 1 285 365
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_blue_val
//       Access: Published
//  Description: Sets the blue component color only at the indicated
//               pixel.  The value given should be in the range
//               0..maxval.
////////////////////////////////////////////////////////////////////
71
inline void PNMImage::set_blue_val(int x, int y, unsigned short int b);

604 12 set_gray_val 0 4 687 22 PNMImage::set_gray_val 0 1 286 723
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_gray_val
//       Access: Published
//  Description: Sets the gray component color at the indicated
//               pixel.  This is only meaningful for grayscale images;
//               for other image types, this simply sets the blue
//               component color.  However, also see set_xel_val(),
//               which can set all the component colors to the same
//               grayscale level, and hence works correctly both for
//               grayscale and color images.  The value given should
//               be in the range 0..maxval.
////////////////////////////////////////////////////////////////////
74
inline void PNMImage::set_gray_val(int x, int y, unsigned short int gray);

605 13 set_alpha_val 0 4 687 23 PNMImage::set_alpha_val 0 1 287 441
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_alpha_val
//       Access: Published
//  Description: Sets the alpha component color only at the indicated
//               pixel.  It is an error to call this unless
//               has_alpha() is true.  The value given should be in
//               the range 0..maxval.
////////////////////////////////////////////////////////////////////
72
inline void PNMImage::set_alpha_val(int x, int y, unsigned short int a);

606 15 get_channel_val 0 4 687 25 PNMImage::get_channel_val 0 1 288 630
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_channel_val
//       Access: Published
//  Description: Returns the nth component color at the indicated
//               pixel.  The channel index should be in the range
//               0..(get_num_channels()-1).  The channels are ordered B,
//               G, R, A.  This is slightly less optimal than
//               accessing the component values directly by named
//               methods.  The value returned is in the range
//               0..maxval.
////////////////////////////////////////////////////////////////////
78
unsigned short int PNMImage::get_channel_val(int x, int y, int channel) const;

607 15 set_channel_val 0 4 687 25 PNMImage::set_channel_val 0 1 289 629
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_channel_val
//       Access: Published
//  Description: Sets the nth component color at the indicated
//               pixel.  The channel index should be in the range
//               0..(get_num_channels()-1).  The channels are ordered B,
//               G, R, A.  This is slightly less optimal than
//               setting the component values directly by named
//               methods.  The value given should be in the range
//               0..maxval.
////////////////////////////////////////////////////////////////////
84
void PNMImage::set_channel_val(int x, int y, int channel, unsigned short int value);

608 9 get_pixel 0 4 687 19 PNMImage::get_pixel 0 1 290 322
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_pixel
//       Access: Published
//  Description: Returns the (r, g, b, a) pixel value at the indicated
//               pixel, using a PixelSpec object.
////////////////////////////////////////////////////////////////////
66
PNMImageHeader::PixelSpec PNMImage::get_pixel(int x, int y) const;

609 9 set_pixel 0 4 687 19 PNMImage::set_pixel 0 1 291 319
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_pixel
//       Access: Published
//  Description: Sets the (r, g, b, a) pixel value at the indicated
//               pixel, using a PixelSpec object.
////////////////////////////////////////////////////////////////////
79
void PNMImage::set_pixel(int x, int y, PNMImageHeader::PixelSpec const &pixel);

610 7 get_xel 0 4 687 17 PNMImage::get_xel 0 1 292 474
// The corresponding get_xel(), set_xel(), get_red(), etc. functions
// automatically scale their values by get_maxval() into the range
// [0..1].

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_xel
//       Access: Published
//  Description: Returns the RGB color at the indicated pixel.  Each
//               component is a double in the range 0..1.
////////////////////////////////////////////////////////////////////
56
inline LVecBase3d PNMImage::get_xel(int x, int y) const;

611 7 set_xel 0 4 687 17 PNMImage::set_xel 0 3 293 294 295 1025
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_xel
//       Access: Published
//  Description: Changes the RGB color at the indicated pixel.  Each
//               component is a double in the range 0..1.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_xel
//       Access: Published
//  Description: Changes the RGB color at the indicated pixel.  Each
//               component is a double in the range 0..1.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_xel
//       Access: Published
//  Description: Changes all three color components at the indicated
//               pixel to the same value.  The value is a double in
//               the range 0..1.
////////////////////////////////////////////////////////////////////
202
inline void PNMImage::set_xel(int x, int y, LVecBase3d const &value);
inline void PNMImage::set_xel(int x, int y, double r, double g, double b);
inline void PNMImage::set_xel(int x, int y, double gray);

612 9 get_xel_a 0 4 687 19 PNMImage::get_xel_a 0 1 296 329
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_xel_a
//       Access: Published
//  Description: Returns the RGBA color at the indicated pixel.  Each
//               component is a double in the range 0..1.
////////////////////////////////////////////////////////////////////
58
inline LVecBase4d PNMImage::get_xel_a(int x, int y) const;

613 9 set_xel_a 0 4 687 19 PNMImage::set_xel_a 0 2 297 298 660
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_xel_a
//       Access: Published
//  Description: Changes the RGBA color at the indicated pixel.  Each
//               component is a double in the range 0..1.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_xel_a
//       Access: Published
//  Description: Changes the RGBA color at the indicated pixel.  Each
//               component is a double in the range 0..1.
////////////////////////////////////////////////////////////////////
158
inline void PNMImage::set_xel_a(int x, int y, LVecBase4d const &value);
inline void PNMImage::set_xel_a(int x, int y, double r, double g, double b, double a);

614 7 get_red 0 4 687 17 PNMImage::get_red 0 1 299 357
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_red
//       Access: Published
//  Description: Returns the red component color at the indicated
//               pixel.  The value returned is a double in the range
//               0..1.
////////////////////////////////////////////////////////////////////
52
inline double PNMImage::get_red(int x, int y) const;

615 9 get_green 0 4 687 19 PNMImage::get_green 0 1 300 361
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_green
//       Access: Published
//  Description: Returns the green component color at the indicated
//               pixel.  The value returned is a double in the range
//               0..1.
////////////////////////////////////////////////////////////////////
54
inline double PNMImage::get_green(int x, int y) const;

616 8 get_blue 0 4 687 18 PNMImage::get_blue 0 1 301 359
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_blue
//       Access: Published
//  Description: Returns the blue component color at the indicated
//               pixel.  The value returned is a double in the range
//               0..1.
////////////////////////////////////////////////////////////////////
53
inline double PNMImage::get_blue(int x, int y) const;

617 8 get_gray 0 4 687 18 PNMImage::get_gray 0 1 302 584
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_gray
//       Access: Published
//  Description: Returns the gray component color at the indicated
//               pixel.  This only has a meaningful value for
//               grayscale images; for other image types, this returns
//               the value of the blue channel only.  However, also
//               see the get_bright() function.  The value returned is
//               a double in the range 0..1.
////////////////////////////////////////////////////////////////////
53
inline double PNMImage::get_gray(int x, int y) const;

618 9 get_alpha 0 4 687 19 PNMImage::get_alpha 0 1 303 435
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_alpha
//       Access: Published
//  Description: Returns the alpha component color at the indicated
//               pixel.  It is an error to call this unless
//               has_alpha() is true.  The value returned is a double
//               in the range 0..1.
////////////////////////////////////////////////////////////////////
54
inline double PNMImage::get_alpha(int x, int y) const;

619 7 set_red 0 4 687 17 PNMImage::set_red 0 1 304 363
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_red
//       Access: Published
//  Description: Sets the red component color only at the indicated
//               pixel.  The value given should be a double in the
//               range 0..1.
////////////////////////////////////////////////////////////////////
54
inline void PNMImage::set_red(int x, int y, double r);

620 9 set_green 0 4 687 19 PNMImage::set_green 0 1 305 367
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_green
//       Access: Published
//  Description: Sets the green component color only at the indicated
//               pixel.  The value given should be a double in the
//               range 0..1.
////////////////////////////////////////////////////////////////////
56
inline void PNMImage::set_green(int x, int y, double g);

621 8 set_blue 0 4 687 18 PNMImage::set_blue 0 1 306 365
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_blue
//       Access: Published
//  Description: Sets the blue component color only at the indicated
//               pixel.  The value given should be a double in the
//               range 0..1.
////////////////////////////////////////////////////////////////////
55
inline void PNMImage::set_blue(int x, int y, double b);

622 8 set_gray 0 4 687 18 PNMImage::set_gray 0 1 307 719
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_gray
//       Access: Published
//  Description: Sets the gray component color at the indicated
//               pixel.  This is only meaningful for grayscale images;
//               for other image types, this simply sets the blue
//               component color.  However, also see set_xel(), which
//               can set all the component colors to the same
//               grayscale level, and hence works correctly both for
//               grayscale and color images.  The value given should
//               be a double in the range 0..1.
////////////////////////////////////////////////////////////////////
58
inline void PNMImage::set_gray(int x, int y, double gray);

623 9 set_alpha 0 4 687 19 PNMImage::set_alpha 0 1 308 432
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_alpha
//       Access: Published
//  Description: Sets the alpha component color only at the indicated
//               pixel.  It is an error to call this unless
//               has_alpha() is true.  The value given should be in
//               the range 0..1.
////////////////////////////////////////////////////////////////////
56
inline void PNMImage::set_alpha(int x, int y, double a);

624 11 get_channel 0 4 687 21 PNMImage::get_channel 0 1 309 630
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_channel
//       Access: Published
//  Description: Returns the nth component color at the indicated
//               pixel.  The channel index should be in the range
//               0..(get_num_channels()-1).  The channels are ordered B,
//               G, R, A.  This is slightly less optimal than
//               accessing the component values directly by named
//               methods.  The value returned is a double in the range
//               0..1.
////////////////////////////////////////////////////////////////////
69
inline double PNMImage::get_channel(int x, int y, int channel) const;

625 11 set_channel 0 4 687 21 PNMImage::set_channel 0 1 310 633
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_channel_val
//       Access: Published
//  Description: Sets the nth component color at the indicated
//               pixel.  The channel index should be in the range
//               0..(get_num_channels()-1).  The channels are ordered B,
//               G, R, A.  This is slightly less optimal than
//               setting the component values directly by named
//               methods.  The value given should be a double in the
//               range 0..1.
////////////////////////////////////////////////////////////////////
75
inline void PNMImage::set_channel(int x, int y, int channel, double value);

626 10 get_bright 0 4 687 20 PNMImage::get_bright 0 3 311 312 313 1413
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_bright
//       Access: Published
//  Description: Returns the linear brightness of the given xel, as a
//               double in the range 0..1.  This flavor of
//               get_bright() returns the correct grayscale brightness
//               level for both full-color and grayscale images.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_bright
//       Access: Published
//  Description: This flavor of get_bright() works correctly only for
//               color images.  It returns a single brightness value
//               for the RGB color at the indicated pixel, based on
//               the supplied weights for each component.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_bright
//       Access: Published
//  Description: This flavor of get_bright() works correctly only for
//               four-channel images.  It returns a single brightness
//               value for the RGBA color at the indicated pixel,
//               based on the supplied weights for each component.
////////////////////////////////////////////////////////////////////
244
inline double PNMImage::get_bright(int x, int y) const;
inline double PNMImage::get_bright(int x, int y, double rc, double gc, double bc) const;
inline double PNMImage::get_bright(int x, int y, double rc, double gc, double bc, double ac) const;

627 5 blend 0 4 687 15 PNMImage::blend 0 2 314 315 1080
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::blend
//       Access: Published
//  Description: Smoothly blends the indicated pixel value in with
//               whatever was already in the image, based on the given
//               alpha value.  An alpha of 1.0 is fully opaque and
//               completely replaces whatever was there previously;
//               alpha of 0.0 is fully transparent and does nothing.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::blend
//       Access: Published
//  Description: Smoothly blends the indicated pixel value in with
//               whatever was already in the image, based on the given
//               alpha value.  An alpha of 1.0 is fully opaque and
//               completely replaces whatever was there previously;
//               alpha of 0.0 is fully transparent and does nothing.
////////////////////////////////////////////////////////////////////
159
inline void PNMImage::blend(int x, int y, LVecBase3d const &val, double alpha);
void PNMImage::blend(int x, int y, double r, double g, double b, double alpha);

628 11 operator [] 0 4 687 21 PNMImage::operator [] 0 2 316 317 784
// If you're used to the NetPBM library and like working with a 2-d
// array of xels, and using the PNM macros to access their components,
// you may treat the PNMImage as such directly.

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::Array Operator
//       Access: Published
//  Description: Allows the PNMImage to appear to be a 2-d array of
//               xels.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::Array Operator
//       Access: Published
//  Description: Allows the PNMImage to appear to be a 2-d array of
//               xels.
////////////////////////////////////////////////////////////////////
99
inline pixel *PNMImage::operator [](int y);
inline pixel const *PNMImage::operator [](int y) const;

629 14 copy_sub_image 0 4 687 24 PNMImage::copy_sub_image 0 5 318 319 320 321 322 647
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::copy_sub_image
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
142
void PNMImage::copy_sub_image(PNMImage const &copy, int xto, int yto, int xfrom = (0), int yfrom = (0), int x_size = (-1), int y_size = (-1));

630 15 blend_sub_image 0 4 687 25 PNMImage::blend_sub_image 0 6 323 324 325 326 327 328 770
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::blend_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), except the alpha
//               channel of the copy is used to blend the copy into
//               the destination image, instead of overwriting pixels
//               unconditionally.
//
//               If pixel_scale is not 1.0, it specifies an amount to
//               scale each *alpha* value of the source image before
//               applying it to the target image.
//
//               If pixel_scale is 1.0 and the copy has no alpha
//               channel, this degenerates into copy_sub_image().
////////////////////////////////////////////////////////////////////
169
void PNMImage::blend_sub_image(PNMImage const &copy, int xto, int yto, int xfrom = (0), int yfrom = (0), int x_size = (-1), int y_size = (-1), double pixel_scale = (1));

631 13 add_sub_image 0 4 687 23 PNMImage::add_sub_image 0 6 329 330 331 332 333 334 503
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::add_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), except the copy pixels
//               are added to the pixels of the destination, after
//               scaling by the specified pixel_scale.  Unlike
//               blend_sub_image(), the alpha channel is not treated
//               specially.
////////////////////////////////////////////////////////////////////
167
void PNMImage::add_sub_image(PNMImage const &copy, int xto, int yto, int xfrom = (0), int yfrom = (0), int x_size = (-1), int y_size = (-1), double pixel_scale = (1));

632 14 mult_sub_image 0 4 687 24 PNMImage::mult_sub_image 0 6 335 336 337 338 339 340 509
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::mult_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), except the copy pixels
//               are multiplied to the pixels of the destination, after
//               scaling by the specified pixel_scale.  Unlike
//               blend_sub_image(), the alpha channel is not treated
//               specially.
////////////////////////////////////////////////////////////////////
168
void PNMImage::mult_sub_image(PNMImage const &copy, int xto, int yto, int xfrom = (0), int yfrom = (0), int x_size = (-1), int y_size = (-1), double pixel_scale = (1));

633 16 darken_sub_image 0 4 687 26 PNMImage::darken_sub_image 0 6 341 342 343 344 345 346 770
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::darken_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), but the resulting
//               color will be the darker of the source and
//               destination colors at each pixel (and at each R, G,
//               B, A component value).
//
//               If pixel_scale is not 1.0, it specifies an amount to
//               scale each pixel value of the source image before
//               applying it to the target image.  The scale is
//               applied with the center at 1.0: scaling the pixel
//               value smaller brings it closer to 1.0.
////////////////////////////////////////////////////////////////////
170
void PNMImage::darken_sub_image(PNMImage const &copy, int xto, int yto, int xfrom = (0), int yfrom = (0), int x_size = (-1), int y_size = (-1), double pixel_scale = (1));

634 17 lighten_sub_image 0 4 687 27 PNMImage::lighten_sub_image 0 6 347 348 349 350 351 352 635
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::lighten_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), but the resulting
//               color will be the lighter of the source and
//               destination colors at each pixel (and at each R, G,
//               B, A component value).
//
//               If pixel_scale is not 1.0, it specifies an amount to
//               scale each pixel value of the source image before
//               applying it to the target image.
////////////////////////////////////////////////////////////////////
171
void PNMImage::lighten_sub_image(PNMImage const &copy, int xto, int yto, int xfrom = (0), int yfrom = (0), int x_size = (-1), int y_size = (-1), double pixel_scale = (1));

635 9 threshold 0 4 687 19 PNMImage::threshold 0 1 353 1004
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::threshold
//       Access: Published
//  Description: Selectively copies each pixel from either one source
//               or another source, depending on the pixel value of
//               the indicated channel of select_image.
//
//               For each pixel (x, y):
//
//               s = select_image.get_channel(x, y, channel). Set this
//               image's (x, y) to:
//
//               lt.get_xel(x, y) if s < threshold, or
//
//               ge.get_xel(x, y) if s >= threshold
//
//               Any of select_image, lt, or ge may be the same
//               PNMImge object as this image, or the same as each
//               other; or they may all be different. All images must
//               be the same size.  As a special case, lt and ge may
//               both be 1x1 images instead of the source image size.
////////////////////////////////////////////////////////////////////
126
void PNMImage::threshold(PNMImage const &select_image, int channel, double threshold, PNMImage const &lt, PNMImage const &ge);

636 20 fill_distance_inside 0 4 687 30 PNMImage::fill_distance_inside 0 1 354 1231
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::fill_distance_inside
//       Access: Published
//  Description: Replaces this image with a grayscale image whose gray
//               channel represents the linear Manhattan distance from
//               the nearest dark pixel in the given mask image, up to
//               the specified radius value (which also becomes the
//               new maxval).  radius may range from 0 to maxmaxval;
//               smaller values will compute faster.  A dark pixel is
//               defined as one whose pixel value is < threshold.
//
//               If shrink_from_border is true, then the mask image is
//               considered to be surrounded by a border of dark
//               pixels; otherwise, the border isn't considered.
//
//               This can be used, in conjunction with threshold, to
//               shrink a mask image inwards by a certain number of
//               pixels.
//
//               The mask image may be the same image as this one, in
//               which case it is destructively modified by this
//               process.
////////////////////////////////////////////////////////////////////
113
void PNMImage::fill_distance_inside(PNMImage const &mask, double threshold, int radius, bool shrink_from_border);

637 21 fill_distance_outside 0 4 687 31 PNMImage::fill_distance_outside 0 1 355 1030
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::fill_distance_outside
//       Access: Published
//  Description: Replaces this image with a grayscale image whose gray
//               channel represents the linear Manhattan distance from
//               the nearest white pixel in the given mask image, up to
//               the specified radius value (which also becomes the
//               new maxval).  radius may range from 0 to maxmaxval;
//               smaller values will compute faster.  A white pixel is
//               defined as one whose pixel value is >= threshold.
//
//               This can be used, in conjunction with threshold, to
//               grow a mask image outwards by a certain number of
//               pixels.
//
//               The mask image may be the same image as this one, in
//               which case it is destructively modified by this
//               process.
////////////////////////////////////////////////////////////////////
89
void PNMImage::fill_distance_outside(PNMImage const &mask, double threshold, int radius);

638 7 rescale 0 4 687 17 PNMImage::rescale 0 1 356 537
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::rescale
//       Access: Published
//  Description: Rescales the RGB channel values so that any values in
//               the original image between min_val and max_val are
//               expanded to the range 0 .. 1.  Values below min_val
//               are set to 0, and values above max_val are set to 1.
//               Does not affect the alpha channel, if any.
////////////////////////////////////////////////////////////////////
55
void PNMImage::rescale(double min_val, double max_val);

639 11 render_spot 0 4 687 21 PNMImage::render_spot 0 1 357 781
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::render_spot
//       Access: Published
//  Description: Renders a solid-color circle, with a fuzzy edge, into
//               the center of the PNMImage.  If the PNMImage is
//               non-square, this actually renders an ellipse.
//
//               The min_radius and max_radius are in the scale 0..1,
//               where 1.0 means the full width of the image.  If
//               min_radius == max_radius, the edge is sharp (but
//               still antialiased); otherwise, the pixels between
//               min_radius and max_radius are smoothly blended
//               between fg and bg colors.
////////////////////////////////////////////////////////////////////
109
void PNMImage::render_spot(LVecBase4d const &fg, LVecBase4d const &bg, double min_radius, double max_radius);

640 13 expand_border 0 4 687 23 PNMImage::expand_border 0 1 358 472
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::expand_border
//       Access: Published
//  Description: Expands the image by the indicated number of pixels
//               on each edge.  The new pixels are set to the
//               indicated color.
//
//               If any of the values is negative, this actually crops
//               the image.
////////////////////////////////////////////////////////////////////
96
void PNMImage::expand_border(int left, int right, int bottom, int top, LVecBase4d const &color);

641 10 box_filter 0 4 687 20 PNMImage::box_filter 0 2 359 360 499
// The bodies for the non-inline *_filter() functions can be found
// in the file pnm-image-filter.cxx.

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::box_filter
//       Access: Published
//  Description: This flavor of box_filter() will apply the filter
//               over the entire image without resizing or copying;
//               the effect is that of a blur operation.
////////////////////////////////////////////////////////////////////
54
inline void PNMImage::box_filter(double radius = (1));

642 15 gaussian_filter 0 4 687 25 PNMImage::gaussian_filter 0 2 361 362 404
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::gaussian_filter
//       Access: Published
//  Description: This flavor of gaussian_filter() will apply the filter
//               over the entire image without resizing or copying;
//               the effect is that of a blur operation.
////////////////////////////////////////////////////////////////////
59
inline void PNMImage::gaussian_filter(double radius = (1));

643 23 unfiltered_stretch_from 0 4 687 33 PNMImage::unfiltered_stretch_from 0 1 363 334
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::unfiltered_stretch_from
//       Access: Published
//  Description: Resizes from the indicated image into this one by
//               performing a nearest-point sample.
////////////////////////////////////////////////////////////////////
61
void PNMImage::unfiltered_stretch_from(PNMImage const &copy);

644 15 box_filter_from 0 4 687 25 PNMImage::box_filter_from 0 1 364 530
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::box_filter_from
//       Access: Public
//  Description: 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.
////////////////////////////////////////////////////////////////////
68
void PNMImage::box_filter_from(double radius, PNMImage const &copy);

645 20 gaussian_filter_from 0 4 687 30 PNMImage::gaussian_filter_from 0 1 365 535
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::gaussian_filter_from
//       Access: Public
//  Description: 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.
////////////////////////////////////////////////////////////////////
73
void PNMImage::gaussian_filter_from(double radius, PNMImage const &copy);

646 17 quick_filter_from 0 4 687 27 PNMImage::quick_filter_from 0 3 366 367 368 731
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::quick_filter_from
//       Access: Public
//  Description: 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.  If borders are
//               specified, they will further restrict the size of the
//               resulting image. There's no point in using
//               quick_box_filter() on a single image.
////////////////////////////////////////////////////////////////////
93
void PNMImage::quick_filter_from(PNMImage const &copy, int xborder = (0), int yborder = (0));

647 14 make_histogram 0 4 687 24 PNMImage::make_histogram 0 1 369 294
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::make_histogram
//       Access: Published
//  Description: Computes a histogram of the colors used in the
//               image.
////////////////////////////////////////////////////////////////////
63
void PNMImage::make_histogram(PNMImageHeader::Histogram &hist);

648 17 perlin_noise_fill 0 4 687 27 PNMImage::perlin_noise_fill 0 4 370 371 372 373 880
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::perlin_noise_fill
//       Access: Published
//  Description: Fills the image with a grayscale perlin noise
//               pattern based on the indicated parameters.
//               Uses set_xel to set the grayscale values.
//               The sx and sy parameters are in multiples
//               of the size of this image.
//               See also the PerlinNoise2 class in mathutil.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::perlin_noise_fill
//       Access: Published
//  Description: Variant of perlin_noise_fill that uses an
//               existing StackedPerlinNoise2 object.
////////////////////////////////////////////////////////////////////
172
void PNMImage::perlin_noise_fill(double sx, double sy, int table_size = (256), unsigned long int seed = (0));
void PNMImage::perlin_noise_fill(StackedPerlinNoise2 &perlin);

649 14 remix_channels 0 4 687 24 PNMImage::remix_channels 0 1 374 370
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::remix_channels
//       Access: Published
//  Description: Transforms every pixel using the operation
//               (Ro,Go,Bo) = conv.xform_point(Ri,Gi,Bi);
//               Input must be a color image.
////////////////////////////////////////////////////////////////////
53
void PNMImage::remix_channels(LMatrix4f const &conv);

650 13 gamma_correct 0 4 687 23 PNMImage::gamma_correct 0 1 375 474
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::gamma_correct
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
72
inline void PNMImage::gamma_correct(double from_gamma, double to_gamma);

651 19 gamma_correct_alpha 0 4 687 29 PNMImage::gamma_correct_alpha 0 1 376 481
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::gamma_correct_alpha
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
78
inline void PNMImage::gamma_correct_alpha(double from_gamma, double to_gamma);

652 14 apply_exponent 0 4 687 24 PNMImage::apply_exponent 0 4 377 378 379 380 1934
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::apply_exponent
//       Access: Published
//  Description: Adjusts each channel of the image by raising the
//               corresponding component value to the indicated
//               exponent, such that L' = L ^ exponent.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::apply_exponent
//       Access: Published
//  Description: Adjusts each channel of the image by raising the
//               corresponding component value to the indicated
//               exponent, such that L' = L ^ exponent.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::apply_exponent
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::apply_exponent
//       Access: Published
//  Description: 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.
////////////////////////////////////////////////////////////////////
366
inline void PNMImage::apply_exponent(double gray_exponent);
inline void PNMImage::apply_exponent(double gray_exponent, double alpha_exponent);
inline void PNMImage::apply_exponent(double red_exponent, double green_exponent, double blue_exponent);
void PNMImage::apply_exponent(double red_exponent, double green_exponent, double blue_exponent, double alpha_exponent);

653 15 get_average_xel 0 4 687 25 PNMImage::get_average_xel 0 1 381 302
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_average_xel
//       Access: Published
//  Description: Returns the average color of all of the pixels
//               in the image.
////////////////////////////////////////////////////////////////////
49
LVecBase3d PNMImage::get_average_xel(void) const;

654 17 get_average_xel_a 0 4 687 27 PNMImage::get_average_xel_a 0 1 382 333
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_average_xel_a
//       Access: Published
//  Description: Returns the average color of all of the pixels
//               in the image, including the alpha channel.
////////////////////////////////////////////////////////////////////
51
LVecBase4d PNMImage::get_average_xel_a(void) const;

655 16 get_average_gray 0 4 687 26 PNMImage::get_average_gray 0 1 383 317
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_average_gray
//       Access: Published
//  Description: Returns the average grayscale component of all of
//               the pixels in the image.
////////////////////////////////////////////////////////////////////
46
double PNMImage::get_average_gray(void) const;

656 16 do_fill_distance 0 4 687 26 PNMImage::do_fill_distance 0 1 384 343
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::do_fill_distance
//       Access: Private
//  Description: Recursively fills in the minimum distance measured
//               from a certain set of points into the gray channel.
////////////////////////////////////////////////////////////////////
55
void PNMImage::do_fill_distance(int xi, int yi, int d);

657 10 operator ~ 0 68 687 20 PNMImage::operator ~ 0 1 385 307
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator ~
//       Access: Published
//  Description: Returns a new PNMImage that is the
//               complement of the current PNMImage.
////////////////////////////////////////////////////////////////////
42
PNMImage PNMImage::operator ~(void) const;

658 10 operator + 0 4 687 20 PNMImage::operator + 0 2 386 387 772
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator +
//       Access: Published
//  Description: Returns a new PNMImage in which each pixel value
//               is the sum of the corresponding pixel values
//               in the two given images.
//               Only valid when both images have the same size.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator +
//       Access: Published
//  Description: Returns a new PNMImage in which the provided color
//               is added to each pixel in the provided image.
////////////////////////////////////////////////////////////////////
135
inline PNMImage PNMImage::operator +(PNMImage const &other) const;
inline PNMImage PNMImage::operator +(LVecBase4d const &other) const;

659 10 operator - 0 4 687 20 PNMImage::operator - 0 2 388 389 787
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator -
//       Access: Published
//  Description: Returns a new PNMImage in which each pixel value
//               from the right image is subtracted from each
//               pixel value from the left image.
//               Only valid when both images have the same size.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator -
//       Access: Published
//  Description: Returns a new PNMImage in which the provided color
//               is subtracted from each pixel in the provided image.
////////////////////////////////////////////////////////////////////
135
inline PNMImage PNMImage::operator -(PNMImage const &other) const;
inline PNMImage PNMImage::operator -(LVecBase4d const &other) const;

660 10 operator * 0 4 687 20 PNMImage::operator * 0 3 390 391 392 1242
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator *
//       Access: Published
//  Description: Returns a new PNMImage in which each pixel value
//               from the left image is multiplied by each
//               pixel value from the right image. Note that the
//               floating-point values in the 0..1 range are
//               multiplied, not in the 0..maxval range.
//               Only valid when both images have the same size.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator *
//       Access: Published
//  Description: Multiplies every pixel value in the image by
//               a constant floating-point multiplier value.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator *
//       Access: Published
//  Description: Returns a new PNMImage in which the provided color
//               is multiplied to each pixel in the provided image.
////////////////////////////////////////////////////////////////////
198
inline PNMImage PNMImage::operator *(PNMImage const &other) const;
inline PNMImage PNMImage::operator *(double multiplier) const;
inline PNMImage PNMImage::operator *(LVecBase4d const &other) const;

661 11 operator += 0 4 687 21 PNMImage::operator += 0 2 393 394 670
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator +=
//       Access: Published
//  Description: Sets each pixel value to the sum of the corresponding
//               pixel values in the two given images.  Only valid
//               when both images have the same size.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator +=
//       Access: Published
//  Description: Adds the provided color to each pixel in this image.
////////////////////////////////////////////////////////////////////
103
void PNMImage::operator +=(PNMImage const &other);
void PNMImage::operator +=(LVecBase4d const &other);

662 11 operator -= 0 4 687 21 PNMImage::operator -= 0 2 395 396 681
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator -=
//       Access: Published
//  Description: Subtracts each pixel from the right image from each
//               pixel value in this image.  Only valid when both
//               images have the same size.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator -=
//       Access: Published
//  Description: Subtracts the provided color from each pixel in this
//               image.
////////////////////////////////////////////////////////////////////
103
void PNMImage::operator -=(PNMImage const &other);
void PNMImage::operator -=(LVecBase4d const &other);

663 11 operator *= 0 4 687 21 PNMImage::operator *= 0 3 397 398 399 1136
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator *=
//       Access: Published
//  Description: Multiples each pixel in this image by each
//               pixel value from the right image. Note that the
//               floating-point values in the 0..1 range are
//               multiplied, not in the 0..maxval range.
//               Only valid when both images have the same size.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator *=
//       Access: Published
//  Description: Multiplies every pixel value in the image by
//               a constant floating-point multiplier value.
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator *=
//       Access: Published
//  Description: Multiples the provided color to each pixel in this
//               image.
////////////////////////////////////////////////////////////////////
150
void PNMImage::operator *=(PNMImage const &other);
void PNMImage::operator *=(double multiplier);
void PNMImage::operator *=(LVecBase4d const &other);

664 10 PNMPainter 0 4 688 22 PNMPainter::PNMPainter 0 3 400 401 402 896
////////////////////////////////////////////////////////////////////
//     Function: PNMPainter::Constructor
//       Access: Published
//  Description: The constructor stores a pointer to the PNMImage you
//               pass it, but it does not take ownership of the
//               object; you are responsible for ensuring that the
//               PNMImage does not destruct during the lifetime of the
//               PNMPainter object.
//
//               The xo, yo coordinates specify an optional offset for
//               fill coordinates.  If you are painting with a pattern
//               fill, these specify the virtual coordinates of the
//               upper-left corner of the image, which can allow you
//               to adjust the pattern to line up with nested images,
//               if necessary.
////////////////////////////////////////////////////////////////////
68
PNMPainter::PNMPainter(PNMImage &image, int xo = (0), int yo = (0));

665 11 ~PNMPainter 0 4 688 23 PNMPainter::~PNMPainter 0 0 708
// Filename: pnmPainter.I
// Created by:  drose (02Feb07)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: PNMPainter::Destructor
//       Access: Published
//  Description: 
////////////////////////////////////////////////////////////////////
37
inline PNMPainter::~PNMPainter(void);

666 7 set_pen 0 4 688 19 PNMPainter::set_pen 0 1 403 608
////////////////////////////////////////////////////////////////////
//     Function: PNMPainter::set_pen
//       Access: Published
//  Description: Specifies a PNMBrush that will be used for drawing
//               lines and edges.  If the brush is a bitmap brush, its
//               image will be smeared pixelwise along the line.
//
//               Unlike the PNMImage passed to the constructor, the
//               PNMPainter will take ownership of the pen.  It is not
//               necessary to keep a separate pointer to it.
////////////////////////////////////////////////////////////////////
47
inline void PNMPainter::set_pen(PNMBrush *pen);

667 7 get_pen 0 4 688 19 PNMPainter::get_pen 0 1 404 259
////////////////////////////////////////////////////////////////////
//     Function: PNMPainter::get_pen
//       Access: Published
//  Description: Returns the current pen.  See set_pen().
////////////////////////////////////////////////////////////////////
49
inline PNMBrush *PNMPainter::get_pen(void) const;

668 8 set_fill 0 4 688 20 PNMPainter::set_fill 0 1 405 639
////////////////////////////////////////////////////////////////////
//     Function: PNMPainter::set_fill
//       Access: Published
//  Description: Specifies a PNMBrush that will be used for filling
//               in the interiors of objects.  If the brush is a
//               bitmap brush, its image will be tiled throughout the
//               space.
//
//               Unlike the PNMImage passed to the constructor, the
//               PNMPainter will take ownership of the fill brush.  It
//               is not necessary to keep a separate pointer to it.
////////////////////////////////////////////////////////////////////
49
inline void PNMPainter::set_fill(PNMBrush *fill);

669 8 get_fill 0 4 688 20 PNMPainter::get_fill 0 1 406 268
////////////////////////////////////////////////////////////////////
//     Function: PNMPainter::get_fill
//       Access: Published
//  Description: Returns the current fill brush.  See set_fill().
////////////////////////////////////////////////////////////////////
50
inline PNMBrush *PNMPainter::get_fill(void) const;

670 10 draw_point 0 4 688 22 PNMPainter::draw_point 0 1 407 305
////////////////////////////////////////////////////////////////////
//     Function: PNMPainter::draw_point
//       Access: Published
//  Description: Draws an antialiased point on the PNMImage, using the
//               current pen.
////////////////////////////////////////////////////////////////////
55
inline void PNMPainter::draw_point(double x, double y);

671 9 draw_line 0 4 688 21 PNMPainter::draw_line 0 1 408 303
////////////////////////////////////////////////////////////////////
//     Function: PNMPainter::draw_line
//       Access: Published
//  Description: Draws an antialiased line on the PNMImage, using the
//               current pen.
////////////////////////////////////////////////////////////////////
71
void PNMPainter::draw_line(double xa, double ya, double xb, double yb);

672 14 draw_rectangle 0 4 688 26 PNMPainter::draw_rectangle 0 1 409 488
////////////////////////////////////////////////////////////////////
//     Function: PNMPainter::draw_rectangle
//       Access: Published
//  Description: Draws a filled rectangule on the PNMImage, using the
//               current pen for the outline, and the current fill
//               brush for the interior.
//
//               The two coordinates specify any two diagonally
//               opposite corners.
////////////////////////////////////////////////////////////////////
76
void PNMPainter::draw_rectangle(double xa, double ya, double xb, double yb);

409
1 14 Dtool_BCNhndVM 0 7 2 689 426 14 Dtool_BCNhndVM 0 0 
2 14 Dtool_BCNhnRJq 0 7 2 689 426 14 Dtool_BCNhnRJq 0 3 1 r 1 674  1 g 1 674  1 b 1 674  
3 14 Dtool_BCNhGjIK 0 6 3 690 0 14 Dtool_BCNhGjIK 0 0 
4 14 Dtool_BCNhvPAo 0 4 4 691 0 14 Dtool_BCNhvPAo 0 2 4 this 3 689  1 i 1 690  
5 14 Dtool_BCNhCOb2 0 6 4 674 0 14 Dtool_BCNhCOb2 0 2 4 this 3 692  1 i 1 690  
6 14 Dtool_BCNhtVKB 0 4 5 691 0 14 Dtool_BCNhtVKB 0 3 4 this 3 689  1 i 1 690  1 v 1 674  
7 14 Dtool_BCNhqbZf 0 7 6 689 426 14 Dtool_BCNhqbZf 0 2 4 this 3 692  5 other 1 692  
8 14 Dtool_BCNhqTKp 0 7 7 689 426 14 Dtool_BCNhqTKp 0 2 4 this 3 692  5 other 1 692  
9 14 Dtool_BCNhUeef 0 7 8 689 426 14 Dtool_BCNhUeef 0 2 4 this 3 692  4 mult 1 694  
10 14 Dtool_BCNhyxYf 0 6 9 689 0 14 Dtool_BCNhyxYf 0 2 4 this 3 689  5 other 1 692  
11 14 Dtool_BCNhy5Jp 0 6 10 689 0 14 Dtool_BCNhy5Jp 0 2 4 this 3 689  5 other 1 692  
12 14 Dtool_BCNh2b7D 0 6 11 689 0 14 Dtool_BCNh2b7D 0 2 4 this 3 689  4 mult 1 694  
13 14 Dtool_BCNhrZSg 0 6 13 674 0 14 Dtool_BCNhrZSg 0 1 4 this 3 692  
14 14 Dtool_BCNhNJEp 0 4 14 691 0 14 Dtool_BCNhNJEp 0 2 4 this 3 689  5 value 1 674  
15 14 Dtool_BCNhrjfs 0 6 16 674 0 14 Dtool_BCNhrjfs 0 1 4 this 3 692  
16 14 Dtool_BCNhNDR1 0 4 17 691 0 14 Dtool_BCNhNDR1 0 2 4 this 3 689  5 value 1 674  
17 14 Dtool_BCNhq5VH 0 6 19 674 0 14 Dtool_BCNhq5VH 0 1 4 this 3 692  
18 14 Dtool_BCNhSpIQ 0 4 20 691 0 14 Dtool_BCNhSpIQ 0 2 4 this 3 689  5 value 1 674  
19 14 Dtool_BCNhmp_V 0 6 25 697 0 14 Dtool_BCNhmp_V 0 1 4 this 3 695  
20 14 Dtool_BCNhs8xu 0 6 26 690 0 14 Dtool_BCNhs8xu 360 ////////////////////////////////////////////////////////////////////
//     Function: PNMFileType::get_num_extensions
//       Access: Published, Virtual
//  Description: Returns the number of different possible filename
//               extensions associated with this particular file type.
//////////////////////////////////////////////////////////////////// 1 4 this 3 695  
21 14 Dtool_BCNh_4Ze 0 6 27 697 0 14 Dtool_BCNh_4Ze 378 ////////////////////////////////////////////////////////////////////
//     Function: PNMFileType::get_extension
//       Access: Published, Virtual
//  Description: Returns the nth possible filename extension
//               associated with this particular file type, without a
//               leading dot.
//////////////////////////////////////////////////////////////////// 2 4 this 3 695  1 n 1 690  
22 14 Dtool_BCNhmZL5 0 6 28 697 0 14 Dtool_BCNhmZL5 424 ////////////////////////////////////////////////////////////////////
//     Function: PNMFileType::get_suggested_extension
//       Access: Published, Virtual
//  Description: Returns a suitable filename extension (without a
//               leading dot) to suggest for files of this type, or
//               empty string if no suggestions are available.
//////////////////////////////////////////////////////////////////// 1 4 this 3 695  
23 14 Dtool_BCNhP0PY 0 7 29 699 0 14 Dtool_BCNhP0PY 0 0 
24 14 Dtool_BCNh4WfZ 0 6 32 690 0 14 Dtool_BCNh4WfZ 279 ////////////////////////////////////////////////////////////////////
//     Function: PNMFileTypeRegistry::get_num_types
//       Access: Published
//  Description: Returns the total number of types registered.
//////////////////////////////////////////////////////////////////// 1 4 this 3 700  
25 14 Dtool_BCNhQ4tf 0 6 33 702 0 14 Dtool_BCNhQ4tf 261 ////////////////////////////////////////////////////////////////////
//     Function: PNMFileTypeRegistry::get_type
//       Access: Published
//  Description: Returns the nth type registered.
//////////////////////////////////////////////////////////////////// 2 4 this 3 700  1 n 1 690  
26 14 Dtool_BCNhul04 0 6 34 702 0 14 Dtool_BCNhul04 481 ////////////////////////////////////////////////////////////////////
//     Function: PNMFileTypeRegistry::get_type_from_extension
//       Access: Published
//  Description: Tries to determine what the PNMFileType is likely to
//               be for a particular image file based on its
//               extension.  Returns a suitable PNMFileType pointer,
//               or NULL if no type can be determined.
//////////////////////////////////////////////////////////////////// 2 4 this 3 700  8 filename 1 697  
27 14 Dtool_BCNhE_a6 0 6 35 702 0 14 Dtool_BCNhE_a6 544 ////////////////////////////////////////////////////////////////////
//     Function: PNMFileTypeRegistry::get_type_from_magic_number
//       Access: Published
//  Description: Tries to determine what the PNMFileType is likely to
//               be for a particular image file based on its
//               magic number, the first two bytes read from the
//               file.  Returns a suitable PNMFileType pointer, or
//               NULL if no type can be determined.
//////////////////////////////////////////////////////////////////// 2 4 this 3 700  12 magic_number 1 697  
28 14 Dtool_BCNhULKw 0 6 36 702 0 14 Dtool_BCNhULKw 444 ////////////////////////////////////////////////////////////////////
//     Function: PNMFileTypeRegistry::get_type_by_handle
//       Access: Published
//  Description: Returns the PNMFileType instance stored in the
//               registry for the given TypeHandle, e.g. as retrieved
//               by a previous call to get_type() on the type
//               instance.
//////////////////////////////////////////////////////////////////// 2 4 this 3 700  6 handle 1 699  
29 14 Dtool_BCNhPi13 0 4 37 691 0 14 Dtool_BCNhPi13 332 ////////////////////////////////////////////////////////////////////
//     Function: PNMFileTypeRegistry::write
//       Access: Published
//  Description: Writes a list of supported image file types to the
//               indicated output stream, one per line.
//////////////////////////////////////////////////////////////////// 3 4 this 3 700  3 out 1 703  12 indent_level 1 690  
30 14 Dtool_BCNhfjWd 0 4 37 691 0 14 Dtool_BCNhfjWd 332 ////////////////////////////////////////////////////////////////////
//     Function: PNMFileTypeRegistry::write
//       Access: Published
//  Description: Writes a list of supported image file types to the
//               indicated output stream, one per line.
//////////////////////////////////////////////////////////////////// 2 4 this 3 700  3 out 1 703  
31 14 Dtool_BCNhFElp 0 6 38 705 0 14 Dtool_BCNhFElp 319 ////////////////////////////////////////////////////////////////////
//     Function: PNMFileTypeRegistry::get_global_ptr
//       Access: Published, Static
//  Description: Returns a pointer to the global PNMFileTypeRegistry
//               object.
//////////////////////////////////////////////////////////////////// 0 
32 14 Dtool_BCNhBReb 0 7 40 706 442 14 Dtool_BCNhBReb 716 // Filename: pnmImageHeader.I
// Created by:  drose (15Jun00)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 0 
33 14 Dtool_BCNh2f0p 0 7 40 706 442 14 Dtool_BCNh2f0p 231 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::Copy Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 copy 1 707  
34 14 Dtool_BCNhglLY 0 6 41 706 0 14 Dtool_BCNhglLY 239 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::Copy Assignment Operator
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 706  4 copy 1 707  
35 14 Dtool_BCNh7arZ 0 6 44 679 0 14 Dtool_BCNh7arZ 397 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::get_color_type
//       Access: Published
//  Description: Returns the image type of the image, as an enumerated
//               value.  This is really just the number of channels
//               cast to the enumerated type.
//////////////////////////////////////////////////////////////////// 1 4 this 3 707  
36 14 Dtool_BCNhieYf 0 6 45 690 0 14 Dtool_BCNhieYf 276 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::get_num_channels
//       Access: Published
//  Description: Returns the number of channels in the image.
//////////////////////////////////////////////////////////////////// 1 4 this 3 707  
37 14 Dtool_BCNhAZAi 0 6 46 709 0 14 Dtool_BCNhAZAi 551 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::is_grayscale
//       Access: Published
//  Description: Returns false if the image is a full-color image, and
//               has red, green, and blue components; true if it is a
//               grayscale image and has only a gray component.  (The
//               gray color is actually stored in the blue channel,
//               and the red and green channels are ignored.)
//////////////////////////////////////////////////////////////////// 1 4 this 3 707  
38 14 Dtool_BCNhc8Xa 0 6 46 709 0 14 Dtool_BCNhc8Xa 395 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::is_grayscale
//       Access: Published, Static
//  Description: This static variant of is_grayscale() returns true if
//               the indicated image type represents a grayscale
//               image, false otherwise.
//////////////////////////////////////////////////////////////////// 1 10 color_type 1 679  
39 14 Dtool_BCNhAlRN 0 6 47 709 0 14 Dtool_BCNhAlRN 464 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::has_alpha
//       Access: Published
//  Description: Returns true if the image includes an alpha channel,
//               false otherwise.  Unlike is_grayscale(), if this
//               returns false it is an error to call any of the
//               functions accessing the alpha channel.
//////////////////////////////////////////////////////////////////// 1 4 this 3 707  
40 14 Dtool_BCNhLbsW 0 6 47 709 0 14 Dtool_BCNhLbsW 386 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::has_alpha
//       Access: Published, Static
//  Description: This static variant of has_alpha() returns true if
//               the indicated image type includes an alpha channel,
//               false otherwise.
//////////////////////////////////////////////////////////////////// 1 10 color_type 1 679  
41 14 Dtool_BCNh_pzV 0 6 48 674 0 14 Dtool_BCNh_pzV 443 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::get_maxval
//       Access: Published
//  Description: Returns the maximum channel value allowable for any
//               pixel in this image; for instance, 255 for a typical
//               8-bit-per-channel image.  A pixel with this value is
//               full on.
//////////////////////////////////////////////////////////////////// 1 4 this 3 707  
42 14 Dtool_BCNhoepx 0 6 49 690 0 14 Dtool_BCNhoepx 366 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::get_x_size
//       Access: Published
//  Description: Returns the number of pixels in the X direction.
//               This is one more than the largest allowable X
//               coordinate.
//////////////////////////////////////////////////////////////////// 1 4 this 3 707  
43 14 Dtool_BCNh488x 0 6 50 690 0 14 Dtool_BCNh488x 366 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::get_y_size
//       Access: Published
//  Description: Returns the number of pixels in the Y direction.
//               This is one more than the largest allowable Y
//               coordinate.
//////////////////////////////////////////////////////////////////// 1 4 this 3 707  
44 14 Dtool_BCNhH6FH 0 6 51 697 0 14 Dtool_BCNhH6FH 263 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::get_comment
//       Access: Published
//  Description: Gets the user comment from the file.
//////////////////////////////////////////////////////////////////// 1 4 this 3 707  
45 14 Dtool_BCNhtnwk 0 4 52 691 0 14 Dtool_BCNhtnwk 278 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::set_comment
//       Access: Published
//  Description: Writes a user comment string to the image (header).
//////////////////////////////////////////////////////////////////// 2 4 this 3 706  7 comment 1 697  
46 14 Dtool_BCNhVIh0 0 6 53 709 0 14 Dtool_BCNhVIh0 315 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::has_type
//       Access: Published
//  Description: Returns true if the PNMImageHeader knows what type it
//               is, false otherwise.
//////////////////////////////////////////////////////////////////// 1 4 this 3 707  
47 14 Dtool_BCNhN1gn 0 6 54 702 0 14 Dtool_BCNhN1gn 373 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::get_type
//       Access: Published
//  Description: If the file type is known (e.g. has_type() returns
//               true), returns its PNMFileType pointer; otherwise,
//               returns NULL.
//////////////////////////////////////////////////////////////////// 1 4 this 3 707  
48 14 Dtool_BCNhKhXL 0 4 55 691 0 14 Dtool_BCNhKhXL 583 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::set_type
//       Access: Published
//  Description: Sets the file type of this PNMImage.  This will be
//               the default type used when an image is read, if the
//               type cannot be determined by magic number or inferred
//               by extension, or the type used when the image is
//               written, if the type cannot be inferred from the
//               filename extension.
//////////////////////////////////////////////////////////////////// 2 4 this 3 706  4 type 1 702  
49 14 Dtool_BCNhjGQr 0 6 56 709 0 14 Dtool_BCNhjGQr 498 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::read_header
//       Access: Published
//  Description: Opens up the image file and tries to read its header
//               information to determine its size, number of
//               channels, etc.  If successful, updates the header
//               information and returns true; otherwise, returns
//               false.
//////////////////////////////////////////////////////////////////// 4 4 this 3 706  8 filename 1 710  4 type 1 702  19 report_unknown_type 1 709  
50 14 Dtool_BCNh6NNp 0 6 56 709 0 14 Dtool_BCNh6NNp 498 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::read_header
//       Access: Published
//  Description: Opens up the image file and tries to read its header
//               information to determine its size, number of
//               channels, etc.  If successful, updates the header
//               information and returns true; otherwise, returns
//               false.
//////////////////////////////////////////////////////////////////// 3 4 this 3 706  8 filename 1 710  4 type 1 702  
51 14 Dtool_BCNhMN61 0 6 56 709 0 14 Dtool_BCNhMN61 498 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::read_header
//       Access: Published
//  Description: Opens up the image file and tries to read its header
//               information to determine its size, number of
//               channels, etc.  If successful, updates the header
//               information and returns true; otherwise, returns
//               false.
//////////////////////////////////////////////////////////////////// 2 4 this 3 706  8 filename 1 710  
52 14 Dtool_BCNhy4oR 0 6 56 709 0 14 Dtool_BCNhy4oR 714 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::read_header
//       Access: Published
//  Description: Reads the image header information only from the
//               indicated stream.
//
//               The filename is advisory only, and may be used
//               to suggest a type if it has a known extension.
//
//               If type is non-NULL, it is a suggestion for the type
//               of file it is (and a non-NULL type will override any
//               magic number test or filename extension lookup).
//
//               Returns true if successful, false on error.
//////////////////////////////////////////////////////////////////// 5 4 this 3 706  4 data 1 713  8 filename 1 697  4 type 1 702  19 report_unknown_type 1 709  
53 14 Dtool_BCNhB6mV 0 6 56 709 0 14 Dtool_BCNhB6mV 714 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::read_header
//       Access: Published
//  Description: Reads the image header information only from the
//               indicated stream.
//
//               The filename is advisory only, and may be used
//               to suggest a type if it has a known extension.
//
//               If type is non-NULL, it is a suggestion for the type
//               of file it is (and a non-NULL type will override any
//               magic number test or filename extension lookup).
//
//               Returns true if successful, false on error.
//////////////////////////////////////////////////////////////////// 4 4 this 3 706  4 data 1 713  8 filename 1 697  4 type 1 702  
54 14 Dtool_BCNh6jDg 0 6 56 709 0 14 Dtool_BCNh6jDg 714 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::read_header
//       Access: Published
//  Description: Reads the image header information only from the
//               indicated stream.
//
//               The filename is advisory only, and may be used
//               to suggest a type if it has a known extension.
//
//               If type is non-NULL, it is a suggestion for the type
//               of file it is (and a non-NULL type will override any
//               magic number test or filename extension lookup).
//
//               Returns true if successful, false on error.
//////////////////////////////////////////////////////////////////// 3 4 this 3 706  4 data 1 713  8 filename 1 697  
55 14 Dtool_BCNhn_zc 0 6 56 709 0 14 Dtool_BCNhn_zc 714 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::read_header
//       Access: Published
//  Description: Reads the image header information only from the
//               indicated stream.
//
//               The filename is advisory only, and may be used
//               to suggest a type if it has a known extension.
//
//               If type is non-NULL, it is a suggestion for the type
//               of file it is (and a non-NULL type will override any
//               magic number test or filename extension lookup).
//
//               Returns true if successful, false on error.
//////////////////////////////////////////////////////////////////// 2 4 this 3 706  4 data 1 713  
56 14 Dtool_BCNhyMEf 0 6 57 715 0 14 Dtool_BCNhyMEf 689 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::make_reader
//       Access: Published
//  Description: Returns a newly-allocated PNMReader of the suitable
//               type for reading from the indicated image filename,
//               or NULL if the filename cannot be read for some
//               reason.  The filename "-" always stands for standard
//               input.  If type is specified, it is a suggestion for
//               the file type to use.
//
//               The PNMReader should be deleted when it is no longer
//               needed.
//////////////////////////////////////////////////////////////////// 4 4 this 3 707  8 filename 1 710  4 type 1 702  19 report_unknown_type 1 709  
57 14 Dtool_BCNhXjYE 0 6 57 715 0 14 Dtool_BCNhXjYE 689 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::make_reader
//       Access: Published
//  Description: Returns a newly-allocated PNMReader of the suitable
//               type for reading from the indicated image filename,
//               or NULL if the filename cannot be read for some
//               reason.  The filename "-" always stands for standard
//               input.  If type is specified, it is a suggestion for
//               the file type to use.
//
//               The PNMReader should be deleted when it is no longer
//               needed.
//////////////////////////////////////////////////////////////////// 3 4 this 3 707  8 filename 1 710  4 type 1 702  
58 14 Dtool_BCNhHm13 0 6 57 715 0 14 Dtool_BCNhHm13 689 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::make_reader
//       Access: Published
//  Description: Returns a newly-allocated PNMReader of the suitable
//               type for reading from the indicated image filename,
//               or NULL if the filename cannot be read for some
//               reason.  The filename "-" always stands for standard
//               input.  If type is specified, it is a suggestion for
//               the file type to use.
//
//               The PNMReader should be deleted when it is no longer
//               needed.
//////////////////////////////////////////////////////////////////// 2 4 this 3 707  8 filename 1 710  
59 14 Dtool_BCNhhavn 0 6 57 715 0 14 Dtool_BCNhhavn 1414 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::make_reader
//       Access: Published
//  Description: Returns a newly-allocated PNMReader of the suitable
//               type for reading from the already-opened image file,
//               or NULL if the file cannot be read for some reason.
//
//               owns_file should be set true if the PNMReader is to
//               be considered the owner of the stream pointer (in
//               which case the stream will be deleted on completion,
//               whether successful or not), or false if it should not
//               delete it.
//
//               The filename parameter is optional here, since the
//               file has already been opened; it is only used to
//               examine the extension and attempt to guess the file
//               type.
//
//               If magic_number is nonempty, it is assumed to
//               represent the first few bytes that have already been
//               read from the file.  Some file types may have
//               difficulty if this is more than two bytes.
//
//               If type is non-NULL, it is a suggestion for the file
//               type to use.
//
//               The PNMReader should be deleted when it is no longer
//               needed.
//////////////////////////////////////////////////////////////////// 7 4 this 3 707  4 file 1 713  9 owns_file 1 709  8 filename 1 710  12 magic_number 1 697  4 type 1 702  19 report_unknown_type 1 709  
60 14 Dtool_BCNhB_GS 0 6 57 715 0 14 Dtool_BCNhB_GS 1414 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::make_reader
//       Access: Published
//  Description: Returns a newly-allocated PNMReader of the suitable
//               type for reading from the already-opened image file,
//               or NULL if the file cannot be read for some reason.
//
//               owns_file should be set true if the PNMReader is to
//               be considered the owner of the stream pointer (in
//               which case the stream will be deleted on completion,
//               whether successful or not), or false if it should not
//               delete it.
//
//               The filename parameter is optional here, since the
//               file has already been opened; it is only used to
//               examine the extension and attempt to guess the file
//               type.
//
//               If magic_number is nonempty, it is assumed to
//               represent the first few bytes that have already been
//               read from the file.  Some file types may have
//               difficulty if this is more than two bytes.
//
//               If type is non-NULL, it is a suggestion for the file
//               type to use.
//
//               The PNMReader should be deleted when it is no longer
//               needed.
//////////////////////////////////////////////////////////////////// 6 4 this 3 707  4 file 1 713  9 owns_file 1 709  8 filename 1 710  12 magic_number 1 697  4 type 1 702  
61 14 Dtool_BCNh9Nkt 0 6 57 715 0 14 Dtool_BCNh9Nkt 1414 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::make_reader
//       Access: Published
//  Description: Returns a newly-allocated PNMReader of the suitable
//               type for reading from the already-opened image file,
//               or NULL if the file cannot be read for some reason.
//
//               owns_file should be set true if the PNMReader is to
//               be considered the owner of the stream pointer (in
//               which case the stream will be deleted on completion,
//               whether successful or not), or false if it should not
//               delete it.
//
//               The filename parameter is optional here, since the
//               file has already been opened; it is only used to
//               examine the extension and attempt to guess the file
//               type.
//
//               If magic_number is nonempty, it is assumed to
//               represent the first few bytes that have already been
//               read from the file.  Some file types may have
//               difficulty if this is more than two bytes.
//
//               If type is non-NULL, it is a suggestion for the file
//               type to use.
//
//               The PNMReader should be deleted when it is no longer
//               needed.
//////////////////////////////////////////////////////////////////// 5 4 this 3 707  4 file 1 713  9 owns_file 1 709  8 filename 1 710  12 magic_number 1 697  
62 14 Dtool_BCNhXIKf 0 6 57 715 0 14 Dtool_BCNhXIKf 1414 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::make_reader
//       Access: Published
//  Description: Returns a newly-allocated PNMReader of the suitable
//               type for reading from the already-opened image file,
//               or NULL if the file cannot be read for some reason.
//
//               owns_file should be set true if the PNMReader is to
//               be considered the owner of the stream pointer (in
//               which case the stream will be deleted on completion,
//               whether successful or not), or false if it should not
//               delete it.
//
//               The filename parameter is optional here, since the
//               file has already been opened; it is only used to
//               examine the extension and attempt to guess the file
//               type.
//
//               If magic_number is nonempty, it is assumed to
//               represent the first few bytes that have already been
//               read from the file.  Some file types may have
//               difficulty if this is more than two bytes.
//
//               If type is non-NULL, it is a suggestion for the file
//               type to use.
//
//               The PNMReader should be deleted when it is no longer
//               needed.
//////////////////////////////////////////////////////////////////// 4 4 this 3 707  4 file 1 713  9 owns_file 1 709  8 filename 1 710  
63 14 Dtool_BCNhhpvx 0 6 57 715 0 14 Dtool_BCNhhpvx 1414 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::make_reader
//       Access: Published
//  Description: Returns a newly-allocated PNMReader of the suitable
//               type for reading from the already-opened image file,
//               or NULL if the file cannot be read for some reason.
//
//               owns_file should be set true if the PNMReader is to
//               be considered the owner of the stream pointer (in
//               which case the stream will be deleted on completion,
//               whether successful or not), or false if it should not
//               delete it.
//
//               The filename parameter is optional here, since the
//               file has already been opened; it is only used to
//               examine the extension and attempt to guess the file
//               type.
//
//               If magic_number is nonempty, it is assumed to
//               represent the first few bytes that have already been
//               read from the file.  Some file types may have
//               difficulty if this is more than two bytes.
//
//               If type is non-NULL, it is a suggestion for the file
//               type to use.
//
//               The PNMReader should be deleted when it is no longer
//               needed.
//////////////////////////////////////////////////////////////////// 3 4 this 3 707  4 file 1 713  9 owns_file 1 709  
64 14 Dtool_BCNhG56G 0 6 57 715 0 14 Dtool_BCNhG56G 1414 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::make_reader
//       Access: Published
//  Description: Returns a newly-allocated PNMReader of the suitable
//               type for reading from the already-opened image file,
//               or NULL if the file cannot be read for some reason.
//
//               owns_file should be set true if the PNMReader is to
//               be considered the owner of the stream pointer (in
//               which case the stream will be deleted on completion,
//               whether successful or not), or false if it should not
//               delete it.
//
//               The filename parameter is optional here, since the
//               file has already been opened; it is only used to
//               examine the extension and attempt to guess the file
//               type.
//
//               If magic_number is nonempty, it is assumed to
//               represent the first few bytes that have already been
//               read from the file.  Some file types may have
//               difficulty if this is more than two bytes.
//
//               If type is non-NULL, it is a suggestion for the file
//               type to use.
//
//               The PNMReader should be deleted when it is no longer
//               needed.
//////////////////////////////////////////////////////////////////// 2 4 this 3 707  4 file 1 713  
65 14 Dtool_BCNh5aMD 0 6 58 717 0 14 Dtool_BCNh5aMD 694 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::make_writer
//       Access: Published
//  Description: Returns a newly-allocated PNMWriter of the suitable
//               type for writing an image to the indicated filename,
//               or NULL if the filename cannot be written for some
//               reason.  The filename "-" always stands for standard
//               output.  If type is specified, it is a suggestion for
//               the file type to use.
//
//               The PNMWriter should be deleted when it is no longer
//               needed.
//////////////////////////////////////////////////////////////////// 3 4 this 3 707  8 filename 1 710  4 type 1 702  
66 14 Dtool_BCNhZHo2 0 6 58 717 0 14 Dtool_BCNhZHo2 694 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::make_writer
//       Access: Published
//  Description: Returns a newly-allocated PNMWriter of the suitable
//               type for writing an image to the indicated filename,
//               or NULL if the filename cannot be written for some
//               reason.  The filename "-" always stands for standard
//               output.  If type is specified, it is a suggestion for
//               the file type to use.
//
//               The PNMWriter should be deleted when it is no longer
//               needed.
//////////////////////////////////////////////////////////////////// 2 4 this 3 707  8 filename 1 710  
67 14 Dtool_BCNhnxIJ 0 6 58 717 0 14 Dtool_BCNhnxIJ 1165 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::make_writer
//       Access: Published
//  Description: Returns a newly-allocated PNMWriter of the suitable
//               type for writing to the already-opened image file, or
//               NULL if the file cannot be written for some reason.
//
//               owns_file should be set true if the PNMWriter is to
//               be considered the owner of the stream pointer (in
//               which case the stream will be deleted on completion,
//               whether successful or not), or false if it should not
//               delete it.
//
//               The filename parameter is optional here, since the
//               file has already been opened; it is only used to
//               examine the extension and attempt to guess the
//               intended file type.
//
//               If type is non-NULL, it is a suggestion for the file
//               type to use.
//
//               The PNMWriter should be deleted when it is no longer
//               needed.
//////////////////////////////////////////////////////////////////// 5 4 this 3 707  4 file 1 703  9 owns_file 1 709  8 filename 1 710  4 type 1 702  
68 14 Dtool_BCNhMA9F 0 6 58 717 0 14 Dtool_BCNhMA9F 1165 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::make_writer
//       Access: Published
//  Description: Returns a newly-allocated PNMWriter of the suitable
//               type for writing to the already-opened image file, or
//               NULL if the file cannot be written for some reason.
//
//               owns_file should be set true if the PNMWriter is to
//               be considered the owner of the stream pointer (in
//               which case the stream will be deleted on completion,
//               whether successful or not), or false if it should not
//               delete it.
//
//               The filename parameter is optional here, since the
//               file has already been opened; it is only used to
//               examine the extension and attempt to guess the
//               intended file type.
//
//               If type is non-NULL, it is a suggestion for the file
//               type to use.
//
//               The PNMWriter should be deleted when it is no longer
//               needed.
//////////////////////////////////////////////////////////////////// 4 4 this 3 707  4 file 1 703  9 owns_file 1 709  8 filename 1 710  
69 14 Dtool_BCNhvviY 0 6 58 717 0 14 Dtool_BCNhvviY 1165 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::make_writer
//       Access: Published
//  Description: Returns a newly-allocated PNMWriter of the suitable
//               type for writing to the already-opened image file, or
//               NULL if the file cannot be written for some reason.
//
//               owns_file should be set true if the PNMWriter is to
//               be considered the owner of the stream pointer (in
//               which case the stream will be deleted on completion,
//               whether successful or not), or false if it should not
//               delete it.
//
//               The filename parameter is optional here, since the
//               file has already been opened; it is only used to
//               examine the extension and attempt to guess the
//               intended file type.
//
//               If type is non-NULL, it is a suggestion for the file
//               type to use.
//
//               The PNMWriter should be deleted when it is no longer
//               needed.
//////////////////////////////////////////////////////////////////// 3 4 this 3 707  4 file 1 703  9 owns_file 1 709  
70 14 Dtool_BCNhKDut 0 6 58 717 0 14 Dtool_BCNhKDut 1165 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::make_writer
//       Access: Published
//  Description: Returns a newly-allocated PNMWriter of the suitable
//               type for writing to the already-opened image file, or
//               NULL if the file cannot be written for some reason.
//
//               owns_file should be set true if the PNMWriter is to
//               be considered the owner of the stream pointer (in
//               which case the stream will be deleted on completion,
//               whether successful or not), or false if it should not
//               delete it.
//
//               The filename parameter is optional here, since the
//               file has already been opened; it is only used to
//               examine the extension and attempt to guess the
//               intended file type.
//
//               If type is non-NULL, it is a suggestion for the file
//               type to use.
//
//               The PNMWriter should be deleted when it is no longer
//               needed.
//////////////////////////////////////////////////////////////////// 2 4 this 3 707  4 file 1 703  
71 14 Dtool_BCNh3Qff 0 6 59 709 0 14 Dtool_BCNh3Qff 602 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::read_magic_number
//       Access: Published, Static
//  Description: Ensures that the first n bytes of the file are read
//               into magic_number.  If magic_number is initially
//               nonempty, assumes these represent the first few bytes
//               already extracted.  Returns true if successful, false
//               if an end of file or error occurred before num_bytes
//               could be read.
//////////////////////////////////////////////////////////////////// 3 4 file 1 713  12 magic_number 1 719  9 num_bytes 1 690  
72 14 Dtool_BCNhN1NO 0 4 60 691 0 14 Dtool_BCNhN1NO 221 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::output
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 707  3 out 1 703  
73 14 Dtool_BCNhaiba 0 7 62 723 477 14 Dtool_BCNhaiba 243 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::Copy Constructor
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 1 4 copy 1 721  
74 14 Dtool_BCNhBg5h 0 7 62 723 477 14 Dtool_BCNhBg5h 238 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::Constructor
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 1 3 rgb 1 692  
75 14 Dtool_BCNhrfQp 0 7 62 723 477 14 Dtool_BCNhrfQp 238 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::Constructor
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 2 3 rgb 1 692  5 alpha 1 674  
76 14 Dtool_BCNhP_Wa 0 7 62 723 477 14 Dtool_BCNhP_Wa 238 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::Constructor
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 1 10 gray_value 1 674  
77 14 Dtool_BCNh0C33 0 7 62 723 477 14 Dtool_BCNh0C33 238 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::Constructor
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 2 10 gray_value 1 674  5 alpha 1 674  
78 14 Dtool_BCNh0mtQ 0 7 62 723 477 14 Dtool_BCNh0mtQ 238 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::Constructor
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 3 3 red 1 674  5 green 1 674  4 blue 1 674  
79 14 Dtool_BCNhuvff 0 7 62 723 477 14 Dtool_BCNhuvff 238 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::Constructor
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 4 3 red 1 674  5 green 1 674  4 blue 1 674  5 alpha 1 674  
80 14 Dtool_BCNhH_yL 0 6 63 723 0 14 Dtool_BCNhH_yL 251 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::Copy Assignment Operator
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 723  4 copy 1 721  
81 14 Dtool_BCNhKqUd 0 6 64 709 0 14 Dtool_BCNhKqUd 237 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::operator <
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 721  5 other 1 721  
82 14 Dtool_BCNh3ntw 0 6 65 709 0 14 Dtool_BCNh3ntw 238 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::operator ==
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 721  5 other 1 721  
83 14 Dtool_BCNhVnpl 0 6 66 709 0 14 Dtool_BCNhVnpl 238 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::operator !=
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 721  5 other 1 721  
84 14 Dtool_BCNhNjTc 0 6 67 690 0 14 Dtool_BCNhNjTc 237 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::compare_to
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 721  5 other 1 721  
85 14 Dtool_BCNh_8Tt 0 6 68 674 0 14 Dtool_BCNh_8Tt 234 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::get_red
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 1 4 this 3 721  
86 14 Dtool_BCNhYDpY 0 6 69 674 0 14 Dtool_BCNhYDpY 236 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::get_green
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 1 4 this 3 721  
87 14 Dtool_BCNh_k6u 0 6 70 674 0 14 Dtool_BCNh_k6u 235 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::get_blue
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 1 4 this 3 721  
88 14 Dtool_BCNhoGXs 0 6 71 674 0 14 Dtool_BCNhoGXs 236 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::get_alpha
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 1 4 this 3 721  
89 14 Dtool_BCNhR5lq 0 4 72 691 0 14 Dtool_BCNhR5lq 234 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::set_red
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 723  3 red 1 674  
90 14 Dtool_BCNhFQSX 0 4 73 691 0 14 Dtool_BCNhFQSX 236 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::set_green
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 723  5 green 1 674  
91 14 Dtool_BCNh_U_S 0 4 74 691 0 14 Dtool_BCNh_U_S 235 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::set_blue
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 723  4 blue 1 674  
92 14 Dtool_BCNhek_q 0 4 75 691 0 14 Dtool_BCNhek_q 236 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::set_alpha
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 723  5 alpha 1 674  
93 14 Dtool_BCNhjJlA 0 6 76 674 0 14 Dtool_BCNhjJlA 397 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::operator []
//       Access: Published
//  Description: Indexes numerically into the components, in the order
//               R, G, B, A.  This also makes the PixelSpec work like
//               a tuple in Python.
//////////////////////////////////////////////////////////////////// 2 4 this 3 721  1 n 1 690  
94 14 Dtool_BCNhSM56 0 6 77 690 0 14 Dtool_BCNhSM56 394 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::size
//       Access: Published, Static
//  Description: Specifies the number of components in the PixelSpec;
//               this is always 4, regardless of the type of image it
//               was taken from.
//////////////////////////////////////////////////////////////////// 0 
95 14 Dtool_BCNhdDxm 0 4 78 691 0 14 Dtool_BCNhdDxm 230 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::PixelSpec::output
//       Access: Public
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 721  3 out 1 703  
96 14 Dtool_BCNhwHpx 0 7 83 724 484 14 Dtool_BCNhwHpx 238 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::Histogram::Constructor
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 0 
97 14 Dtool_BCNhKSJ_ 0 6 84 690 0 14 Dtool_BCNhKSJ_ 317 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::Histogram::get_num_pixels
//       Access: Published
//  Description: Returns the number of unique pixel colors in the
//               histogram.
//////////////////////////////////////////////////////////////////// 1 4 this 3 725  
98 14 Dtool_BCNhjIKa 0 6 85 721 0 14 Dtool_BCNhjIKa 385 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::Histogram::get_pixel
//       Access: Published
//  Description: Returns the nth unique pixel color in the histogram.
//               These are ordered by default from most common to
//               least common.
//////////////////////////////////////////////////////////////////// 2 4 this 3 725  1 n 1 690  
99 14 Dtool_BCNhzrFZ 0 6 86 690 0 14 Dtool_BCNhzrFZ 329 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::Histogram::get_count
//       Access: Published
//  Description: Returns the number of occurrences in the image of the
//               indicated pixel color.
//////////////////////////////////////////////////////////////////// 2 4 this 3 725  5 pixel 1 721  
100 14 Dtool_BCNhDuJV 0 6 86 690 0 14 Dtool_BCNhDuJV 347 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::Histogram::get_count
//       Access: Published
//  Description: Returns the number of occurrences in the image of the
//               nth unique pixel color in the histogram.
//////////////////////////////////////////////////////////////////// 2 4 this 3 725  1 n 1 690  
101 14 Dtool_BCNh67a1 0 4 87 691 0 14 Dtool_BCNh67a1 229 ////////////////////////////////////////////////////////////////////
//     Function: PNMImageHeader::Histogram::write
//       Access: Public
//  Description: 
//////////////////////////////////////////////////////////////////// 2 4 this 3 725  3 out 1 703  
102 14 Dtool_BCNhfcBd 0 7 90 727 557 14 Dtool_BCNhfcBd 219 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 0 
103 14 Dtool_BCNhuEPB 0 7 90 727 557 14 Dtool_BCNhuEPB 224 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::Copy Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 copy 1 728  
104 14 Dtool_BCNhA5af 0 6 91 727 0 14 Dtool_BCNhA5af 223 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::Copy Assignment
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  4 copy 1 728  
105 14 Dtool_BCNhaNu8 0 4 92 691 0 14 Dtool_BCNhaNu8 246 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::clear
//       Access: Published
//  Description: Eliminates all data in the file.
//////////////////////////////////////////////////////////////////// 1 4 this 3 727  
106 14 Dtool_BCNh_3Nw 0 4 92 691 0 14 Dtool_BCNh_3Nw 455 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::clear
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 4 4 this 3 727  6 x_size 1 690  6 y_size 1 690  12 num_channels 1 690  
107 14 Dtool_BCNhBQSl 0 6 93 709 0 14 Dtool_BCNhBQSl 501 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::read
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  8 fullpath 1 710  
108 14 Dtool_BCNhQcwB 0 6 93 709 0 14 Dtool_BCNhQcwB 375 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::read
//       Access: Published
//  Description: Reads the PFM data using the indicated PNMReader.
//
//               The PNMReader is always deleted upon completion,
//               whether successful or not.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  6 reader 1 715  
109 14 Dtool_BCNhRtln 0 6 93 709 0 14 Dtool_BCNhRtln 503 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::read
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 3 4 this 3 727  2 in 1 713  8 fullpath 1 710  
110 14 Dtool_BCNhQa5A 0 6 93 709 0 14 Dtool_BCNhQa5A 503 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::read
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  2 in 1 713  
111 14 Dtool_BCNhd8U_ 0 6 94 709 0 14 Dtool_BCNhd8U_ 589 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::write
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  8 fullpath 1 710  
112 14 Dtool_BCNh4u_u 0 6 94 709 0 14 Dtool_BCNh4u_u 377 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::write
//       Access: Published
//  Description: Writes the PFM data using the indicated PNMWriter.
//
//               The PNMWriter is always deleted upon completion,
//               whether successful or not.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  6 writer 1 717  
113 14 Dtool_BCNh6toJ 0 6 94 709 0 14 Dtool_BCNh6toJ 320 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::write
//       Access: Published
//  Description: Writes the PFM data to the indicated stream,
//               returning true on success, false on failure.
//////////////////////////////////////////////////////////////////// 3 4 this 3 727  3 out 1 703  8 fullpath 1 710  
114 14 Dtool_BCNhq5oy 0 6 94 709 0 14 Dtool_BCNhq5oy 320 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::write
//       Access: Published
//  Description: Writes the PFM data to the indicated stream,
//               returning true on success, false on failure.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  3 out 1 703  
115 14 Dtool_BCNh0Br7 0 6 95 709 0 14 Dtool_BCNh0Br7 326 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::load
//       Access: Published
//  Description: Fills the PfmFile with the data from the indicated
//               PNMImage, converted to floating-point values.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  8 pnmimage 1 730  
116 14 Dtool_BCNhevef 0 6 96 709 0 14 Dtool_BCNhevef 299 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::store
//       Access: Published
//  Description: Copies the data to the indicated PNMImage, converting
//               to RGB values.
//////////////////////////////////////////////////////////////////// 2 4 this 3 728  8 pnmimage 1 732  
117 14 Dtool_BCNhguFC 0 6 97 709 0 14 Dtool_BCNhguFC 433 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::store_mask
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 2 4 this 3 728  8 pnmimage 1 732  
118 14 Dtool_BCNhhuHM 0 6 98 709 0 14 Dtool_BCNhhuHM 700 // Filename: pfmFile.I
// Created by:  drose (23Dec10)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: PfmFile::is_valid
//       Access: Published
//  Description: 
//////////////////////////////////////////////////////////////////// 1 4 this 3 728  
119 14 Dtool_BCNhgrkA 0 6 99 733 0 14 Dtool_BCNhgrkA 305 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::get_scale
//       Access: Published
//  Description: The "scale" is reported in the pfm header and is
//               probably meaningless.
//////////////////////////////////////////////////////////////////// 1 4 this 3 728  
120 14 Dtool_BCNhnZPD 0 4 100 691 0 14 Dtool_BCNhnZPD 305 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_scale
//       Access: Published
//  Description: The "scale" is reported in the pfm header and is
//               probably meaningless.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  5 scale 1 733  
121 14 Dtool_BCNhBfvY 0 6 101 709 0 14 Dtool_BCNhBfvY 457 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::has_point
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 3 4 this 3 728  1 x 1 690  1 y 1 690  
122 14 Dtool_BCNhfV5j 0 6 102 733 0 14 Dtool_BCNhfV5j 303 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::get_channel
//       Access: Published
//  Description: Returns the cth channel of the point value at the
//               indicated point.
//////////////////////////////////////////////////////////////////// 4 4 this 3 728  1 x 1 690  1 y 1 690  1 c 1 690  
123 14 Dtool_BCNhSXNW 0 4 103 691 0 14 Dtool_BCNhSXNW 304 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_channel
//       Access: Published
//  Description: Replaces the cth channel of the point value at the
//               indicated point.
//////////////////////////////////////////////////////////////////// 5 4 this 3 727  1 x 1 690  1 y 1 690  1 c 1 690  5 value 1 733  
124 14 Dtool_BCNhOYNf 0 6 104 733 0 14 Dtool_BCNhOYNf 295 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::get_point1
//       Access: Published
//  Description: Returns the 1-component point value at the indicated
//               point.
//////////////////////////////////////////////////////////////////// 3 4 this 3 728  1 x 1 690  1 y 1 690  
125 14 Dtool_BCNho4g3 0 4 105 691 0 14 Dtool_BCNho4g3 296 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_point1
//       Access: Published
//  Description: Replaces the 1-component point value at the indicated
//               point.
//////////////////////////////////////////////////////////////////// 4 4 this 3 727  1 x 1 690  1 y 1 690  5 point 1 733  
126 14 Dtool_BCNh4mNm 0 6 106 734 0 14 Dtool_BCNh4mNm 376 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::get_point2
//       Access: Published
//  Description: Returns the 2-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
//////////////////////////////////////////////////////////////////// 3 4 this 3 728  1 x 1 690  1 y 1 690  
127 14 Dtool_BCNhXXsW 0 4 107 691 0 14 Dtool_BCNhXXsW 377 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_point2
//       Access: Published
//  Description: Replaces the 2-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
//////////////////////////////////////////////////////////////////// 4 4 this 3 727  1 x 1 690  1 y 1 690  5 point 1 737  
128 14 Dtool_BCNhHx_W 0 4 107 691 0 14 Dtool_BCNhHx_W 377 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_point2
//       Access: Published
//  Description: Replaces the 2-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
//////////////////////////////////////////////////////////////////// 4 4 this 3 727  1 x 1 690  1 y 1 690  5 point 1 740  
129 14 Dtool_BCNhDHfT 0 6 108 743 0 14 Dtool_BCNhDHfT 307 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::modify_point2
//       Access: Published
//  Description: Returns a modifiable 2-component point value at the
//               indicated point.
//////////////////////////////////////////////////////////////////// 3 4 this 3 727  1 x 1 690  1 y 1 690  
130 14 Dtool_BCNhpEcj 0 6 109 744 0 14 Dtool_BCNhpEcj 375 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::get_point
//       Access: Published
//  Description: Returns the 3-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
//////////////////////////////////////////////////////////////////// 3 4 this 3 728  1 x 1 690  1 y 1 690  
131 14 Dtool_BCNhDTg1 0 4 110 691 0 14 Dtool_BCNhDTg1 376 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_point
//       Access: Published
//  Description: Replaces the 3-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
//////////////////////////////////////////////////////////////////// 4 4 this 3 727  1 x 1 690  1 y 1 690  5 point 1 747  
132 14 Dtool_BCNhHMhV 0 4 110 691 0 14 Dtool_BCNhHMhV 376 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_point
//       Access: Published
//  Description: Replaces the 3-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
//////////////////////////////////////////////////////////////////// 4 4 this 3 727  1 x 1 690  1 y 1 690  5 point 1 750  
133 14 Dtool_BCNhe8cV 0 6 111 753 0 14 Dtool_BCNhe8cV 306 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::modify_point
//       Access: Published
//  Description: Returns a modifiable 3-component point value at the
//               indicated point.
//////////////////////////////////////////////////////////////////// 3 4 this 3 727  1 x 1 690  1 y 1 690  
134 14 Dtool_BCNhqnNt 0 6 112 744 0 14 Dtool_BCNhqnNt 376 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::get_point3
//       Access: Published
//  Description: Returns the 3-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
//////////////////////////////////////////////////////////////////// 3 4 this 3 728  1 x 1 690  1 y 1 690  
135 14 Dtool_BCNhn4sN 0 4 113 691 0 14 Dtool_BCNhn4sN 377 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_point3
//       Access: Published
//  Description: Replaces the 3-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
//////////////////////////////////////////////////////////////////// 4 4 this 3 727  1 x 1 690  1 y 1 690  5 point 1 747  
136 14 Dtool_BCNh3e_N 0 4 113 691 0 14 Dtool_BCNh3e_N 377 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_point3
//       Access: Published
//  Description: Replaces the 3-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
//////////////////////////////////////////////////////////////////// 4 4 this 3 727  1 x 1 690  1 y 1 690  5 point 1 750  
137 14 Dtool_BCNhDfQd 0 6 114 753 0 14 Dtool_BCNhDfQd 307 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::modify_point3
//       Access: Published
//  Description: Returns a modifiable 3-component point value at the
//               indicated point.
//////////////////////////////////////////////////////////////////// 3 4 this 3 727  1 x 1 690  1 y 1 690  
138 14 Dtool_BCNhkkN0 0 6 115 754 0 14 Dtool_BCNhkkN0 376 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::get_point4
//       Access: Published
//  Description: Returns the 4-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
//////////////////////////////////////////////////////////////////// 3 4 this 3 728  1 x 1 690  1 y 1 690  
139 14 Dtool_BCNh8fsE 0 4 116 691 0 14 Dtool_BCNh8fsE 377 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_point4
//       Access: Published
//  Description: Replaces the 4-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
//////////////////////////////////////////////////////////////////// 4 4 this 3 727  1 x 1 690  1 y 1 690  5 point 1 757  
140 14 Dtool_BCNhs9BF 0 4 116 691 0 14 Dtool_BCNhs9BF 377 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_point4
//       Access: Published
//  Description: Replaces the 4-component point value at the indicated
//               point.  In a 1-channel image, the channel value is in
//               the x component.
//////////////////////////////////////////////////////////////////// 4 4 this 3 727  1 x 1 690  1 y 1 690  5 point 1 760  
141 14 Dtool_BCNhDXBn 0 6 117 763 0 14 Dtool_BCNhDXBn 307 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::modify_point4
//       Access: Published
//  Description: Returns a modifiable 4-component point value at the
//               indicated point.
//////////////////////////////////////////////////////////////////// 3 4 this 3 727  1 x 1 690  1 y 1 690  
142 14 Dtool_BCNhrT_E 0 4 118 691 0 14 Dtool_BCNhrT_E 256 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::fill
//       Access: Published
//  Description: Fills the table with all of the same value.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  5 value 1 734  
143 14 Dtool_BCNh71QF 0 4 118 691 0 14 Dtool_BCNh71QF 256 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::fill
//       Access: Published
//  Description: Fills the table with all of the same value.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  5 value 1 744  
144 14 Dtool_BCNhLUkF 0 4 118 691 0 14 Dtool_BCNhLUkF 256 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::fill
//       Access: Published
//  Description: Fills the table with all of the same value.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  5 value 1 754  
145 14 Dtool_BCNhc6zT 0 4 118 691 0 14 Dtool_BCNhc6zT 256 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::fill
//       Access: Published
//  Description: Fills the table with all of the same value.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  5 value 1 733  
146 14 Dtool_BCNhlO5X 0 4 119 691 0 14 Dtool_BCNhlO5X 246 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::fill_nan
//       Access: Published
//  Description: Fills the table with all NaN.
//////////////////////////////////////////////////////////////////// 1 4 this 3 727  
147 14 Dtool_BCNhSFpi 0 4 120 691 0 14 Dtool_BCNhSFpi 319 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::fill_no_data_value
//       Access: Published
//  Description: Fills the table with the current no_data value, so
//               that the table is empty.
//////////////////////////////////////////////////////////////////// 1 4 this 3 727  
148 14 Dtool_BCNhugPC 0 4 121 691 0 14 Dtool_BCNhugPC 331 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::fill_channel
//       Access: Published
//  Description: Fills the indicated channel with all of the same
//               value, leaving the other channels unchanged.
//////////////////////////////////////////////////////////////////// 3 4 this 3 727  7 channel 1 690  5 value 1 733  
149 14 Dtool_BCNhH3Pi 0 4 122 691 0 14 Dtool_BCNhH3Pi 317 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::fill_channel_nan
//       Access: Published
//  Description: Fills the indicated channel with NaN, leaving the
//               other channels unchanged.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  7 channel 1 690  
150 14 Dtool_BCNheiyb 0 4 123 691 0 14 Dtool_BCNheiyb 400 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::fill_channel_masked
//       Access: Published
//  Description: Fills the indicated channel with all of the same
//               value, but only where the table already has a data
//               point.  Leaves empty points unchanged.
//////////////////////////////////////////////////////////////////// 3 4 this 3 727  7 channel 1 690  5 value 1 733  
151 14 Dtool_BCNhZSM1 0 4 124 691 0 14 Dtool_BCNhZSM1 386 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::fill_channel_masked_nan
//       Access: Published
//  Description: Fills the indicated channel with NaN, but only where
//               the table already has a data point.  Leaves empty
//               points unchanged.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  7 channel 1 690  
152 14 Dtool_BCNh7tIH 0 6 125 709 0 14 Dtool_BCNh7tIH 587 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::calc_average_point
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 5 4 this 3 728  6 result 1 753  1 x 1 733  1 y 1 733  6 radius 1 733  
153 14 Dtool_BCNhDLy3 0 6 126 709 0 14 Dtool_BCNhDLy3 451 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::calc_bilinear_point
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 4 4 this 3 728  6 result 1 753  1 x 1 733  1 y 1 733  
154 14 Dtool_BCNhsLyS 0 6 127 709 0 14 Dtool_BCNhsLyS 515 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::calc_min_max
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 3 4 this 3 728  10 min_points 1 764  10 max_points 1 764  
155 14 Dtool_BCNhl8Jt 0 6 128 709 0 14 Dtool_BCNhl8Jt 520 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::calc_autocrop
//       Access: Published
//  Description: 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()).
//////////////////////////////////////////////////////////////////// 2 4 this 3 728  5 range 1 765  
156 14 Dtool_BCNhC8pw 0 6 128 709 0 14 Dtool_BCNhC8pw 520 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::calc_autocrop
//       Access: Published
//  Description: 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()).
//////////////////////////////////////////////////////////////////// 2 4 this 3 728  5 range 1 766  
157 14 Dtool_BCNheU4g 0 6 129 709 0 14 Dtool_BCNheU4g 401 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::is_row_empty
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 4 4 this 3 728  1 y 1 690  7 x_begin 1 690  5 x_end 1 690  
158 14 Dtool_BCNha8z0 0 6 130 709 0 14 Dtool_BCNha8z0 399 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::is_column_empty
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 4 4 this 3 728  1 x 1 690  7 y_begin 1 690  5 y_end 1 690  
159 14 Dtool_BCNh2cwR 0 4 131 691 0 14 Dtool_BCNh2cwR 468 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_zero_special
//       Access: Published
//  Description: 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().
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  12 zero_special 1 709  
160 14 Dtool_BCNhOIvm 0 4 132 691 0 14 Dtool_BCNhOIvm 534 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_no_data_chan4
//       Access: Published
//  Description: 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().
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  5 chan4 1 709  
161 14 Dtool_BCNhwwZx 0 4 133 691 0 14 Dtool_BCNhwwZx 562 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_no_data_nan
//       Access: Published
//  Description: 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().
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  12 num_channels 1 690  
162 14 Dtool_BCNhPx5P 0 4 134 691 0 14 Dtool_BCNhPx5P 319 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_no_data_value
//       Access: Published
//  Description: Sets the special value that means "no data" when it
//               appears in the pfm file.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  13 no_data_value 1 767  
163 14 Dtool_BCNhXuDQ 0 4 134 691 0 14 Dtool_BCNhXuDQ 319 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_no_data_value
//       Access: Published
//  Description: Sets the special value that means "no data" when it
//               appears in the pfm file.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  13 no_data_value 1 754  
164 14 Dtool_BCNhQzz3 0 4 135 691 0 14 Dtool_BCNhQzz3 376 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_no_data_threshold
//       Access: Published
//  Description: Sets the special threshold value.  Points that are
//               below this value in all components are considered "no
//               value".
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  13 no_data_value 1 767  
165 14 Dtool_BCNhVYzX 0 4 135 691 0 14 Dtool_BCNhVYzX 376 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_no_data_threshold
//       Access: Published
//  Description: Sets the special threshold value.  Points that are
//               below this value in all components are considered "no
//               value".
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  13 no_data_value 1 754  
166 14 Dtool_BCNh7Fnh 0 4 136 691 0 14 Dtool_BCNh7Fnh 382 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::set_no_data_value
//       Access: Published
//  Description: Removes the special value that means "no data" when it
//               appears in the pfm file.  All points will thus be
//               considered valid.
//////////////////////////////////////////////////////////////////// 1 4 this 3 727  
167 14 Dtool_BCNh5uAw 0 6 137 709 0 14 Dtool_BCNh5uAw 321 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::has_no_data_value
//       Access: Published
//  Description: Returns whether a "no data" value has been
//               established by set_no_data_value().
//////////////////////////////////////////////////////////////////// 1 4 this 3 728  
168 14 Dtool_BCNhlRuN 0 6 138 709 0 14 Dtool_BCNhlRuN 339 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::has_no_data_threshold
//       Access: Published
//  Description: Returns whether a "no data" threshold value has been
//               established by set_no_data_threshold().
//////////////////////////////////////////////////////////////////// 1 4 this 3 728  
169 14 Dtool_BCNh92u6 0 6 139 754 0 14 Dtool_BCNh92u6 324 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::get_no_data_value
//       Access: Published
//  Description: If has_no_data_value() returns true, this returns the
//               particular "no data" value.
//////////////////////////////////////////////////////////////////// 1 4 this 3 728  
170 14 Dtool_BCNhAwaU 0 4 140 691 0 14 Dtool_BCNhAwaU 422 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::resize
//       Access: Published
//  Description: 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().
//////////////////////////////////////////////////////////////////// 3 4 this 3 727  10 new_x_size 1 690  10 new_y_size 1 690  
171 14 Dtool_BCNhjjnM 0 4 141 691 0 14 Dtool_BCNhjjnM 529 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::box_filter_from
//       Access: Public
//  Description: 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.
//////////////////////////////////////////////////////////////////// 3 4 this 3 727  6 radius 1 694  4 copy 1 728  
172 14 Dtool_BCNhjhAl 0 4 142 691 0 14 Dtool_BCNhjhAl 534 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::gaussian_filter_from
//       Access: Public
//  Description: 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.
//////////////////////////////////////////////////////////////////// 3 4 this 3 727  6 radius 1 694  4 copy 1 728  
173 14 Dtool_BCNhxXOb 0 4 143 691 0 14 Dtool_BCNhxXOb 528 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::quick_filter_from
//       Access: Public
//  Description: 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.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  4 copy 1 728  
174 14 Dtool_BCNhxkF_ 0 4 144 691 0 14 Dtool_BCNhxkF_ 271 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::reverse_rows
//       Access: Published
//  Description: Performs an in-place reversal of the row (y) data.
//////////////////////////////////////////////////////////////////// 1 4 this 3 727  
175 14 Dtool_BCNh20m3 0 4 145 691 0 14 Dtool_BCNh20m3 661 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::flip
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 4 4 this 3 727  6 flip_x 1 709  6 flip_y 1 709  9 transpose 1 709  
176 14 Dtool_BCNhjS6J 0 4 146 691 0 14 Dtool_BCNhjS6J 293 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::xform
//       Access: Published
//  Description: Applies the indicated transform matrix to all points
//               in-place.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  9 transform 1 770  
177 14 Dtool_BCNh7Z6l 0 4 146 691 0 14 Dtool_BCNh7Z6l 293 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::xform
//       Access: Published
//  Description: Applies the indicated transform matrix to all points
//               in-place.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  9 transform 1 773  
178 14 Dtool_BCNh8D3N 0 4 147 691 0 14 Dtool_BCNh8D3N 1065 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::forward_distort
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 3 4 this 3 727  4 dist 1 728  12 scale_factor 1 733  
179 14 Dtool_BCNhJosg 0 4 147 691 0 14 Dtool_BCNhJosg 1065 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::forward_distort
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  4 dist 1 728  
180 14 Dtool_BCNhuslk 0 4 148 691 0 14 Dtool_BCNhuslk 1063 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::reverse_distort
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 3 4 this 3 727  4 dist 1 728  12 scale_factor 1 733  
181 14 Dtool_BCNh7Ga3 0 4 148 691 0 14 Dtool_BCNh7Ga3 1063 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::reverse_distort
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  4 dist 1 728  
182 14 Dtool_BCNhF13_ 0 4 149 691 0 14 Dtool_BCNhF13_ 447 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::merge
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 2 4 this 3 727  5 other 1 728  
183 14 Dtool_BCNhdgPC 0 4 150 691 0 14 Dtool_BCNhdgPC 400 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::copy_channel
//       Access: Published
//  Description: Copies just the specified channel values from the
//               indicated PfmFile (which could be same as this
//               PfmFile) into the specified channel of this one.
//////////////////////////////////////////////////////////////////// 4 4 this 3 727  10 to_channel 1 690  5 other 1 728  12 from_channel 1 690  
184 14 Dtool_BCNh1_UE 0 4 151 691 0 14 Dtool_BCNh1_UE 378 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::copy_channel_masked
//       Access: Published
//  Description: Copies just the specified channel values from the
//               indicated PfmFile, but only where the other file has
//               a data point.
//////////////////////////////////////////////////////////////////// 4 4 this 3 727  10 to_channel 1 690  5 other 1 728  12 from_channel 1 690  
185 14 Dtool_BCNhq8Xi 0 4 152 691 0 14 Dtool_BCNhq8Xi 387 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::apply_crop
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 5 4 this 3 727  7 x_begin 1 690  5 x_end 1 690  7 y_begin 1 690  5 y_end 1 690  
186 14 Dtool_BCNhBlT0 0 4 153 691 0 14 Dtool_BCNhBlT0 406 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::clear_to_texcoords
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 3 4 this 3 727  6 x_size 1 690  6 y_size 1 690  
187 14 Dtool_BCNhRe5B 0 6 154 690 0 14 Dtool_BCNhRe5B 528 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::pull_spot
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 7 4 this 3 727  5 delta 1 754  2 xc 1 694  2 yc 1 694  2 xr 1 694  2 yr 1 694  8 exponent 1 694  
188 14 Dtool_BCNhgnbM 0 6 155 709 0 14 Dtool_BCNhgnbM 487 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::calc_tight_bounds
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 3 4 this 3 728  9 min_point 1 753  9 max_point 1 753  
189 14 Dtool_BCNhBx_b 0 7 156 780 0 14 Dtool_BCNhBx_b 1039 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::compute_planar_bounds
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 5 4 this 3 728  6 center 1 777  10 point_dist 1 733  13 sample_radius 1 733  11 points_only 1 709  
190 14 Dtool_BCNhMW_7 0 7 156 780 0 14 Dtool_BCNhMW_7 1039 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::compute_planar_bounds
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 5 4 this 3 728  6 center 1 734  10 point_dist 1 733  13 sample_radius 1 733  11 points_only 1 709  
191 14 Dtool_BCNhbj0E 0 4 157 691 0 14 Dtool_BCNhbj0E 468 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::compute_sample_point
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 5 4 this 3 728  6 result 1 753  1 x 1 733  1 y 1 733  13 sample_radius 1 733  
192 14 Dtool_BCNhO9ZV 0 4 158 691 0 14 Dtool_BCNhO9ZV 646 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::copy_sub_image
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 8 4 this 3 727  4 copy 1 728  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  6 x_size 1 690  6 y_size 1 690  
193 14 Dtool_BCNhE9Xn 0 4 158 691 0 14 Dtool_BCNhE9Xn 646 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::copy_sub_image
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 7 4 this 3 727  4 copy 1 728  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  6 x_size 1 690  
194 14 Dtool_BCNhHCXw 0 4 158 691 0 14 Dtool_BCNhHCXw 646 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::copy_sub_image
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 6 4 this 3 727  4 copy 1 728  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  
195 14 Dtool_BCNh1t3U 0 4 158 691 0 14 Dtool_BCNh1t3U 646 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::copy_sub_image
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 5 4 this 3 727  4 copy 1 728  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  
196 14 Dtool_BCNh3vGn 0 4 158 691 0 14 Dtool_BCNh3vGn 646 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::copy_sub_image
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 4 4 this 3 727  4 copy 1 728  3 xto 1 690  3 yto 1 690  
197 14 Dtool_BCNheHYK 0 4 159 691 0 14 Dtool_BCNheHYK 214 ////////////////////////////////////////////////////////////////////
//     Function: PfmFile::output
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 728  3 out 1 703  
198 14 Dtool_BCNhg1ML 0 6 160 781 0 14 Dtool_BCNhg1ML 0 1 4 this 3 728  
199 14 Dtool_BCNhGfTK 0 6 161 690 0 14 Dtool_BCNhGfTK 0 4 4 this 3 728  4 self 1 781  4 view 1 783  5 flags 1 690  
200 14 Dtool_BCNhX5Ct 0 7 166 785 0 14 Dtool_BCNhX5Ct 414 ////////////////////////////////////////////////////////////////////
//     Function: PNMBrush::make_transparent
//       Access: Published, Static
//  Description: Returns a new brush that does not paint anything.
//               Can be used as either a pen or a fill brush to make
//               borderless or unfilled shapes, respectively.
//////////////////////////////////////////////////////////////////// 0 
201 14 Dtool_BCNhEIGY 0 7 167 785 0 14 Dtool_BCNhEIGY 384 ////////////////////////////////////////////////////////////////////
//     Function: PNMBrush::make_pixel
//       Access: Published, Static
//  Description: Returns a new brush that paints a single pixel of the
//               indicated color on a border, or paints a solid color
//               in an interior.
//////////////////////////////////////////////////////////////////// 2 5 color 1 757  6 effect 1 686  
202 14 Dtool_BCNhU4t_ 0 7 167 785 0 14 Dtool_BCNhU4t_ 384 ////////////////////////////////////////////////////////////////////
//     Function: PNMBrush::make_pixel
//       Access: Published, Static
//  Description: Returns a new brush that paints a single pixel of the
//               indicated color on a border, or paints a solid color
//               in an interior.
//////////////////////////////////////////////////////////////////// 1 5 color 1 757  
203 14 Dtool_BCNhFWh_ 0 7 168 785 0 14 Dtool_BCNhFWh_ 401 ////////////////////////////////////////////////////////////////////
//     Function: PNMBrush::make_spot
//       Access: Published, Static
//  Description: Returns a new brush that paints a spot of the
//               indicated color and radius.  If fuzzy is true, the
//               spot is fuzzy; otherwise, it is hard-edged.
//////////////////////////////////////////////////////////////////// 4 5 color 1 757  6 radius 1 694  5 fuzzy 1 709  6 effect 1 686  
204 14 Dtool_BCNhgvau 0 7 168 785 0 14 Dtool_BCNhgvau 401 ////////////////////////////////////////////////////////////////////
//     Function: PNMBrush::make_spot
//       Access: Published, Static
//  Description: Returns a new brush that paints a spot of the
//               indicated color and radius.  If fuzzy is true, the
//               spot is fuzzy; otherwise, it is hard-edged.
//////////////////////////////////////////////////////////////////// 3 5 color 1 757  6 radius 1 694  5 fuzzy 1 709  
205 14 Dtool_BCNhmniy 0 7 169 785 0 14 Dtool_BCNhmniy 537 ////////////////////////////////////////////////////////////////////
//     Function: PNMBrush::make_image
//       Access: Published, Static
//  Description: Returns a new brush that paints with the indicated
//               image.  xc and yc indicate the pixel in the center of
//               the brush.
//
//               The brush makes a copy of the image; it is safe to
//               deallocate or modify the image after making this
//               call.
//////////////////////////////////////////////////////////////////// 4 5 image 1 730  2 xc 1 694  2 yc 1 694  6 effect 1 686  
206 14 Dtool_BCNh1ifs 0 7 169 785 0 14 Dtool_BCNh1ifs 537 ////////////////////////////////////////////////////////////////////
//     Function: PNMBrush::make_image
//       Access: Published, Static
//  Description: Returns a new brush that paints with the indicated
//               image.  xc and yc indicate the pixel in the center of
//               the brush.
//
//               The brush makes a copy of the image; it is safe to
//               deallocate or modify the image after making this
//               call.
//////////////////////////////////////////////////////////////////// 3 5 image 1 730  2 xc 1 694  2 yc 1 694  
207 14 Dtool_BCNhJuU_ 0 7 171 732 564 14 Dtool_BCNhJuU_ 704 // Filename: pnmImage.I
// Created by:  drose (15Jun00)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//     Function: PNMImage::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 0 
208 14 Dtool_BCNhZniN 0 7 171 732 564 14 Dtool_BCNhZniN 220 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 8 filename 1 710  4 type 1 702  
209 14 Dtool_BCNhGo3y 0 7 171 732 564 14 Dtool_BCNhGo3y 220 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 8 filename 1 710  
210 14 Dtool_BCNh9JI_ 0 7 171 732 564 14 Dtool_BCNh9JI_ 225 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::Copy Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 1 4 copy 1 730  
211 14 Dtool_BCNhGUHz 0 7 171 732 564 14 Dtool_BCNhGUHz 220 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 5 6 x_size 1 690  6 y_size 1 690  12 num_channels 1 690  6 maxval 1 674  4 type 1 702  
212 14 Dtool_BCNh3kSc 0 7 171 732 564 14 Dtool_BCNh3kSc 220 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 4 6 x_size 1 690  6 y_size 1 690  12 num_channels 1 690  6 maxval 1 674  
213 14 Dtool_BCNh0Ehq 0 7 171 732 564 14 Dtool_BCNh0Ehq 220 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 3 6 x_size 1 690  6 y_size 1 690  12 num_channels 1 690  
214 14 Dtool_BCNhxphz 0 7 171 732 564 14 Dtool_BCNhxphz 220 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::Constructor
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 6 x_size 1 690  6 y_size 1 690  
215 14 Dtool_BCNhW6D7 0 6 172 732 0 14 Dtool_BCNhW6D7 233 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::Copy Assignment Operator
//       Access: Published
//  Description:
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  4 copy 1 730  
216 14 Dtool_BCNh1Od2 0 6 174 674 0 14 Dtool_BCNh1Od2 290 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::clamp_val
//       Access: Published
//  Description: A handy function to clamp values to
//               [0..get_maxval()].
//////////////////////////////////////////////////////////////////// 2 4 this 3 730  11 input_value 1 690  
217 14 Dtool_BCNhJVnd 0 6 175 674 0 14 Dtool_BCNhJVnd 299 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::to_val
//       Access: Published
//  Description: A handy function to scale values from [0..1] to
//               [0..get_maxval()].
//////////////////////////////////////////////////////////////////// 2 4 this 3 730  11 input_value 1 694  
218 14 Dtool_BCNh78bW 0 6 176 694 0 14 Dtool_BCNh78bW 301 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::from_val
//       Access: Published
//  Description: A handy function to scale values from
//               [0..get_maxval()] to [0..1].
//////////////////////////////////////////////////////////////////// 2 4 this 3 730  11 input_value 1 674  
219 14 Dtool_BCNhgRyO 0 4 177 691 0 14 Dtool_BCNhgRyO 329 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::clear
//       Access: Published
//  Description: Frees all memory allocated for the image, and clears
//               all its parameters (size, color, type, etc).
//////////////////////////////////////////////////////////////////// 1 4 this 3 732  
220 14 Dtool_BCNhFn3z 0 4 177 691 0 14 Dtool_BCNhFn3z 331 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::clear
//       Access: Published
//  Description: This flavor of clear() reinitializes the image to an
//               empty (black) image with the given dimensions.
//////////////////////////////////////////////////////////////////// 6 4 this 3 732  6 x_size 1 690  6 y_size 1 690  12 num_channels 1 690  6 maxval 1 674  4 type 1 702  
221 14 Dtool_BCNh32h2 0 4 177 691 0 14 Dtool_BCNh32h2 331 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::clear
//       Access: Published
//  Description: This flavor of clear() reinitializes the image to an
//               empty (black) image with the given dimensions.
//////////////////////////////////////////////////////////////////// 5 4 this 3 732  6 x_size 1 690  6 y_size 1 690  12 num_channels 1 690  6 maxval 1 674  
222 14 Dtool_BCNhJDi_ 0 4 177 691 0 14 Dtool_BCNhJDi_ 331 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::clear
//       Access: Published
//  Description: This flavor of clear() reinitializes the image to an
//               empty (black) image with the given dimensions.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  6 x_size 1 690  6 y_size 1 690  12 num_channels 1 690  
223 14 Dtool_BCNhJQp3 0 4 177 691 0 14 Dtool_BCNhJQp3 331 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::clear
//       Access: Published
//  Description: This flavor of clear() reinitializes the image to an
//               empty (black) image with the given dimensions.
//////////////////////////////////////////////////////////////////// 3 4 this 3 732  6 x_size 1 690  6 y_size 1 690  
224 14 Dtool_BCNh1EcB 0 4 178 691 0 14 Dtool_BCNh1EcB 269 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::copy_from
//       Access: Published
//  Description: Makes this image become a copy of the other image.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  4 copy 1 730  
225 14 Dtool_BCNh7qGl 0 4 179 691 0 14 Dtool_BCNh7qGl 313 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::copy_channel
//       Access: Published
//  Description: Copies a channel from one image into another.
//               Images must be the same size
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  4 copy 1 730  11 src_channel 1 690  12 dest_channel 1 690  
226 14 Dtool_BCNhfWin 0 4 179 691 0 14 Dtool_BCNhfWin 381 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::copy_channel
//       Access: Published
//  Description: Copies just a single channel from the source image
//               into a single channel of this image, leaving the
//               remaining channels alone.
//////////////////////////////////////////////////////////////////// 10 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  3 cto 1 690  5 xfrom 1 690  5 yfrom 1 690  5 cfrom 1 690  6 x_size 1 690  6 y_size 1 690  
227 14 Dtool_BCNhv6bv 0 4 179 691 0 14 Dtool_BCNhv6bv 381 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::copy_channel
//       Access: Published
//  Description: Copies just a single channel from the source image
//               into a single channel of this image, leaving the
//               remaining channels alone.
//////////////////////////////////////////////////////////////////// 9 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  3 cto 1 690  5 xfrom 1 690  5 yfrom 1 690  5 cfrom 1 690  6 x_size 1 690  
228 14 Dtool_BCNhy9XT 0 4 179 691 0 14 Dtool_BCNhy9XT 381 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::copy_channel
//       Access: Published
//  Description: Copies just a single channel from the source image
//               into a single channel of this image, leaving the
//               remaining channels alone.
//////////////////////////////////////////////////////////////////// 8 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  3 cto 1 690  5 xfrom 1 690  5 yfrom 1 690  5 cfrom 1 690  
229 14 Dtool_BCNhFKXl 0 4 179 691 0 14 Dtool_BCNhFKXl 381 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::copy_channel
//       Access: Published
//  Description: Copies just a single channel from the source image
//               into a single channel of this image, leaving the
//               remaining channels alone.
//////////////////////////////////////////////////////////////////// 7 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  3 cto 1 690  5 xfrom 1 690  5 yfrom 1 690  
230 14 Dtool_BCNhItVu 0 4 179 691 0 14 Dtool_BCNhItVu 381 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::copy_channel
//       Access: Published
//  Description: Copies just a single channel from the source image
//               into a single channel of this image, leaving the
//               remaining channels alone.
//////////////////////////////////////////////////////////////////// 6 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  3 cto 1 690  5 xfrom 1 690  
231 14 Dtool_BCNhVR0S 0 4 179 691 0 14 Dtool_BCNhVR0S 381 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::copy_channel
//       Access: Published
//  Description: Copies just a single channel from the source image
//               into a single channel of this image, leaving the
//               remaining channels alone.
//////////////////////////////////////////////////////////////////// 5 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  3 cto 1 690  
232 14 Dtool_BCNhfIQ5 0 4 180 691 0 14 Dtool_BCNhfIQ5 445 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::copy_header_from
//       Access: Published
//  Description: Copies just the header information into this image.
//               This will blow away any image data stored in the
//               image.  The new image data will be allocated, but
//               left unitialized.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  6 header 1 707  
233 14 Dtool_BCNhNRgL 0 4 181 691 0 14 Dtool_BCNhNRgL 314 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::take_from
//       Access: Published
//  Description: Move the contents of the other image into this one,
//               and empty the other image.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  4 orig 1 732  
234 14 Dtool_BCNhVQQT 0 4 182 691 0 14 Dtool_BCNhVQQT 309 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::fill
//       Access: Published
//  Description: Sets the entire image (except the alpha channel) to
//               the given grayscale level.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  4 gray 1 694  
235 14 Dtool_BCNh_Hno 0 4 182 691 0 14 Dtool_BCNh_Hno 309 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::fill
//       Access: Published
//  Description: Sets the entire image (except the alpha channel) to
//               the given grayscale level.
//////////////////////////////////////////////////////////////////// 1 4 this 3 732  
236 14 Dtool_BCNhFZy4 0 4 182 691 0 14 Dtool_BCNhFZy4 299 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::fill
//       Access: Published
//  Description: Sets the entire image (except the alpha channel) to
//               the given color.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  3 red 1 694  5 green 1 694  4 blue 1 694  
237 14 Dtool_BCNh9TTf 0 4 183 691 0 14 Dtool_BCNh9TTf 313 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::fill_val
//       Access: Published
//  Description: Sets the entire image (except the alpha channel) to
//               the given grayscale level.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  4 gray 1 674  
238 14 Dtool_BCNhgsJ_ 0 4 183 691 0 14 Dtool_BCNhgsJ_ 313 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::fill_val
//       Access: Published
//  Description: Sets the entire image (except the alpha channel) to
//               the given grayscale level.
//////////////////////////////////////////////////////////////////// 1 4 this 3 732  
239 14 Dtool_BCNhJAW_ 0 4 183 691 0 14 Dtool_BCNhJAW_ 303 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::fill_val
//       Access: Published
//  Description: Sets the entire image (except the alpha channel) to
//               the given color.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  3 red 1 674  5 green 1 674  4 blue 1 674  
240 14 Dtool_BCNhJekT 0 4 184 691 0 14 Dtool_BCNhJekT 269 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::alpha_fill
//       Access: Published
//  Description: Sets the entire alpha channel to the given level.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  5 alpha 1 694  
241 14 Dtool_BCNhZk_o 0 4 184 691 0 14 Dtool_BCNhZk_o 269 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::alpha_fill
//       Access: Published
//  Description: Sets the entire alpha channel to the given level.
//////////////////////////////////////////////////////////////////// 1 4 this 3 732  
242 14 Dtool_BCNh_dAZ 0 4 185 691 0 14 Dtool_BCNh_dAZ 273 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::alpha_fill_val
//       Access: Published
//  Description: Sets the entire alpha channel to the given level.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  5 alpha 1 674  
243 14 Dtool_BCNh7C1N 0 4 185 691 0 14 Dtool_BCNh7C1N 273 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::alpha_fill_val
//       Access: Published
//  Description: Sets the entire alpha channel to the given level.
//////////////////////////////////////////////////////////////////// 1 4 this 3 732  
244 14 Dtool_BCNhXK1K 0 4 186 691 0 14 Dtool_BCNhXK1K 855 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_read_size
//       Access: Published
//  Description: Specifies the size to we'd like to scale the image
//               upon reading it.  This will affect the next call to
//               read().  This is usually used to reduce the image
//               size, e.g. for a thumbnail.
//
//               If the file type reader supports it (e.g. JPEG), then
//               this will scale the image during the read operation,
//               consequently reducing memory and CPU utilization.  If
//               the file type reader does not support it, this will
//               load the image normally, and them perform a linear
//               scale after it has been loaded.
//////////////////////////////////////////////////////////////////// 3 4 this 3 732  6 x_size 1 690  6 y_size 1 690  
245 14 Dtool_BCNhILYS 0 4 187 691 0 14 Dtool_BCNhILYS 298 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::clear_read_size
//       Access: Published
//  Description: Undoes the effect of a previous call to
//               set_read_size().
//////////////////////////////////////////////////////////////////// 1 4 this 3 732  
246 14 Dtool_BCNhx2p1 0 6 188 709 0 14 Dtool_BCNhx2p1 271 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::has_read_size
//       Access: Published
//  Description: Returns true if set_read_size() has been called.
//////////////////////////////////////////////////////////////////// 1 4 this 3 730  
247 14 Dtool_BCNh9mAj 0 6 189 690 0 14 Dtool_BCNh9mAj 384 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_read_x_size
//       Access: Published
//  Description: Returns the requested x_size of the image if
//               set_read_size() has been called, or the image x_size
//               otherwise (if it is known).
//////////////////////////////////////////////////////////////////// 1 4 this 3 730  
248 14 Dtool_BCNh69BD 0 6 190 690 0 14 Dtool_BCNh69BD 384 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_read_y_size
//       Access: Published
//  Description: Returns the requested y_size of the image if
//               set_read_size() has been called, or the image y_size
//               otherwise (if it is known).
//////////////////////////////////////////////////////////////////// 1 4 this 3 730  
249 14 Dtool_BCNhC64S 0 6 191 709 0 14 Dtool_BCNhC64S 397 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::read
//       Access: Published
//  Description: Reads the indicated image filename.  If type is
//               non-NULL, it is a suggestion for the type of file it
//               is.  Returns true if successful, false on error.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  8 filename 1 710  4 type 1 702  19 report_unknown_type 1 709  
250 14 Dtool_BCNhPAvM 0 6 191 709 0 14 Dtool_BCNhPAvM 397 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::read
//       Access: Published
//  Description: Reads the indicated image filename.  If type is
//               non-NULL, it is a suggestion for the type of file it
//               is.  Returns true if successful, false on error.
//////////////////////////////////////////////////////////////////// 3 4 this 3 732  8 filename 1 710  4 type 1 702  
251 14 Dtool_BCNhvCUh 0 6 191 709 0 14 Dtool_BCNhvCUh 397 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::read
//       Access: Published
//  Description: Reads the indicated image filename.  If type is
//               non-NULL, it is a suggestion for the type of file it
//               is.  Returns true if successful, false on error.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  8 filename 1 710  
252 14 Dtool_BCNhdJLw 0 6 191 709 0 14 Dtool_BCNhdJLw 692 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::read
//       Access: Published
//  Description: This flavor of read() uses an already-existing
//               PNMReader to read the image file.  You can get a
//               reader via the PNMImageHeader::make_reader() methods.
//               This is a good way to examine the header of a file
//               (for instance, to determine its size) before actually
//               reading the entire image.
//
//               The PNMReader is always deleted upon completion,
//               whether successful or not.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  6 reader 1 715  
253 14 Dtool_BCNh9o7O 0 6 191 709 0 14 Dtool_BCNh9o7O 665 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::read
//       Access: Published
//  Description: Reads the image data from the indicated stream.
//
//               The filename is advisory only, and may be used
//               to suggest a type if it has a known extension.
//
//               If type is non-NULL, it is a suggestion for the type
//               of file it is (and a non-NULL type will override any
//               magic number test or filename extension lookup).
//
//               Returns true if successful, false on error.
//////////////////////////////////////////////////////////////////// 5 4 this 3 732  4 data 1 713  8 filename 1 697  4 type 1 702  19 report_unknown_type 1 709  
254 14 Dtool_BCNhwKxG 0 6 191 709 0 14 Dtool_BCNhwKxG 665 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::read
//       Access: Published
//  Description: Reads the image data from the indicated stream.
//
//               The filename is advisory only, and may be used
//               to suggest a type if it has a known extension.
//
//               If type is non-NULL, it is a suggestion for the type
//               of file it is (and a non-NULL type will override any
//               magic number test or filename extension lookup).
//
//               Returns true if successful, false on error.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  4 data 1 713  8 filename 1 697  4 type 1 702  
255 14 Dtool_BCNhgtc5 0 6 191 709 0 14 Dtool_BCNhgtc5 665 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::read
//       Access: Published
//  Description: Reads the image data from the indicated stream.
//
//               The filename is advisory only, and may be used
//               to suggest a type if it has a known extension.
//
//               If type is non-NULL, it is a suggestion for the type
//               of file it is (and a non-NULL type will override any
//               magic number test or filename extension lookup).
//
//               Returns true if successful, false on error.
//////////////////////////////////////////////////////////////////// 3 4 this 3 732  4 data 1 713  8 filename 1 697  
256 14 Dtool_BCNh5luU 0 6 191 709 0 14 Dtool_BCNh5luU 665 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::read
//       Access: Published
//  Description: Reads the image data from the indicated stream.
//
//               The filename is advisory only, and may be used
//               to suggest a type if it has a known extension.
//
//               If type is non-NULL, it is a suggestion for the type
//               of file it is (and a non-NULL type will override any
//               magic number test or filename extension lookup).
//
//               Returns true if successful, false on error.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  4 data 1 713  
257 14 Dtool_BCNhryAQ 0 6 192 709 0 14 Dtool_BCNhryAQ 370 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::write
//       Access: Published
//  Description: Writes the image to the indicated filename.  If type
//               is non-NULL, it is a suggestion for the type of image
//               file to write.
//////////////////////////////////////////////////////////////////// 3 4 this 3 730  8 filename 1 710  4 type 1 702  
258 14 Dtool_BCNhibdu 0 6 192 709 0 14 Dtool_BCNhibdu 370 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::write
//       Access: Published
//  Description: Writes the image to the indicated filename.  If type
//               is non-NULL, it is a suggestion for the type of image
//               file to write.
//////////////////////////////////////////////////////////////////// 2 4 this 3 730  8 filename 1 710  
259 14 Dtool_BCNhl0d0 0 6 192 709 0 14 Dtool_BCNhl0d0 513 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::write
//       Access: Published
//  Description: This flavor of write() uses an already-existing
//               PNMWriter to write the image file.  You can get a
//               writer via the PNMImageHeader::make_writer() methods.
//
//               The PNMWriter is always deleted upon completion,
//               whether successful or not.
//////////////////////////////////////////////////////////////////// 2 4 this 3 730  6 writer 1 717  
260 14 Dtool_BCNh3I_7 0 6 192 709 0 14 Dtool_BCNh3I_7 499 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::write
//       Access: Published
//  Description: Writes the image to the indicated ostream.
//
//               The filename is advisory only, and may be used
//               suggest a type if it has a known extension.
//
//               If type is non-NULL, it is a suggestion for the type
//               of image file to write.
//////////////////////////////////////////////////////////////////// 4 4 this 3 730  4 data 1 703  8 filename 1 697  4 type 1 702  
261 14 Dtool_BCNhSl_y 0 6 192 709 0 14 Dtool_BCNhSl_y 499 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::write
//       Access: Published
//  Description: Writes the image to the indicated ostream.
//
//               The filename is advisory only, and may be used
//               suggest a type if it has a known extension.
//
//               If type is non-NULL, it is a suggestion for the type
//               of image file to write.
//////////////////////////////////////////////////////////////////// 3 4 this 3 730  4 data 1 703  8 filename 1 697  
262 14 Dtool_BCNhlWrL 0 6 192 709 0 14 Dtool_BCNhlWrL 499 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::write
//       Access: Published
//  Description: Writes the image to the indicated ostream.
//
//               The filename is advisory only, and may be used
//               suggest a type if it has a known extension.
//
//               If type is non-NULL, it is a suggestion for the type
//               of image file to write.
//////////////////////////////////////////////////////////////////// 2 4 this 3 730  4 data 1 703  
263 14 Dtool_BCNhbtI8 0 6 193 709 0 14 Dtool_BCNhbtI8 470 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::is_valid
//       Access: Published
//  Description: Returns true if the image has been read in or
//               correctly initialized with a height and width.  If
//               this returns false, virtually all member functions
//               except clear() and read() are invalid function calls.
//////////////////////////////////////////////////////////////////// 1 4 this 3 730  
264 14 Dtool_BCNhvlnH 0 4 194 691 0 14 Dtool_BCNhvlnH 531 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_num_channels
//       Access: Published
//  Description: Changes the number of channels associated with the
//               image.  The new number of channels must be an integer
//               in the range 1 through 4, inclusive.  This will
//               allocate and/or deallocate memory as necessary to
//               accommodate; see set_color_type().
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  12 num_channels 1 690  
265 14 Dtool_BCNhHw_e 0 4 195 691 0 14 Dtool_BCNhHw_e 606 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_color_type
//       Access: Published
//  Description: Translates the image to or from grayscale, color, or
//               four-color mode.  Grayscale images are converted to
//               full-color images with R, G, B set to the original
//               gray level; color images are converted to grayscale
//               according to the value of Bright().  The alpha
//               channel, if added, is initialized to zero.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  10 color_type 1 679  
266 14 Dtool_BCNhudkF 0 4 196 691 0 14 Dtool_BCNhudkF 365 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::add_alpha
//       Access: Published
//  Description: Adds an alpha channel to the image, if it does not
//               already have one.  The alpha channel is initialized
//               to zeros.
//////////////////////////////////////////////////////////////////// 1 4 this 3 732  
267 14 Dtool_BCNhuXS6 0 4 197 691 0 14 Dtool_BCNhuXS6 270 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::remove_alpha
//       Access: Published
//  Description: Removes the image's alpha channel, if it exists.
//////////////////////////////////////////////////////////////////// 1 4 this 3 732  
268 14 Dtool_BCNhvd8W 0 4 198 691 0 14 Dtool_BCNhvd8W 335 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::make_grayscale
//       Access: Published
//  Description: Converts the image from RGB to grayscale.  Any alpha
//               channel, if present, is left undisturbed.
//////////////////////////////////////////////////////////////////// 1 4 this 3 732  
269 14 Dtool_BCNhsKwX 0 4 198 691 0 14 Dtool_BCNhsKwX 502 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::make_grayscale
//       Access: Published
//  Description: Converts the image from RGB to grayscale.  Any alpha
//               channel, if present, is left undisturbed.  The
//               optional rc, gc, bc values represent the relative
//               weights to apply to each channel to convert it to
//               grayscale.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  2 rc 1 694  2 gc 1 694  2 bc 1 694  
270 14 Dtool_BCNhWxCH 0 4 199 691 0 14 Dtool_BCNhWxCH 329 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::make_rgb
//       Access: Published
//  Description: Converts the image from grayscale to RGB.  Any alpha
//               channel, if present, is left undisturbed.
//////////////////////////////////////////////////////////////////// 1 4 this 3 732  
271 14 Dtool_BCNhkTj7 0 4 200 691 0 14 Dtool_BCNhkTj7 272 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::reverse_rows
//       Access: Published
//  Description: Performs an in-place reversal of the row (y) data.
//////////////////////////////////////////////////////////////////// 1 4 this 3 732  
272 14 Dtool_BCNhJnEt 0 4 201 691 0 14 Dtool_BCNhJnEt 662 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::flip
//       Access: Published
//  Description: Reverses, transposes, and/or rotates the image
//               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.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  6 flip_x 1 709  6 flip_y 1 709  9 transpose 1 709  
273 14 Dtool_BCNhqQ4f 0 4 202 691 0 14 Dtool_BCNhqQ4f 263 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_maxval
//       Access: Published
//  Description: Rescales the image to the indicated maxval.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  6 maxval 1 674  
274 14 Dtool_BCNhZ_t1 0 6 203 692 0 14 Dtool_BCNhZ_t1 326 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_xel_val
//       Access: Published
//  Description: Returns the RGB color at the indicated pixel.  Each
//               component is in the range 0..maxval.
//////////////////////////////////////////////////////////////////// 3 4 this 3 730  1 x 1 690  1 y 1 690  
275 14 Dtool_BCNhBLQe 0 4 204 691 0 14 Dtool_BCNhBLQe 326 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_xel_val
//       Access: Published
//  Description: Changes the RGB color at the indicated pixel.  Each
//               component is in the range 0..maxval.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  1 x 1 690  1 y 1 690  5 value 1 692  
276 14 Dtool_BCNhwSca 0 4 204 691 0 14 Dtool_BCNhwSca 369 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_xel_val
//       Access: Published
//  Description: Changes all three color components at the indicated
//               pixel to the same value.  The value is in the range
//               0..maxval.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  1 x 1 690  1 y 1 690  4 gray 1 674  
277 14 Dtool_BCNheokV 0 4 204 691 0 14 Dtool_BCNheokV 326 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_xel_val
//       Access: Published
//  Description: Changes the RGB color at the indicated pixel.  Each
//               component is in the range 0..maxval.
//////////////////////////////////////////////////////////////////// 6 4 this 3 732  1 x 1 690  1 y 1 690  1 r 1 674  1 g 1 674  1 b 1 674  
278 14 Dtool_BCNhvbnu 0 6 205 674 0 14 Dtool_BCNhvbnu 340 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_red_val
//       Access: Published
//  Description: Returns the red component color at the indicated
//               pixel.  The value returned is in the range 0..maxval.
//////////////////////////////////////////////////////////////////// 3 4 this 3 730  1 x 1 690  1 y 1 690  
279 14 Dtool_BCNhim_o 0 6 206 674 0 14 Dtool_BCNhim_o 344 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_green_val
//       Access: Published
//  Description: Returns the green component color at the indicated
//               pixel.  The value returned is in the range 0..maxval.
//////////////////////////////////////////////////////////////////// 3 4 this 3 730  1 x 1 690  1 y 1 690  
280 14 Dtool_BCNhfY0A 0 6 207 674 0 14 Dtool_BCNhfY0A 342 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_blue_val
//       Access: Published
//  Description: Returns the blue component color at the indicated
//               pixel.  The value returned is in the range 0..maxval.
//////////////////////////////////////////////////////////////////// 3 4 this 3 730  1 x 1 690  1 y 1 690  
281 14 Dtool_BCNh3oeE 0 6 208 674 0 14 Dtool_BCNh3oeE 584 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_gray_val
//       Access: Published
//  Description: Returns the gray component color at the indicated
//               pixel.  This only has a meaningful value for
//               grayscale images; for other image types, this returns
//               the value of the blue channel only.  However, also
//               see the get_bright() function.  The value returned is
//               in the range 0..maxval.
//////////////////////////////////////////////////////////////////// 3 4 this 3 730  1 x 1 690  1 y 1 690  
282 14 Dtool_BCNhKba3 0 6 209 674 0 14 Dtool_BCNhKba3 435 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_alpha_val
//       Access: Published
//  Description: Returns the alpha component color at the indicated
//               pixel.  It is an error to call this unless
//               has_alpha() is true.  The value returned is in the
//               range 0..maxval.
//////////////////////////////////////////////////////////////////// 3 4 this 3 730  1 x 1 690  1 y 1 690  
283 14 Dtool_BCNhB1WT 0 4 210 691 0 14 Dtool_BCNhB1WT 363 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_red_val
//       Access: Published
//  Description: Sets the red component color only at the indicated
//               pixel.  The value given should be in the range
//               0..maxval.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  1 x 1 690  1 y 1 690  1 r 1 674  
284 14 Dtool_BCNh4_Bi 0 4 211 691 0 14 Dtool_BCNh4_Bi 367 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_green_val
//       Access: Published
//  Description: Sets the green component color only at the indicated
//               pixel.  The value given should be in the range
//               0..maxval.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  1 x 1 690  1 y 1 690  1 g 1 674  
285 14 Dtool_BCNhq9d9 0 4 212 691 0 14 Dtool_BCNhq9d9 365 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_blue_val
//       Access: Published
//  Description: Sets the blue component color only at the indicated
//               pixel.  The value given should be in the range
//               0..maxval.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  1 x 1 690  1 y 1 690  1 b 1 674  
286 14 Dtool_BCNhjFIB 0 4 213 691 0 14 Dtool_BCNhjFIB 723 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_gray_val
//       Access: Published
//  Description: Sets the gray component color at the indicated
//               pixel.  This is only meaningful for grayscale images;
//               for other image types, this simply sets the blue
//               component color.  However, also see set_xel_val(),
//               which can set all the component colors to the same
//               grayscale level, and hence works correctly both for
//               grayscale and color images.  The value given should
//               be in the range 0..maxval.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  1 x 1 690  1 y 1 690  4 gray 1 674  
287 14 Dtool_BCNhjmcw 0 4 214 691 0 14 Dtool_BCNhjmcw 441 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_alpha_val
//       Access: Published
//  Description: Sets the alpha component color only at the indicated
//               pixel.  It is an error to call this unless
//               has_alpha() is true.  The value given should be in
//               the range 0..maxval.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  1 x 1 690  1 y 1 690  1 a 1 674  
288 14 Dtool_BCNh5dxI 0 6 215 674 0 14 Dtool_BCNh5dxI 630 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_channel_val
//       Access: Published
//  Description: Returns the nth component color at the indicated
//               pixel.  The channel index should be in the range
//               0..(get_num_channels()-1).  The channels are ordered B,
//               G, R, A.  This is slightly less optimal than
//               accessing the component values directly by named
//               methods.  The value returned is in the range
//               0..maxval.
//////////////////////////////////////////////////////////////////// 4 4 this 3 730  1 x 1 690  1 y 1 690  7 channel 1 690  
289 14 Dtool_BCNh4AHG 0 4 216 691 0 14 Dtool_BCNh4AHG 629 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_channel_val
//       Access: Published
//  Description: Sets the nth component color at the indicated
//               pixel.  The channel index should be in the range
//               0..(get_num_channels()-1).  The channels are ordered B,
//               G, R, A.  This is slightly less optimal than
//               setting the component values directly by named
//               methods.  The value given should be in the range
//               0..maxval.
//////////////////////////////////////////////////////////////////// 5 4 this 3 732  1 x 1 690  1 y 1 690  7 channel 1 690  5 value 1 674  
290 14 Dtool_BCNhEyf6 0 7 217 723 477 14 Dtool_BCNhEyf6 322 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_pixel
//       Access: Published
//  Description: Returns the (r, g, b, a) pixel value at the indicated
//               pixel, using a PixelSpec object.
//////////////////////////////////////////////////////////////////// 3 4 this 3 730  1 x 1 690  1 y 1 690  
291 14 Dtool_BCNh4idQ 0 4 218 691 0 14 Dtool_BCNh4idQ 319 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_pixel
//       Access: Published
//  Description: Sets the (r, g, b, a) pixel value at the indicated
//               pixel, using a PixelSpec object.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  1 x 1 690  1 y 1 690  5 pixel 1 721  
292 14 Dtool_BCNhE1Ub 0 7 219 786 0 14 Dtool_BCNhE1Ub 326 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_xel
//       Access: Published
//  Description: Returns the RGB color at the indicated pixel.  Each
//               component is a double in the range 0..1.
//////////////////////////////////////////////////////////////////// 3 4 this 3 730  1 x 1 690  1 y 1 690  
293 14 Dtool_BCNhlCyT 0 4 220 691 0 14 Dtool_BCNhlCyT 326 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_xel
//       Access: Published
//  Description: Changes the RGB color at the indicated pixel.  Each
//               component is a double in the range 0..1.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  1 x 1 690  1 y 1 690  5 value 1 747  
294 14 Dtool_BCNhkAzw 0 4 220 691 0 14 Dtool_BCNhkAzw 369 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_xel
//       Access: Published
//  Description: Changes all three color components at the indicated
//               pixel to the same value.  The value is a double in
//               the range 0..1.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  1 x 1 690  1 y 1 690  4 gray 1 694  
295 14 Dtool_BCNhJNjN 0 4 220 691 0 14 Dtool_BCNhJNjN 326 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_xel
//       Access: Published
//  Description: Changes the RGB color at the indicated pixel.  Each
//               component is a double in the range 0..1.
//////////////////////////////////////////////////////////////////// 6 4 this 3 732  1 x 1 690  1 y 1 690  1 r 1 694  1 g 1 694  1 b 1 694  
296 14 Dtool_BCNhV6AJ 0 7 221 765 0 14 Dtool_BCNhV6AJ 329 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_xel_a
//       Access: Published
//  Description: Returns the RGBA color at the indicated pixel.  Each
//               component is a double in the range 0..1.
//////////////////////////////////////////////////////////////////// 3 4 this 3 730  1 x 1 690  1 y 1 690  
297 14 Dtool_BCNh0Zb6 0 4 222 691 0 14 Dtool_BCNh0Zb6 329 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_xel_a
//       Access: Published
//  Description: Changes the RGBA color at the indicated pixel.  Each
//               component is a double in the range 0..1.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  1 x 1 690  1 y 1 690  5 value 1 757  
298 14 Dtool_BCNhkHvU 0 4 222 691 0 14 Dtool_BCNhkHvU 329 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_xel_a
//       Access: Published
//  Description: Changes the RGBA color at the indicated pixel.  Each
//               component is a double in the range 0..1.
//////////////////////////////////////////////////////////////////// 7 4 this 3 732  1 x 1 690  1 y 1 690  1 r 1 694  1 g 1 694  1 b 1 694  1 a 1 694  
299 14 Dtool_BCNh2WPU 0 6 223 694 0 14 Dtool_BCNh2WPU 357 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_red
//       Access: Published
//  Description: Returns the red component color at the indicated
//               pixel.  The value returned is a double in the range
//               0..1.
//////////////////////////////////////////////////////////////////// 3 4 this 3 730  1 x 1 690  1 y 1 690  
300 14 Dtool_BCNhhyC9 0 6 224 694 0 14 Dtool_BCNhhyC9 361 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_green
//       Access: Published
//  Description: Returns the green component color at the indicated
//               pixel.  The value returned is a double in the range
//               0..1.
//////////////////////////////////////////////////////////////////// 3 4 this 3 730  1 x 1 690  1 y 1 690  
301 14 Dtool_BCNhWrcz 0 6 225 694 0 14 Dtool_BCNhWrcz 359 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_blue
//       Access: Published
//  Description: Returns the blue component color at the indicated
//               pixel.  The value returned is a double in the range
//               0..1.
//////////////////////////////////////////////////////////////////// 3 4 this 3 730  1 x 1 690  1 y 1 690  
302 14 Dtool_BCNh55I3 0 6 226 694 0 14 Dtool_BCNh55I3 584 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_gray
//       Access: Published
//  Description: Returns the gray component color at the indicated
//               pixel.  This only has a meaningful value for
//               grayscale images; for other image types, this returns
//               the value of the blue channel only.  However, also
//               see the get_bright() function.  The value returned is
//               a double in the range 0..1.
//////////////////////////////////////////////////////////////////// 3 4 this 3 730  1 x 1 690  1 y 1 690  
303 14 Dtool_BCNha6eL 0 6 227 694 0 14 Dtool_BCNha6eL 435 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_alpha
//       Access: Published
//  Description: Returns the alpha component color at the indicated
//               pixel.  It is an error to call this unless
//               has_alpha() is true.  The value returned is a double
//               in the range 0..1.
//////////////////////////////////////////////////////////////////// 3 4 this 3 730  1 x 1 690  1 y 1 690  
304 14 Dtool_BCNhWqtp 0 4 228 691 0 14 Dtool_BCNhWqtp 363 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_red
//       Access: Published
//  Description: Sets the red component color only at the indicated
//               pixel.  The value given should be a double in the
//               range 0..1.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  1 x 1 690  1 y 1 690  1 r 1 694  
305 14 Dtool_BCNh2K1_ 0 4 229 691 0 14 Dtool_BCNh2K1_ 367 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_green
//       Access: Published
//  Description: Sets the green component color only at the indicated
//               pixel.  The value given should be a double in the
//               range 0..1.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  1 x 1 690  1 y 1 690  1 g 1 694  
306 14 Dtool_BCNhr0aG 0 4 230 691 0 14 Dtool_BCNhr0aG 365 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_blue
//       Access: Published
//  Description: Sets the blue component color only at the indicated
//               pixel.  The value given should be a double in the
//               range 0..1.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  1 x 1 690  1 y 1 690  1 b 1 694  
307 14 Dtool_BCNhiwGK 0 4 231 691 0 14 Dtool_BCNhiwGK 719 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_gray
//       Access: Published
//  Description: Sets the gray component color at the indicated
//               pixel.  This is only meaningful for grayscale images;
//               for other image types, this simply sets the blue
//               component color.  However, also see set_xel(), which
//               can set all the component colors to the same
//               grayscale level, and hence works correctly both for
//               grayscale and color images.  The value given should
//               be a double in the range 0..1.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  1 x 1 690  1 y 1 690  4 gray 1 694  
308 14 Dtool_BCNh9QPO 0 4 232 691 0 14 Dtool_BCNh9QPO 432 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_alpha
//       Access: Published
//  Description: Sets the alpha component color only at the indicated
//               pixel.  It is an error to call this unless
//               has_alpha() is true.  The value given should be in
//               the range 0..1.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  1 x 1 690  1 y 1 690  1 a 1 694  
309 14 Dtool_BCNhjZD3 0 6 233 694 0 14 Dtool_BCNhjZD3 630 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_channel
//       Access: Published
//  Description: Returns the nth component color at the indicated
//               pixel.  The channel index should be in the range
//               0..(get_num_channels()-1).  The channels are ordered B,
//               G, R, A.  This is slightly less optimal than
//               accessing the component values directly by named
//               methods.  The value returned is a double in the range
//               0..1.
//////////////////////////////////////////////////////////////////// 4 4 this 3 730  1 x 1 690  1 y 1 690  7 channel 1 690  
310 14 Dtool_BCNhPshy 0 4 234 691 0 14 Dtool_BCNhPshy 633 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::set_channel_val
//       Access: Published
//  Description: Sets the nth component color at the indicated
//               pixel.  The channel index should be in the range
//               0..(get_num_channels()-1).  The channels are ordered B,
//               G, R, A.  This is slightly less optimal than
//               setting the component values directly by named
//               methods.  The value given should be a double in the
//               range 0..1.
//////////////////////////////////////////////////////////////////// 5 4 this 3 732  1 x 1 690  1 y 1 690  7 channel 1 690  5 value 1 694  
311 14 Dtool_BCNhcpGI 0 6 235 694 0 14 Dtool_BCNhcpGI 467 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_bright
//       Access: Published
//  Description: Returns the linear brightness of the given xel, as a
//               double in the range 0..1.  This flavor of
//               get_bright() returns the correct grayscale brightness
//               level for both full-color and grayscale images.
//////////////////////////////////////////////////////////////////// 3 4 this 3 730  1 x 1 690  1 y 1 690  
312 14 Dtool_BCNhN9Lp 0 6 235 694 0 14 Dtool_BCNhN9Lp 467 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_bright
//       Access: Published
//  Description: This flavor of get_bright() works correctly only for
//               color images.  It returns a single brightness value
//               for the RGB color at the indicated pixel, based on
//               the supplied weights for each component.
//////////////////////////////////////////////////////////////////// 6 4 this 3 730  1 x 1 690  1 y 1 690  2 rc 1 694  2 gc 1 694  2 bc 1 694  
313 14 Dtool_BCNh1KaX 0 6 235 694 0 14 Dtool_BCNh1KaX 475 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_bright
//       Access: Published
//  Description: This flavor of get_bright() works correctly only for
//               four-channel images.  It returns a single brightness
//               value for the RGBA color at the indicated pixel,
//               based on the supplied weights for each component.
//////////////////////////////////////////////////////////////////// 7 4 this 3 730  1 x 1 690  1 y 1 690  2 rc 1 694  2 gc 1 694  2 bc 1 694  2 ac 1 694  
314 14 Dtool_BCNhVicO 0 4 236 691 0 14 Dtool_BCNhVicO 539 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::blend
//       Access: Published
//  Description: Smoothly blends the indicated pixel value in with
//               whatever was already in the image, based on the given
//               alpha value.  An alpha of 1.0 is fully opaque and
//               completely replaces whatever was there previously;
//               alpha of 0.0 is fully transparent and does nothing.
//////////////////////////////////////////////////////////////////// 5 4 this 3 732  1 x 1 690  1 y 1 690  3 val 1 747  5 alpha 1 694  
315 14 Dtool_BCNh9I6e 0 4 236 691 0 14 Dtool_BCNh9I6e 539 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::blend
//       Access: Published
//  Description: Smoothly blends the indicated pixel value in with
//               whatever was already in the image, based on the given
//               alpha value.  An alpha of 1.0 is fully opaque and
//               completely replaces whatever was there previously;
//               alpha of 0.0 is fully transparent and does nothing.
//////////////////////////////////////////////////////////////////// 7 4 this 3 732  1 x 1 690  1 y 1 690  1 r 1 694  1 g 1 694  1 b 1 694  5 alpha 1 694  
316 14 Dtool_BCNh_EKA 0 6 237 689 0 14 Dtool_BCNh_EKA 297 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::Array Operator
//       Access: Published
//  Description: Allows the PNMImage to appear to be a 2-d array of
//               xels.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  1 y 1 690  
317 14 Dtool_BCNhwxq_ 0 6 237 692 0 14 Dtool_BCNhwxq_ 297 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::Array Operator
//       Access: Published
//  Description: Allows the PNMImage to appear to be a 2-d array of
//               xels.
//////////////////////////////////////////////////////////////////// 2 4 this 3 730  1 y 1 690  
318 14 Dtool_BCNhiW_W 0 4 238 691 0 14 Dtool_BCNhiW_W 647 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::copy_sub_image
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 8 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  6 x_size 1 690  6 y_size 1 690  
319 14 Dtool_BCNhxEW3 0 4 238 691 0 14 Dtool_BCNhxEW3 647 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::copy_sub_image
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 7 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  6 x_size 1 690  
320 14 Dtool_BCNhWkin 0 4 238 691 0 14 Dtool_BCNhWkin 647 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::copy_sub_image
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 6 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  
321 14 Dtool_BCNhXAof 0 4 238 691 0 14 Dtool_BCNhXAof 647 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::copy_sub_image
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 5 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  
322 14 Dtool_BCNhrmrb 0 4 238 691 0 14 Dtool_BCNhrmrb 647 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::copy_sub_image
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  
323 14 Dtool_BCNhUBqK 0 4 239 691 0 14 Dtool_BCNhUBqK 770 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::blend_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), except the alpha
//               channel of the copy is used to blend the copy into
//               the destination image, instead of overwriting pixels
//               unconditionally.
//
//               If pixel_scale is not 1.0, it specifies an amount to
//               scale each *alpha* value of the source image before
//               applying it to the target image.
//
//               If pixel_scale is 1.0 and the copy has no alpha
//               channel, this degenerates into copy_sub_image().
//////////////////////////////////////////////////////////////////// 9 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  6 x_size 1 690  6 y_size 1 690  11 pixel_scale 1 694  
324 14 Dtool_BCNhnnVh 0 4 239 691 0 14 Dtool_BCNhnnVh 770 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::blend_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), except the alpha
//               channel of the copy is used to blend the copy into
//               the destination image, instead of overwriting pixels
//               unconditionally.
//
//               If pixel_scale is not 1.0, it specifies an amount to
//               scale each *alpha* value of the source image before
//               applying it to the target image.
//
//               If pixel_scale is 1.0 and the copy has no alpha
//               channel, this degenerates into copy_sub_image().
//////////////////////////////////////////////////////////////////// 8 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  6 x_size 1 690  6 y_size 1 690  
325 14 Dtool_BCNh_Jps 0 4 239 691 0 14 Dtool_BCNh_Jps 770 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::blend_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), except the alpha
//               channel of the copy is used to blend the copy into
//               the destination image, instead of overwriting pixels
//               unconditionally.
//
//               If pixel_scale is not 1.0, it specifies an amount to
//               scale each *alpha* value of the source image before
//               applying it to the target image.
//
//               If pixel_scale is 1.0 and the copy has no alpha
//               channel, this degenerates into copy_sub_image().
//////////////////////////////////////////////////////////////////// 7 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  6 x_size 1 690  
326 14 Dtool_BCNh9rTy 0 4 239 691 0 14 Dtool_BCNh9rTy 770 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::blend_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), except the alpha
//               channel of the copy is used to blend the copy into
//               the destination image, instead of overwriting pixels
//               unconditionally.
//
//               If pixel_scale is not 1.0, it specifies an amount to
//               scale each *alpha* value of the source image before
//               applying it to the target image.
//
//               If pixel_scale is 1.0 and the copy has no alpha
//               channel, this degenerates into copy_sub_image().
//////////////////////////////////////////////////////////////////// 6 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  
327 14 Dtool_BCNhHoI1 0 4 239 691 0 14 Dtool_BCNhHoI1 770 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::blend_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), except the alpha
//               channel of the copy is used to blend the copy into
//               the destination image, instead of overwriting pixels
//               unconditionally.
//
//               If pixel_scale is not 1.0, it specifies an amount to
//               scale each *alpha* value of the source image before
//               applying it to the target image.
//
//               If pixel_scale is 1.0 and the copy has no alpha
//               channel, this degenerates into copy_sub_image().
//////////////////////////////////////////////////////////////////// 5 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  
328 14 Dtool_BCNh5Bk2 0 4 239 691 0 14 Dtool_BCNh5Bk2 770 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::blend_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), except the alpha
//               channel of the copy is used to blend the copy into
//               the destination image, instead of overwriting pixels
//               unconditionally.
//
//               If pixel_scale is not 1.0, it specifies an amount to
//               scale each *alpha* value of the source image before
//               applying it to the target image.
//
//               If pixel_scale is 1.0 and the copy has no alpha
//               channel, this degenerates into copy_sub_image().
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  
329 14 Dtool_BCNhTm50 0 4 240 691 0 14 Dtool_BCNhTm50 503 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::add_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), except the copy pixels
//               are added to the pixels of the destination, after
//               scaling by the specified pixel_scale.  Unlike
//               blend_sub_image(), the alpha channel is not treated
//               specially.
//////////////////////////////////////////////////////////////////// 9 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  6 x_size 1 690  6 y_size 1 690  11 pixel_scale 1 694  
330 14 Dtool_BCNhptjC 0 4 240 691 0 14 Dtool_BCNhptjC 503 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::add_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), except the copy pixels
//               are added to the pixels of the destination, after
//               scaling by the specified pixel_scale.  Unlike
//               blend_sub_image(), the alpha channel is not treated
//               specially.
//////////////////////////////////////////////////////////////////// 8 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  6 x_size 1 690  6 y_size 1 690  
331 14 Dtool_BCNhKbnB 0 4 240 691 0 14 Dtool_BCNhKbnB 503 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::add_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), except the copy pixels
//               are added to the pixels of the destination, after
//               scaling by the specified pixel_scale.  Unlike
//               blend_sub_image(), the alpha channel is not treated
//               specially.
//////////////////////////////////////////////////////////////////// 7 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  6 x_size 1 690  
332 14 Dtool_BCNhMpHh 0 4 240 691 0 14 Dtool_BCNhMpHh 503 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::add_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), except the copy pixels
//               are added to the pixels of the destination, after
//               scaling by the specified pixel_scale.  Unlike
//               blend_sub_image(), the alpha channel is not treated
//               specially.
//////////////////////////////////////////////////////////////////// 6 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  
333 14 Dtool_BCNhpz4w 0 4 240 691 0 14 Dtool_BCNhpz4w 503 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::add_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), except the copy pixels
//               are added to the pixels of the destination, after
//               scaling by the specified pixel_scale.  Unlike
//               blend_sub_image(), the alpha channel is not treated
//               specially.
//////////////////////////////////////////////////////////////////// 5 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  
334 14 Dtool_BCNhZex4 0 4 240 691 0 14 Dtool_BCNhZex4 503 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::add_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), except the copy pixels
//               are added to the pixels of the destination, after
//               scaling by the specified pixel_scale.  Unlike
//               blend_sub_image(), the alpha channel is not treated
//               specially.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  
335 14 Dtool_BCNhd4tn 0 4 241 691 0 14 Dtool_BCNhd4tn 509 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::mult_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), except the copy pixels
//               are multiplied to the pixels of the destination, after
//               scaling by the specified pixel_scale.  Unlike
//               blend_sub_image(), the alpha channel is not treated
//               specially.
//////////////////////////////////////////////////////////////////// 9 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  6 x_size 1 690  6 y_size 1 690  11 pixel_scale 1 694  
336 14 Dtool_BCNhCjdc 0 4 241 691 0 14 Dtool_BCNhCjdc 509 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::mult_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), except the copy pixels
//               are multiplied to the pixels of the destination, after
//               scaling by the specified pixel_scale.  Unlike
//               blend_sub_image(), the alpha channel is not treated
//               specially.
//////////////////////////////////////////////////////////////////// 8 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  6 x_size 1 690  6 y_size 1 690  
337 14 Dtool_BCNhRQ08 0 4 241 691 0 14 Dtool_BCNhRQ08 509 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::mult_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), except the copy pixels
//               are multiplied to the pixels of the destination, after
//               scaling by the specified pixel_scale.  Unlike
//               blend_sub_image(), the alpha channel is not treated
//               specially.
//////////////////////////////////////////////////////////////////// 7 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  6 x_size 1 690  
338 14 Dtool_BCNhWvAt 0 4 241 691 0 14 Dtool_BCNhWvAt 509 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::mult_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), except the copy pixels
//               are multiplied to the pixels of the destination, after
//               scaling by the specified pixel_scale.  Unlike
//               blend_sub_image(), the alpha channel is not treated
//               specially.
//////////////////////////////////////////////////////////////////// 6 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  
339 14 Dtool_BCNh3XGl 0 4 241 691 0 14 Dtool_BCNh3XGl 509 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::mult_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), except the copy pixels
//               are multiplied to the pixels of the destination, after
//               scaling by the specified pixel_scale.  Unlike
//               blend_sub_image(), the alpha channel is not treated
//               specially.
//////////////////////////////////////////////////////////////////// 5 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  
340 14 Dtool_BCNhbbKh 0 4 241 691 0 14 Dtool_BCNhbbKh 509 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::mult_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), except the copy pixels
//               are multiplied to the pixels of the destination, after
//               scaling by the specified pixel_scale.  Unlike
//               blend_sub_image(), the alpha channel is not treated
//               specially.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  
341 14 Dtool_BCNhOz5_ 0 4 242 691 0 14 Dtool_BCNhOz5_ 770 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::darken_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), but the resulting
//               color will be the darker of the source and
//               destination colors at each pixel (and at each R, G,
//               B, A component value).
//
//               If pixel_scale is not 1.0, it specifies an amount to
//               scale each pixel value of the source image before
//               applying it to the target image.  The scale is
//               applied with the center at 1.0: scaling the pixel
//               value smaller brings it closer to 1.0.
//////////////////////////////////////////////////////////////////// 9 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  6 x_size 1 690  6 y_size 1 690  11 pixel_scale 1 694  
342 14 Dtool_BCNhj3MU 0 4 242 691 0 14 Dtool_BCNhj3MU 770 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::darken_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), but the resulting
//               color will be the darker of the source and
//               destination colors at each pixel (and at each R, G,
//               B, A component value).
//
//               If pixel_scale is not 1.0, it specifies an amount to
//               scale each pixel value of the source image before
//               applying it to the target image.  The scale is
//               applied with the center at 1.0: scaling the pixel
//               value smaller brings it closer to 1.0.
//////////////////////////////////////////////////////////////////// 8 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  6 x_size 1 690  6 y_size 1 690  
343 14 Dtool_BCNhW_U9 0 4 242 691 0 14 Dtool_BCNhW_U9 770 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::darken_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), but the resulting
//               color will be the darker of the source and
//               destination colors at each pixel (and at each R, G,
//               B, A component value).
//
//               If pixel_scale is not 1.0, it specifies an amount to
//               scale each pixel value of the source image before
//               applying it to the target image.  The scale is
//               applied with the center at 1.0: scaling the pixel
//               value smaller brings it closer to 1.0.
//////////////////////////////////////////////////////////////////// 7 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  6 x_size 1 690  
344 14 Dtool_BCNhCJ4x 0 4 242 691 0 14 Dtool_BCNhCJ4x 770 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::darken_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), but the resulting
//               color will be the darker of the source and
//               destination colors at each pixel (and at each R, G,
//               B, A component value).
//
//               If pixel_scale is not 1.0, it specifies an amount to
//               scale each pixel value of the source image before
//               applying it to the target image.  The scale is
//               applied with the center at 1.0: scaling the pixel
//               value smaller brings it closer to 1.0.
//////////////////////////////////////////////////////////////////// 6 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  
345 14 Dtool_BCNhg3LM 0 4 242 691 0 14 Dtool_BCNhg3LM 770 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::darken_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), but the resulting
//               color will be the darker of the source and
//               destination colors at each pixel (and at each R, G,
//               B, A component value).
//
//               If pixel_scale is not 1.0, it specifies an amount to
//               scale each pixel value of the source image before
//               applying it to the target image.  The scale is
//               applied with the center at 1.0: scaling the pixel
//               value smaller brings it closer to 1.0.
//////////////////////////////////////////////////////////////////// 5 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  
346 14 Dtool_BCNh7UU5 0 4 242 691 0 14 Dtool_BCNh7UU5 770 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::darken_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), but the resulting
//               color will be the darker of the source and
//               destination colors at each pixel (and at each R, G,
//               B, A component value).
//
//               If pixel_scale is not 1.0, it specifies an amount to
//               scale each pixel value of the source image before
//               applying it to the target image.  The scale is
//               applied with the center at 1.0: scaling the pixel
//               value smaller brings it closer to 1.0.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  
347 14 Dtool_BCNhfVkb 0 4 243 691 0 14 Dtool_BCNhfVkb 635 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::lighten_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), but the resulting
//               color will be the lighter of the source and
//               destination colors at each pixel (and at each R, G,
//               B, A component value).
//
//               If pixel_scale is not 1.0, it specifies an amount to
//               scale each pixel value of the source image before
//               applying it to the target image.
//////////////////////////////////////////////////////////////////// 9 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  6 x_size 1 690  6 y_size 1 690  11 pixel_scale 1 694  
348 14 Dtool_BCNhpuck 0 4 243 691 0 14 Dtool_BCNhpuck 635 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::lighten_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), but the resulting
//               color will be the lighter of the source and
//               destination colors at each pixel (and at each R, G,
//               B, A component value).
//
//               If pixel_scale is not 1.0, it specifies an amount to
//               scale each pixel value of the source image before
//               applying it to the target image.
//////////////////////////////////////////////////////////////////// 8 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  6 x_size 1 690  6 y_size 1 690  
349 14 Dtool_BCNhFcYI 0 4 243 691 0 14 Dtool_BCNhFcYI 635 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::lighten_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), but the resulting
//               color will be the lighter of the source and
//               destination colors at each pixel (and at each R, G,
//               B, A component value).
//
//               If pixel_scale is not 1.0, it specifies an amount to
//               scale each pixel value of the source image before
//               applying it to the target image.
//////////////////////////////////////////////////////////////////// 7 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  6 x_size 1 690  
350 14 Dtool_BCNhfeXa 0 4 243 691 0 14 Dtool_BCNhfeXa 635 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::lighten_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), but the resulting
//               color will be the lighter of the source and
//               destination colors at each pixel (and at each R, G,
//               B, A component value).
//
//               If pixel_scale is not 1.0, it specifies an amount to
//               scale each pixel value of the source image before
//               applying it to the target image.
//////////////////////////////////////////////////////////////////// 6 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  5 yfrom 1 690  
351 14 Dtool_BCNhsdWj 0 4 243 691 0 14 Dtool_BCNhsdWj 635 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::lighten_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), but the resulting
//               color will be the lighter of the source and
//               destination colors at each pixel (and at each R, G,
//               B, A component value).
//
//               If pixel_scale is not 1.0, it specifies an amount to
//               scale each pixel value of the source image before
//               applying it to the target image.
//////////////////////////////////////////////////////////////////// 5 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  5 xfrom 1 690  
352 14 Dtool_BCNhb52H 0 4 243 691 0 14 Dtool_BCNhb52H 635 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::lighten_sub_image
//       Access: Published
//  Description: Behaves like copy_sub_image(), but the resulting
//               color will be the lighter of the source and
//               destination colors at each pixel (and at each R, G,
//               B, A component value).
//
//               If pixel_scale is not 1.0, it specifies an amount to
//               scale each pixel value of the source image before
//               applying it to the target image.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  4 copy 1 730  3 xto 1 690  3 yto 1 690  
353 14 Dtool_BCNhGK6i 0 4 244 691 0 14 Dtool_BCNhGK6i 1004 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::threshold
//       Access: Published
//  Description: Selectively copies each pixel from either one source
//               or another source, depending on the pixel value of
//               the indicated channel of select_image.
//
//               For each pixel (x, y):
//
//               s = select_image.get_channel(x, y, channel). Set this
//               image's (x, y) to:
//
//               lt.get_xel(x, y) if s < threshold, or
//
//               ge.get_xel(x, y) if s >= threshold
//
//               Any of select_image, lt, or ge may be the same
//               PNMImge object as this image, or the same as each
//               other; or they may all be different. All images must
//               be the same size.  As a special case, lt and ge may
//               both be 1x1 images instead of the source image size.
//////////////////////////////////////////////////////////////////// 6 4 this 3 732  12 select_image 1 730  7 channel 1 690  9 threshold 1 694  2 lt 1 730  2 ge 1 730  
354 14 Dtool_BCNhTe5v 0 4 245 691 0 14 Dtool_BCNhTe5v 1231 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::fill_distance_inside
//       Access: Published
//  Description: Replaces this image with a grayscale image whose gray
//               channel represents the linear Manhattan distance from
//               the nearest dark pixel in the given mask image, up to
//               the specified radius value (which also becomes the
//               new maxval).  radius may range from 0 to maxmaxval;
//               smaller values will compute faster.  A dark pixel is
//               defined as one whose pixel value is < threshold.
//
//               If shrink_from_border is true, then the mask image is
//               considered to be surrounded by a border of dark
//               pixels; otherwise, the border isn't considered.
//
//               This can be used, in conjunction with threshold, to
//               shrink a mask image inwards by a certain number of
//               pixels.
//
//               The mask image may be the same image as this one, in
//               which case it is destructively modified by this
//               process.
//////////////////////////////////////////////////////////////////// 5 4 this 3 732  4 mask 1 730  9 threshold 1 694  6 radius 1 690  18 shrink_from_border 1 709  
355 14 Dtool_BCNhrckK 0 4 246 691 0 14 Dtool_BCNhrckK 1030 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::fill_distance_outside
//       Access: Published
//  Description: Replaces this image with a grayscale image whose gray
//               channel represents the linear Manhattan distance from
//               the nearest white pixel in the given mask image, up to
//               the specified radius value (which also becomes the
//               new maxval).  radius may range from 0 to maxmaxval;
//               smaller values will compute faster.  A white pixel is
//               defined as one whose pixel value is >= threshold.
//
//               This can be used, in conjunction with threshold, to
//               grow a mask image outwards by a certain number of
//               pixels.
//
//               The mask image may be the same image as this one, in
//               which case it is destructively modified by this
//               process.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  4 mask 1 730  9 threshold 1 694  6 radius 1 690  
356 14 Dtool_BCNhANbQ 0 4 247 691 0 14 Dtool_BCNhANbQ 537 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::rescale
//       Access: Published
//  Description: Rescales the RGB channel values so that any values in
//               the original image between min_val and max_val are
//               expanded to the range 0 .. 1.  Values below min_val
//               are set to 0, and values above max_val are set to 1.
//               Does not affect the alpha channel, if any.
//////////////////////////////////////////////////////////////////// 3 4 this 3 732  7 min_val 1 694  7 max_val 1 694  
357 14 Dtool_BCNhj9HN 0 4 248 691 0 14 Dtool_BCNhj9HN 781 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::render_spot
//       Access: Published
//  Description: Renders a solid-color circle, with a fuzzy edge, into
//               the center of the PNMImage.  If the PNMImage is
//               non-square, this actually renders an ellipse.
//
//               The min_radius and max_radius are in the scale 0..1,
//               where 1.0 means the full width of the image.  If
//               min_radius == max_radius, the edge is sharp (but
//               still antialiased); otherwise, the pixels between
//               min_radius and max_radius are smoothly blended
//               between fg and bg colors.
//////////////////////////////////////////////////////////////////// 5 4 this 3 732  2 fg 1 757  2 bg 1 757  10 min_radius 1 694  10 max_radius 1 694  
358 14 Dtool_BCNhg5VA 0 4 249 691 0 14 Dtool_BCNhg5VA 472 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::expand_border
//       Access: Published
//  Description: Expands the image by the indicated number of pixels
//               on each edge.  The new pixels are set to the
//               indicated color.
//
//               If any of the values is negative, this actually crops
//               the image.
//////////////////////////////////////////////////////////////////// 6 4 this 3 732  4 left 1 690  5 right 1 690  6 bottom 1 690  3 top 1 690  5 color 1 757  
359 14 Dtool_BCNh0QpA 0 4 250 691 0 14 Dtool_BCNh0QpA 394 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::box_filter
//       Access: Published
//  Description: This flavor of box_filter() will apply the filter
//               over the entire image without resizing or copying;
//               the effect is that of a blur operation.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  6 radius 1 694  
360 14 Dtool_BCNhKBDW 0 4 250 691 0 14 Dtool_BCNhKBDW 394 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::box_filter
//       Access: Published
//  Description: This flavor of box_filter() will apply the filter
//               over the entire image without resizing or copying;
//               the effect is that of a blur operation.
//////////////////////////////////////////////////////////////////// 1 4 this 3 732  
361 14 Dtool_BCNhSjEC 0 4 251 691 0 14 Dtool_BCNhSjEC 404 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::gaussian_filter
//       Access: Published
//  Description: This flavor of gaussian_filter() will apply the filter
//               over the entire image without resizing or copying;
//               the effect is that of a blur operation.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  6 radius 1 694  
362 14 Dtool_BCNhN02s 0 4 251 691 0 14 Dtool_BCNhN02s 404 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::gaussian_filter
//       Access: Published
//  Description: This flavor of gaussian_filter() will apply the filter
//               over the entire image without resizing or copying;
//               the effect is that of a blur operation.
//////////////////////////////////////////////////////////////////// 1 4 this 3 732  
363 14 Dtool_BCNhpuxe 0 4 252 691 0 14 Dtool_BCNhpuxe 334 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::unfiltered_stretch_from
//       Access: Published
//  Description: Resizes from the indicated image into this one by
//               performing a nearest-point sample.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  4 copy 1 730  
364 14 Dtool_BCNhPYod 0 4 253 691 0 14 Dtool_BCNhPYod 530 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::box_filter_from
//       Access: Public
//  Description: 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.
//////////////////////////////////////////////////////////////////// 3 4 this 3 732  6 radius 1 694  4 copy 1 730  
365 14 Dtool_BCNhRiE8 0 4 254 691 0 14 Dtool_BCNhRiE8 535 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::gaussian_filter_from
//       Access: Public
//  Description: 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.
//////////////////////////////////////////////////////////////////// 3 4 this 3 732  6 radius 1 694  4 copy 1 730  
366 14 Dtool_BCNh2C4m 0 4 255 691 0 14 Dtool_BCNh2C4m 731 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::quick_filter_from
//       Access: Public
//  Description: 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.  If borders are
//               specified, they will further restrict the size of the
//               resulting image. There's no point in using
//               quick_box_filter() on a single image.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  4 copy 1 730  7 xborder 1 690  7 yborder 1 690  
367 14 Dtool_BCNhocJ5 0 4 255 691 0 14 Dtool_BCNhocJ5 731 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::quick_filter_from
//       Access: Public
//  Description: 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.  If borders are
//               specified, they will further restrict the size of the
//               resulting image. There's no point in using
//               quick_box_filter() on a single image.
//////////////////////////////////////////////////////////////////// 3 4 this 3 732  4 copy 1 730  7 xborder 1 690  
368 14 Dtool_BCNhRBRi 0 4 255 691 0 14 Dtool_BCNhRBRi 731 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::quick_filter_from
//       Access: Public
//  Description: 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.  If borders are
//               specified, they will further restrict the size of the
//               resulting image. There's no point in using
//               quick_box_filter() on a single image.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  4 copy 1 730  
369 14 Dtool_BCNhluC7 0 4 256 691 0 14 Dtool_BCNhluC7 294 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::make_histogram
//       Access: Published
//  Description: Computes a histogram of the colors used in the
//               image.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  4 hist 1 724  
370 14 Dtool_BCNhLw3A 0 4 257 691 0 14 Dtool_BCNhLw3A 322 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::perlin_noise_fill
//       Access: Published
//  Description: Variant of perlin_noise_fill that uses an
//               existing StackedPerlinNoise2 object.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  6 perlin 1 787  
371 14 Dtool_BCNh_dBm 0 4 257 691 0 14 Dtool_BCNh_dBm 556 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::perlin_noise_fill
//       Access: Published
//  Description: Fills the image with a grayscale perlin noise
//               pattern based on the indicated parameters.
//               Uses set_xel to set the grayscale values.
//               The sx and sy parameters are in multiples
//               of the size of this image.
//               See also the PerlinNoise2 class in mathutil.
//////////////////////////////////////////////////////////////////// 5 4 this 3 732  2 sx 1 694  2 sy 1 694  10 table_size 1 690  4 seed 1 789  
372 14 Dtool_BCNhtAOc 0 4 257 691 0 14 Dtool_BCNhtAOc 556 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::perlin_noise_fill
//       Access: Published
//  Description: Fills the image with a grayscale perlin noise
//               pattern based on the indicated parameters.
//               Uses set_xel to set the grayscale values.
//               The sx and sy parameters are in multiples
//               of the size of this image.
//               See also the PerlinNoise2 class in mathutil.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  2 sx 1 694  2 sy 1 694  10 table_size 1 690  
373 14 Dtool_BCNh06Hk 0 4 257 691 0 14 Dtool_BCNh06Hk 556 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::perlin_noise_fill
//       Access: Published
//  Description: Fills the image with a grayscale perlin noise
//               pattern based on the indicated parameters.
//               Uses set_xel to set the grayscale values.
//               The sx and sy parameters are in multiples
//               of the size of this image.
//               See also the PerlinNoise2 class in mathutil.
//////////////////////////////////////////////////////////////////// 3 4 this 3 732  2 sx 1 694  2 sy 1 694  
374 14 Dtool_BCNhfaTI 0 4 258 691 0 14 Dtool_BCNhfaTI 370 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::remix_channels
//       Access: Published
//  Description: Transforms every pixel using the operation
//               (Ro,Go,Bo) = conv.xform_point(Ri,Gi,Bi);
//               Input must be a color image.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  4 conv 1 773  
375 14 Dtool_BCNhYSjO 0 4 259 691 0 14 Dtool_BCNhYSjO 474 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::gamma_correct
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 3 4 this 3 732  10 from_gamma 1 694  8 to_gamma 1 694  
376 14 Dtool_BCNhwa1s 0 4 260 691 0 14 Dtool_BCNhwa1s 481 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::gamma_correct_alpha
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 3 4 this 3 732  10 from_gamma 1 694  8 to_gamma 1 694  
377 14 Dtool_BCNhH6Fb 0 4 261 691 0 14 Dtool_BCNhH6Fb 392 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::apply_exponent
//       Access: Published
//  Description: Adjusts each channel of the image by raising the
//               corresponding component value to the indicated
//               exponent, such that L' = L ^ exponent.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  13 gray_exponent 1 694  
378 14 Dtool_BCNhkr_l 0 4 261 691 0 14 Dtool_BCNhkr_l 392 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::apply_exponent
//       Access: Published
//  Description: Adjusts each channel of the image by raising the
//               corresponding component value to the indicated
//               exponent, such that L' = L ^ exponent.
//////////////////////////////////////////////////////////////////// 3 4 this 3 732  13 gray_exponent 1 694  14 alpha_exponent 1 694  
379 14 Dtool_BCNhxePx 0 4 261 691 0 14 Dtool_BCNhxePx 572 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::apply_exponent
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  12 red_exponent 1 694  14 green_exponent 1 694  13 blue_exponent 1 694  
380 14 Dtool_BCNhZSgf 0 4 261 691 0 14 Dtool_BCNhZSgf 572 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::apply_exponent
//       Access: Published
//  Description: 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.
//////////////////////////////////////////////////////////////////// 5 4 this 3 732  12 red_exponent 1 694  14 green_exponent 1 694  13 blue_exponent 1 694  14 alpha_exponent 1 694  
381 14 Dtool_BCNh9NNp 0 7 262 786 0 14 Dtool_BCNh9NNp 302 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_average_xel
//       Access: Published
//  Description: Returns the average color of all of the pixels
//               in the image.
//////////////////////////////////////////////////////////////////// 1 4 this 3 730  
382 14 Dtool_BCNhrTM5 0 7 263 765 0 14 Dtool_BCNhrTM5 333 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_average_xel_a
//       Access: Published
//  Description: Returns the average color of all of the pixels
//               in the image, including the alpha channel.
//////////////////////////////////////////////////////////////////// 1 4 this 3 730  
383 14 Dtool_BCNhbKRd 0 6 264 694 0 14 Dtool_BCNhbKRd 317 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::get_average_gray
//       Access: Published
//  Description: Returns the average grayscale component of all of
//               the pixels in the image.
//////////////////////////////////////////////////////////////////// 1 4 this 3 730  
384 14 Dtool_BCNh3sgG 0 4 265 691 0 14 Dtool_BCNh3sgG 343 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::do_fill_distance
//       Access: Private
//  Description: Recursively fills in the minimum distance measured
//               from a certain set of points into the gray channel.
//////////////////////////////////////////////////////////////////// 4 4 this 3 732  2 xi 1 690  2 yi 1 690  1 d 1 690  
385 14 Dtool_BCNh7hU9 0 7 266 732 564 14 Dtool_BCNh7hU9 307 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator ~
//       Access: Published
//  Description: Returns a new PNMImage that is the
//               complement of the current PNMImage.
//////////////////////////////////////////////////////////////////// 1 4 this 3 730  
386 14 Dtool_BCNhSIk1 0 7 267 732 564 14 Dtool_BCNhSIk1 333 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator +
//       Access: Published
//  Description: Returns a new PNMImage in which the provided color
//               is added to each pixel in the provided image.
//////////////////////////////////////////////////////////////////// 2 4 this 3 730  5 other 1 757  
387 14 Dtool_BCNhO9xS 0 7 267 732 564 14 Dtool_BCNhO9xS 437 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator +
//       Access: Published
//  Description: Returns a new PNMImage in which each pixel value
//               is the sum of the corresponding pixel values
//               in the two given images.
//               Only valid when both images have the same size.
//////////////////////////////////////////////////////////////////// 2 4 this 3 730  5 other 1 730  
388 14 Dtool_BCNhtan1 0 7 268 732 564 14 Dtool_BCNhtan1 340 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator -
//       Access: Published
//  Description: Returns a new PNMImage in which the provided color
//               is subtracted from each pixel in the provided image.
//////////////////////////////////////////////////////////////////// 2 4 this 3 730  5 other 1 757  
389 14 Dtool_BCNhxDzS 0 7 268 732 564 14 Dtool_BCNhxDzS 445 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator -
//       Access: Published
//  Description: Returns a new PNMImage in which each pixel value
//               from the right image is subtracted from each
//               pixel value from the left image.
//               Only valid when both images have the same size.
//////////////////////////////////////////////////////////////////// 2 4 this 3 730  5 other 1 730  
390 14 Dtool_BCNhXRlV 0 7 269 732 564 14 Dtool_BCNhXRlV 338 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator *
//       Access: Published
//  Description: Returns a new PNMImage in which the provided color
//               is multiplied to each pixel in the provided image.
//////////////////////////////////////////////////////////////////// 2 4 this 3 730  5 other 1 757  
391 14 Dtool_BCNhSkwy 0 7 269 732 564 14 Dtool_BCNhSkwy 575 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator *
//       Access: Published
//  Description: Returns a new PNMImage in which each pixel value
//               from the left image is multiplied by each
//               pixel value from the right image. Note that the
//               floating-point values in the 0..1 range are
//               multiplied, not in the 0..maxval range.
//               Only valid when both images have the same size.
//////////////////////////////////////////////////////////////////// 2 4 this 3 730  5 other 1 730  
392 14 Dtool_BCNhgYfb 0 7 269 732 564 14 Dtool_BCNhgYfb 325 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator *
//       Access: Published
//  Description: Multiplies every pixel value in the image by
//               a constant floating-point multiplier value.
//////////////////////////////////////////////////////////////////// 2 4 this 3 730  10 multiplier 1 694  
393 14 Dtool_BCNhiOty 0 6 270 732 0 14 Dtool_BCNhiOty 273 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator +=
//       Access: Published
//  Description: Adds the provided color to each pixel in this image.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  5 other 1 757  
394 14 Dtool_BCNhULJV 0 6 270 732 0 14 Dtool_BCNhULJV 395 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator +=
//       Access: Published
//  Description: Sets each pixel value to the sum of the corresponding
//               pixel values in the two given images.  Only valid
//               when both images have the same size.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  5 other 1 730  
395 14 Dtool_BCNhlcsy 0 6 271 732 0 14 Dtool_BCNhlcsy 297 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator -=
//       Access: Published
//  Description: Subtracts the provided color from each pixel in this
//               image.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  5 other 1 757  
396 14 Dtool_BCNhdZIV 0 6 271 732 0 14 Dtool_BCNhdZIV 382 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator -=
//       Access: Published
//  Description: Subtracts each pixel from the right image from each
//               pixel value in this image.  Only valid when both
//               images have the same size.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  5 other 1 730  
397 14 Dtool_BCNh_lsS 0 6 272 732 0 14 Dtool_BCNh_lsS 295 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator *=
//       Access: Published
//  Description: Multiples the provided color to each pixel in this
//               image.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  5 other 1 757  
398 14 Dtool_BCNhQSI1 0 6 272 732 0 14 Dtool_BCNhQSI1 511 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator *=
//       Access: Published
//  Description: Multiples each pixel in this image by each
//               pixel value from the right image. Note that the
//               floating-point values in the 0..1 range are
//               multiplied, not in the 0..maxval range.
//               Only valid when both images have the same size.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  5 other 1 730  
399 14 Dtool_BCNh4c6t 0 6 272 732 0 14 Dtool_BCNh4c6t 326 ////////////////////////////////////////////////////////////////////
//     Function: PNMImage::operator *=
//       Access: Published
//  Description: Multiplies every pixel value in the image by
//               a constant floating-point multiplier value.
//////////////////////////////////////////////////////////////////// 2 4 this 3 732  10 multiplier 1 694  
400 14 Dtool_BCNhScvd 0 7 274 790 665 14 Dtool_BCNhScvd 896 ////////////////////////////////////////////////////////////////////
//     Function: PNMPainter::Constructor
//       Access: Published
//  Description: The constructor stores a pointer to the PNMImage you
//               pass it, but it does not take ownership of the
//               object; you are responsible for ensuring that the
//               PNMImage does not destruct during the lifetime of the
//               PNMPainter object.
//
//               The xo, yo coordinates specify an optional offset for
//               fill coordinates.  If you are painting with a pattern
//               fill, these specify the virtual coordinates of the
//               upper-left corner of the image, which can allow you
//               to adjust the pattern to line up with nested images,
//               if necessary.
//////////////////////////////////////////////////////////////////// 3 5 image 1 732  2 xo 1 690  2 yo 1 690  
401 14 Dtool_BCNht6xb 0 7 274 790 665 14 Dtool_BCNht6xb 896 ////////////////////////////////////////////////////////////////////
//     Function: PNMPainter::Constructor
//       Access: Published
//  Description: The constructor stores a pointer to the PNMImage you
//               pass it, but it does not take ownership of the
//               object; you are responsible for ensuring that the
//               PNMImage does not destruct during the lifetime of the
//               PNMPainter object.
//
//               The xo, yo coordinates specify an optional offset for
//               fill coordinates.  If you are painting with a pattern
//               fill, these specify the virtual coordinates of the
//               upper-left corner of the image, which can allow you
//               to adjust the pattern to line up with nested images,
//               if necessary.
//////////////////////////////////////////////////////////////////// 2 5 image 1 732  2 xo 1 690  
402 14 Dtool_BCNhCt0a 0 7 274 790 665 14 Dtool_BCNhCt0a 896 ////////////////////////////////////////////////////////////////////
//     Function: PNMPainter::Constructor
//       Access: Published
//  Description: The constructor stores a pointer to the PNMImage you
//               pass it, but it does not take ownership of the
//               object; you are responsible for ensuring that the
//               PNMImage does not destruct during the lifetime of the
//               PNMPainter object.
//
//               The xo, yo coordinates specify an optional offset for
//               fill coordinates.  If you are painting with a pattern
//               fill, these specify the virtual coordinates of the
//               upper-left corner of the image, which can allow you
//               to adjust the pattern to line up with nested images,
//               if necessary.
//////////////////////////////////////////////////////////////////// 1 5 image 1 732  
403 14 Dtool_BCNhZ5aW 0 4 276 691 0 14 Dtool_BCNhZ5aW 608 ////////////////////////////////////////////////////////////////////
//     Function: PNMPainter::set_pen
//       Access: Published
//  Description: Specifies a PNMBrush that will be used for drawing
//               lines and edges.  If the brush is a bitmap brush, its
//               image will be smeared pixelwise along the line.
//
//               Unlike the PNMImage passed to the constructor, the
//               PNMPainter will take ownership of the pen.  It is not
//               necessary to keep a separate pointer to it.
//////////////////////////////////////////////////////////////////// 2 4 this 3 790  3 pen 1 785  
404 14 Dtool_BCNhTkSz 0 7 277 785 0 14 Dtool_BCNhTkSz 259 ////////////////////////////////////////////////////////////////////
//     Function: PNMPainter::get_pen
//       Access: Published
//  Description: Returns the current pen.  See set_pen().
//////////////////////////////////////////////////////////////////// 1 4 this 3 791  
405 14 Dtool_BCNhdT_C 0 4 278 691 0 14 Dtool_BCNhdT_C 639 ////////////////////////////////////////////////////////////////////
//     Function: PNMPainter::set_fill
//       Access: Published
//  Description: Specifies a PNMBrush that will be used for filling
//               in the interiors of objects.  If the brush is a
//               bitmap brush, its image will be tiled throughout the
//               space.
//
//               Unlike the PNMImage passed to the constructor, the
//               PNMPainter will take ownership of the fill brush.  It
//               is not necessary to keep a separate pointer to it.
//////////////////////////////////////////////////////////////////// 2 4 this 3 790  4 fill 1 785  
406 14 Dtool_BCNhQsMf 0 7 279 785 0 14 Dtool_BCNhQsMf 268 ////////////////////////////////////////////////////////////////////
//     Function: PNMPainter::get_fill
//       Access: Published
//  Description: Returns the current fill brush.  See set_fill().
//////////////////////////////////////////////////////////////////// 1 4 this 3 791  
407 14 Dtool_BCNhnCKD 0 4 280 691 0 14 Dtool_BCNhnCKD 305 ////////////////////////////////////////////////////////////////////
//     Function: PNMPainter::draw_point
//       Access: Published
//  Description: Draws an antialiased point on the PNMImage, using the
//               current pen.
//////////////////////////////////////////////////////////////////// 3 4 this 3 790  1 x 1 694  1 y 1 694  
408 14 Dtool_BCNhdfA6 0 4 281 691 0 14 Dtool_BCNhdfA6 303 ////////////////////////////////////////////////////////////////////
//     Function: PNMPainter::draw_line
//       Access: Published
//  Description: Draws an antialiased line on the PNMImage, using the
//               current pen.
//////////////////////////////////////////////////////////////////// 5 4 this 3 790  2 xa 1 694  2 ya 1 694  2 xb 1 694  2 yb 1 694  
409 14 Dtool_BCNhIBht 0 4 282 691 0 14 Dtool_BCNhIBht 488 ////////////////////////////////////////////////////////////////////
//     Function: PNMPainter::draw_rectangle
//       Access: Published
//  Description: Draws a filled rectangule on the PNMImage, using the
//               current pen for the outline, and the current fill
//               brush for the interior.
//
//               The two coordinates specify any two diagonally
//               opposite corners.
//////////////////////////////////////////////////////////////////// 5 4 this 3 790  2 xa 1 694  2 ya 1 694  2 xb 1 694  2 yb 1 694  
120
673 5 pixel 0 140289 5 pixel 5 pixel 0 0 0 1 410 426 3 793 794 795 9 411 412 413 414 415 416 417 418 419 0 0 0 0 0 0

674 18 unsigned short int 0 8262 18 unsigned short int 18 unsigned short int 0 1 0 0 0 0 0 0 0 0 0 0 0

675 11 PNMFileType 0 75777 11 PNMFileType 11 PNMFileType 0 0 0 0 0 0 5 427 428 429 430 431 1 796 0 1 0 676 0 0 0 0 330
////////////////////////////////////////////////////////////////////
//       Class : PNMFileType
// Description : This is the base class of a family of classes that
//               represent particular image file types that PNMImage
//               supports.
////////////////////////////////////////////////////////////////////

676 13 TypedWritable 0 2049 13 TypedWritable 13 TypedWritable 0 0 0 0 0 0 0 0 0 0 0 0 341
////////////////////////////////////////////////////////////////////
//       Class : TypedWritable
// Description : Base class for objects that can be written to and
//               read from Bam files.
//
//               See also TypedObject for detailed instructions.
////////////////////////////////////////////////////////////////////

677 19 PNMFileTypeRegistry 0 26625 19 PNMFileTypeRegistry 19 PNMFileTypeRegistry 0 0 0 0 432 0 7 433 434 435 436 437 438 439 1 797 0 0 0 0 280
////////////////////////////////////////////////////////////////////
//       Class : PNMFileTypeRegistry
// Description : This class maintains the set of all known
//               PNMFileTypes in the universe.
////////////////////////////////////////////////////////////////////

678 14 PNMImageHeader 0 26625 14 PNMImageHeader 14 PNMImageHeader 0 0 0 1 440 442 0 18 441 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 0 0 0 0 4 679 680 681 682 616
////////////////////////////////////////////////////////////////////
//       Class : PNMImageHeader
// Description : This is the base class of PNMImage, PNMReader, and
//               PNMWriter.  It encapsulates all the information
//               associated with an image that describes its size,
//               number of channels, etc; that is, all the information
//               about the image except the image data itself.  It's
//               the sort of information you typically read from the
//               image file's header.
////////////////////////////////////////////////////////////////////

679 9 ColorType 0 794624 25 PNMImageHeader::ColorType 25 PNMImageHeader::ColorType 678 0 0 0 0 0 0 0 0 0 5 10 CT_invalid 26 PNMImageHeader::CT_invalid 0 12 CT_grayscale 28 PNMImageHeader::CT_grayscale 1 14 CT_two_channel 30 PNMImageHeader::CT_two_channel 2 8 CT_color 24 PNMImageHeader::CT_color 3 15 CT_four_channel 31 PNMImageHeader::CT_four_channel 4 0 198
// This enumerated type indicates the number of channels in the
// image, and also implies an image type.  You can treat it either
// as an integer number of channels or as an enumerated image type.

680 9 PixelSpec 0 403457 25 PNMImageHeader::PixelSpec 25 PNMImageHeader::PixelSpec 678 0 0 1 460 477 0 16 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 0 0 0 0 0 179
// Contains a single pixel specification used in compute_histogram()
// and make_histogram().  Note that pixels are stored by integer
// value, not by floating-point scaled value.

681 14 PixelSpecCount 0 403457 30 PNMImageHeader::PixelSpecCount 30 PNMImageHeader::PixelSpecCount 678 0 0 0 478 0 0 0 0 0 0 0 93
// Associates a pixel specification with an appearance count, for
// use in Histogram, below.

682 9 Histogram 0 403457 25 PNMImageHeader::Histogram 25 PNMImageHeader::Histogram 678 0 0 1 479 484 0 4 480 481 482 483 1 798 0 0 0 0 65
// Used to return a pixel histogram in PNMImage::get_histogram().

683 7 PfmFile 0 141313 7 PfmFile 7 PfmFile 0 0 0 1 485 557 0 71 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 0 0 1 0 678 0 0 0 0 355
////////////////////////////////////////////////////////////////////
//       Class : PfmFile
// Description : 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.
////////////////////////////////////////////////////////////////////

684 8 PNMBrush 0 75777 8 PNMBrush 8 PNMBrush 0 0 0 0 0 0 4 558 559 560 561 0 0 1 0 685 0 0 0 1 686 836
////////////////////////////////////////////////////////////////////
//       Class : PNMBrush
// Description : This class is used to control the shape and color of
//               the drawing operations performed by a PNMPainter
//               object.
//
//               Normally, you don't create a PNMBrush directly;
//               instead, use one of the static PNMBrush::make_*()
//               methods provided here.
//
//               A PNMBrush is used to draw the border of a polygon or
//               rectangle, as well as for filling its interior.  When
//               it is used to draw a border, the brush is "smeared"
//               over the border; when it is used to fill the
//               interior, it is tiled through the interior.
////////////////////////////////////////////////////////////////////

685 14 ReferenceCount 0 2049 14 ReferenceCount 14 ReferenceCount 0 0 0 0 0 0 0 0 0 0 0 0 425
////////////////////////////////////////////////////////////////////
//       Class : ReferenceCount
// Description : A base class for all things that want to be
//               reference-counted.  ReferenceCount works in
//               conjunction with PointerTo to automatically delete
//               objects when the last pointer to them goes away.
////////////////////////////////////////////////////////////////////

686 11 BrushEffect 0 794624 21 PNMBrush::BrushEffect 21 PNMBrush::BrushEffect 684 0 0 0 0 0 0 0 0 0 4 6 BE_set 16 PNMBrush::BE_set 0 8 BE_blend 18 PNMBrush::BE_blend 1 9 BE_darken 19 PNMBrush::BE_darken 2 10 BE_lighten 20 PNMBrush::BE_lighten 3 0 0

687 8 PNMImage 0 26625 8 PNMImage 8 PNMImage 0 0 0 1 562 564 0 100 563 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 0 0 1 0 678 0 0 0 0 1506
////////////////////////////////////////////////////////////////////
//       Class : PNMImage
// Description : The name of this class derives from the fact that we
//               originally implemented it as a layer on top of the
//               "pnm library", based on netpbm, which was built to
//               implement pbm, pgm, and pbm files, and is the
//               underlying support of a number of public-domain image
//               file converters.  Nowadays we are no longer derived
//               directly from the pnm library, mainly to allow
//               support of C++ iostreams instead of the C stdio FILE
//               interface.
//
//               Conceptually, a PNMImage is a two-dimensional array
//               of xels, which are the PNM-defined generic pixel
//               type.  Each xel may have a red, green, and blue
//               component, or (if the image is grayscale) a gray
//               component.  The image may be read in, the individual
//               xels manipulated, and written out again, or a black
//               image may be constructed from scratch.
//
//               The image is of size XSize() by YSize() xels,
//               numbered from top to bottom, left to right, beginning
//               at zero.
//
//               Files can be specified by filename, or by an iostream
//               pointer.  The filename "-" refers to stdin or stdout.
////////////////////////////////////////////////////////////////////

688 10 PNMPainter 0 26625 10 PNMPainter 10 PNMPainter 0 0 0 1 664 665 0 7 666 667 668 669 670 671 672 0 0 0 0 0 596
////////////////////////////////////////////////////////////////////
//       Class : PNMPainter
// Description : This class provides a number of convenient methods
//               for painting drawings directly into a PNMImage.
//
//               It stores a pointer to the PNMImage you pass it, but
//               it does not take ownership of the object; you are
//               responsible for ensuring that the PNMImage does not
//               destruct during the lifetime of the PNMPainter
//               object.
////////////////////////////////////////////////////////////////////

689 7 pixel * 0 8576 7 pixel * 7 pixel * 0 0 673 0 0 0 0 0 0 0 0 0 0

690 3 int 0 8194 3 int 3 int 0 1 0 0 0 0 0 0 0 0 0 0 0

691 4 void 0 8194 4 void 4 void 0 6 0 0 0 0 0 0 0 0 0 0 0

692 13 pixel const * 0 8576 13 pixel const * 13 pixel const * 0 0 693 0 0 0 0 0 0 0 0 0 0

693 11 pixel const 0 8832 11 pixel const 11 pixel const 0 0 673 0 0 0 0 0 0 0 0 0 0

694 6 double 0 8194 6 double 6 double 0 3 0 0 0 0 0 0 0 0 0 0 0

695 19 PNMFileType const * 0 8576 19 PNMFileType const * 19 PNMFileType const * 0 0 696 0 0 0 0 0 0 0 0 0 0

696 17 PNMFileType const 0 8832 17 PNMFileType const 17 PNMFileType const 0 0 675 0 0 0 0 0 0 0 0 0 0

697 13 atomic string 0 2 13 atomic string 13 atomic string 0 7 0 0 0 0 0 0 0 0 0 0 0

698 10 TypeHandle 0 2048 10 TypeHandle 10 TypeHandle 0 0 0 0 0 0 0 0 0 0 0 0 1098
////////////////////////////////////////////////////////////////////
//       Class : TypeHandle
// Description : TypeHandle is the identifier used to differentiate
//               C++ class types.  Any C++ classes that inherit from
//               some base class, and must be differentiated at run
//               time, should store a static TypeHandle object that
//               can be queried through a static member function
//               named get_class_type().  Most of the time, it is also
//               desirable to inherit from TypedObject, which provides
//               some virtual functions to return the TypeHandle for a
//               particular instance.
//
//               At its essence, a TypeHandle is simply a unique
//               identifier that is assigned by the TypeRegistry.  The
//               TypeRegistry stores a tree of TypeHandles, so that
//               ancestry of a particular type may be queried, and the
//               type name may be retrieved for run-time display.
////////////////////////////////////////////////////////////////////

699 12 TypeHandle * 0 8576 12 TypeHandle * 12 TypeHandle * 0 0 698 0 0 0 0 0 0 0 0 0 0

700 27 PNMFileTypeRegistry const * 0 8576 27 PNMFileTypeRegistry const * 27 PNMFileTypeRegistry const * 0 0 701 0 0 0 0 0 0 0 0 0 0

701 25 PNMFileTypeRegistry const 0 8832 25 PNMFileTypeRegistry const 25 PNMFileTypeRegistry const 0 0 677 0 0 0 0 0 0 0 0 0 0

702 13 PNMFileType * 0 8576 13 PNMFileType * 13 PNMFileType * 0 0 675 0 0 0 0 0 0 0 0 0 0

703 9 ostream * 0 8576 9 ostream * 9 ostream * 0 0 704 0 0 0 0 0 0 0 0 0 0

704 7 ostream 0 2048 7 ostream 7 ostream 0 0 0 0 0 0 0 0 0 0 0 0 0

705 21 PNMFileTypeRegistry * 0 8576 21 PNMFileTypeRegistry * 21 PNMFileTypeRegistry * 0 0 677 0 0 0 0 0 0 0 0 0 0

706 16 PNMImageHeader * 0 8576 16 PNMImageHeader * 16 PNMImageHeader * 0 0 678 0 0 0 0 0 0 0 0 0 0

707 22 PNMImageHeader const * 0 8576 22 PNMImageHeader const * 22 PNMImageHeader const * 0 0 708 0 0 0 0 0 0 0 0 0 0

708 20 PNMImageHeader const 0 8832 20 PNMImageHeader const 20 PNMImageHeader const 0 0 678 0 0 0 0 0 0 0 0 0 0

709 4 bool 0 8194 4 bool 4 bool 0 4 0 0 0 0 0 0 0 0 0 0 0

710 16 Filename const * 0 8576 16 Filename const * 16 Filename const * 0 0 711 0 0 0 0 0 0 0 0 0 0

711 14 Filename const 0 8832 14 Filename const 14 Filename const 0 0 712 0 0 0 0 0 0 0 0 0 0

712 8 Filename 0 2048 8 Filename 8 Filename 0 0 0 0 0 0 0 0 0 0 0 0 869
////////////////////////////////////////////////////////////////////
//       Class : Filename
// Description : The name of a file, such as a texture file or an Egg
//               file.  Stores the full pathname, and includes
//               functions for extracting out the directory prefix
//               part and the file extension and stuff.
//
//               A Filename is also aware of the mapping between the
//               Unix-like filename convention we use internally, and
//               the local OS's specific filename convention, and it
//               knows how to perform basic OS-specific I/O, like
//               testing for file existence and searching a
//               searchpath, as well as the best way to open an
//               fstream for reading or writing.
////////////////////////////////////////////////////////////////////

713 9 istream * 0 8576 9 istream * 9 istream * 0 0 714 0 0 0 0 0 0 0 0 0 0

714 7 istream 0 2048 7 istream 7 istream 0 0 0 0 0 0 0 0 0 0 0 0 0

715 11 PNMReader * 0 8576 11 PNMReader * 11 PNMReader * 0 0 716 0 0 0 0 0 0 0 0 0 0

716 9 PNMReader 0 2048 9 PNMReader 9 PNMReader 0 0 0 0 0 0 0 0 0 0 0 0 0

717 11 PNMWriter * 0 8576 11 PNMWriter * 11 PNMWriter * 0 0 718 0 0 0 0 0 0 0 0 0 0

718 9 PNMWriter 0 2048 9 PNMWriter 9 PNMWriter 0 0 0 0 0 0 0 0 0 0 0 0 0

719 22 basic_string< char > * 0 8576 22 basic_string< char > * 22 basic_string< char > * 0 0 720 0 0 0 0 0 0 0 0 0 0

720 6 string 0 2048 20 basic_string< char > 20 basic_string< char > 0 0 0 0 0 0 0 0 0 0 0 0 0

721 17 PixelSpec const * 0 8576 33 PNMImageHeader::PixelSpec const * 33 PNMImageHeader::PixelSpec const * 0 0 722 0 0 0 0 0 0 0 0 0 0

722 15 PixelSpec const 0 8832 31 PNMImageHeader::PixelSpec const 31 PNMImageHeader::PixelSpec const 0 0 680 0 0 0 0 0 0 0 0 0 0

723 11 PixelSpec * 0 8576 27 PNMImageHeader::PixelSpec * 27 PNMImageHeader::PixelSpec * 0 0 680 0 0 0 0 0 0 0 0 0 0

724 11 Histogram * 0 8576 27 PNMImageHeader::Histogram * 27 PNMImageHeader::Histogram * 0 0 682 0 0 0 0 0 0 0 0 0 0

725 17 Histogram const * 0 8576 33 PNMImageHeader::Histogram const * 33 PNMImageHeader::Histogram const * 0 0 726 0 0 0 0 0 0 0 0 0 0

726 15 Histogram const 0 8832 31 PNMImageHeader::Histogram const 31 PNMImageHeader::Histogram const 0 0 682 0 0 0 0 0 0 0 0 0 0

727 9 PfmFile * 0 8576 9 PfmFile * 9 PfmFile * 0 0 683 0 0 0 0 0 0 0 0 0 0

728 15 PfmFile const * 0 8576 15 PfmFile const * 15 PfmFile const * 0 0 729 0 0 0 0 0 0 0 0 0 0

729 13 PfmFile const 0 8832 13 PfmFile const 13 PfmFile const 0 0 683 0 0 0 0 0 0 0 0 0 0

730 16 PNMImage const * 0 8576 16 PNMImage const * 16 PNMImage const * 0 0 731 0 0 0 0 0 0 0 0 0 0

731 14 PNMImage const 0 8832 14 PNMImage const 14 PNMImage const 0 0 687 0 0 0 0 0 0 0 0 0 0

732 10 PNMImage * 0 8576 10 PNMImage * 10 PNMImage * 0 0 687 0 0 0 0 0 0 0 0 0 0

733 5 float 0 8194 5 float 5 float 0 2 0 0 0 0 0 0 0 0 0 0 0

734 16 LPoint2f const * 0 8576 16 LPoint2f const * 16 LPoint2f const * 0 0 735 0 0 0 0 0 0 0 0 0 0

735 14 LPoint2f const 0 8832 14 LPoint2f const 14 LPoint2f const 0 0 736 0 0 0 0 0 0 0 0 0 0

736 8 LPoint2f 0 2048 8 LPoint2f 8 LPoint2f 0 0 0 0 0 0 0 0 0 0 0 0 706
// Filename: lpoint2_src.h
// Created by:  drose (08Mar00)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//       Class : LPoint2
// Description : This is a two-component point in space.
////////////////////////////////////////////////////////////////////

737 18 LVecBase2d const * 0 8576 18 LVecBase2d const * 18 LVecBase2d const * 0 0 738 0 0 0 0 0 0 0 0 0 0

738 16 LVecBase2d const 0 8832 16 LVecBase2d const 16 LVecBase2d const 0 0 739 0 0 0 0 0 0 0 0 0 0

739 10 LVecBase2d 0 2048 10 LVecBase2d 10 LVecBase2d 0 0 0 0 0 0 0 0 0 0 0 0 752
// Filename: lvecBase2_src.h
// Created by:  drose (08Mar00)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//       Class : LVecBase2
// Description : This is the base class for all two-component
//               vectors and points.
////////////////////////////////////////////////////////////////////

740 18 LVecBase2f const * 0 8576 18 LVecBase2f const * 18 LVecBase2f const * 0 0 741 0 0 0 0 0 0 0 0 0 0

741 16 LVecBase2f const 0 8832 16 LVecBase2f const 16 LVecBase2f const 0 0 742 0 0 0 0 0 0 0 0 0 0

742 10 LVecBase2f 0 2048 10 LVecBase2f 10 LVecBase2f 0 0 0 0 0 0 0 0 0 0 0 0 752
// Filename: lvecBase2_src.h
// Created by:  drose (08Mar00)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//       Class : LVecBase2
// Description : This is the base class for all two-component
//               vectors and points.
////////////////////////////////////////////////////////////////////

743 10 LPoint2f * 0 8576 10 LPoint2f * 10 LPoint2f * 0 0 736 0 0 0 0 0 0 0 0 0 0

744 16 LPoint3f const * 0 8576 16 LPoint3f const * 16 LPoint3f const * 0 0 745 0 0 0 0 0 0 0 0 0 0

745 14 LPoint3f const 0 8832 14 LPoint3f const 14 LPoint3f const 0 0 746 0 0 0 0 0 0 0 0 0 0

746 8 LPoint3f 0 2048 8 LPoint3f 8 LPoint3f 0 0 0 0 0 0 0 0 0 0 0 0 1083
// Filename: lpoint3_src.h
// Created by:  drose (25Sep99)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//       Class : LPoint3
// Description : This is a three-component point in space (as opposed
//               to a three-component vector, which represents a
//               direction and a distance).  Some of the methods are
//               slightly different between LPoint3 and LVector3; in
//               particular, subtraction of two points yields a
//               vector, while addition of a vector and a point yields
//               a point.
////////////////////////////////////////////////////////////////////

747 18 LVecBase3d const * 0 8576 18 LVecBase3d const * 18 LVecBase3d const * 0 0 748 0 0 0 0 0 0 0 0 0 0

748 16 LVecBase3d const 0 8832 16 LVecBase3d const 16 LVecBase3d const 0 0 749 0 0 0 0 0 0 0 0 0 0

749 10 LVecBase3d 0 2048 10 LVecBase3d 10 LVecBase3d 0 0 0 0 0 0 0 0 0 0 0 0 754
// Filename: lvecBase3_src.h
// Created by:  drose (08Mar00)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//       Class : LVecBase3
// Description : This is the base class for all three-component
//               vectors and points.
////////////////////////////////////////////////////////////////////

750 18 LVecBase3f const * 0 8576 18 LVecBase3f const * 18 LVecBase3f const * 0 0 751 0 0 0 0 0 0 0 0 0 0

751 16 LVecBase3f const 0 8832 16 LVecBase3f const 16 LVecBase3f const 0 0 752 0 0 0 0 0 0 0 0 0 0

752 10 LVecBase3f 0 2048 10 LVecBase3f 10 LVecBase3f 0 0 0 0 0 0 0 0 0 0 0 0 754
// Filename: lvecBase3_src.h
// Created by:  drose (08Mar00)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//       Class : LVecBase3
// Description : This is the base class for all three-component
//               vectors and points.
////////////////////////////////////////////////////////////////////

753 10 LPoint3f * 0 8576 10 LPoint3f * 10 LPoint3f * 0 0 746 0 0 0 0 0 0 0 0 0 0

754 16 LPoint4f const * 0 8576 16 LPoint4f const * 16 LPoint4f const * 0 0 755 0 0 0 0 0 0 0 0 0 0

755 14 LPoint4f const 0 8832 14 LPoint4f const 14 LPoint4f const 0 0 756 0 0 0 0 0 0 0 0 0 0

756 8 LPoint4f 0 2048 8 LPoint4f 8 LPoint4f 0 0 0 0 0 0 0 0 0 0 0 0 707
// Filename: lpoint4_src.h
// Created by:  drose (08Mar00)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//       Class : LPoint4
// Description : This is a four-component point in space.
////////////////////////////////////////////////////////////////////

757 18 LVecBase4d const * 0 8576 18 LVecBase4d const * 18 LVecBase4d const * 0 0 758 0 0 0 0 0 0 0 0 0 0

758 16 LVecBase4d const 0 8832 16 LVecBase4d const 16 LVecBase4d const 0 0 759 0 0 0 0 0 0 0 0 0 0

759 10 LVecBase4d 0 2048 10 LVecBase4d 10 LVecBase4d 0 0 0 0 0 0 0 0 0 0 0 0 265
////////////////////////////////////////////////////////////////////
//       Class : LVecBase4
// Description : This is the base class for all three-component
//               vectors and points.
////////////////////////////////////////////////////////////////////

760 18 LVecBase4f const * 0 8576 18 LVecBase4f const * 18 LVecBase4f const * 0 0 761 0 0 0 0 0 0 0 0 0 0

761 16 LVecBase4f const 0 8832 16 LVecBase4f const 16 LVecBase4f const 0 0 762 0 0 0 0 0 0 0 0 0 0

762 10 LVecBase4f 0 2048 10 LVecBase4f 10 LVecBase4f 0 0 0 0 0 0 0 0 0 0 0 0 265
////////////////////////////////////////////////////////////////////
//       Class : LVecBase4
// Description : This is the base class for all three-component
//               vectors and points.
////////////////////////////////////////////////////////////////////

763 10 LPoint4f * 0 8576 10 LPoint4f * 10 LPoint4f * 0 0 756 0 0 0 0 0 0 0 0 0 0

764 12 LVecBase3f * 0 8576 12 LVecBase3f * 12 LVecBase3f * 0 0 752 0 0 0 0 0 0 0 0 0 0

765 12 LVecBase4d * 0 8576 12 LVecBase4d * 12 LVecBase4d * 0 0 759 0 0 0 0 0 0 0 0 0 0

766 12 LVecBase4f * 0 8576 12 LVecBase4f * 12 LVecBase4f * 0 0 762 0 0 0 0 0 0 0 0 0 0

767 16 LPoint4d const * 0 8576 16 LPoint4d const * 16 LPoint4d const * 0 0 768 0 0 0 0 0 0 0 0 0 0

768 14 LPoint4d const 0 8832 14 LPoint4d const 14 LPoint4d const 0 0 769 0 0 0 0 0 0 0 0 0 0

769 8 LPoint4d 0 2048 8 LPoint4d 8 LPoint4d 0 0 0 0 0 0 0 0 0 0 0 0 707
// Filename: lpoint4_src.h
// Created by:  drose (08Mar00)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//       Class : LPoint4
// Description : This is a four-component point in space.
////////////////////////////////////////////////////////////////////

770 17 LMatrix4d const * 0 8576 17 LMatrix4d const * 17 LMatrix4d const * 0 0 771 0 0 0 0 0 0 0 0 0 0

771 15 LMatrix4d const 0 8832 15 LMatrix4d const 15 LMatrix4d const 0 0 772 0 0 0 0 0 0 0 0 0 0

772 9 LMatrix4d 0 2048 9 LMatrix4d 9 LMatrix4d 0 0 0 0 0 0 0 3 799 800 801 0 0 0 0 215
////////////////////////////////////////////////////////////////////
//       Class : LMatrix4
// Description : This is a 4-by-4 transform matrix.
////////////////////////////////////////////////////////////////////

773 17 LMatrix4f const * 0 8576 17 LMatrix4f const * 17 LMatrix4f const * 0 0 774 0 0 0 0 0 0 0 0 0 0

774 15 LMatrix4f const 0 8832 15 LMatrix4f const 15 LMatrix4f const 0 0 775 0 0 0 0 0 0 0 0 0 0

775 9 LMatrix4f 0 2048 9 LMatrix4f 9 LMatrix4f 0 0 0 0 0 0 0 3 802 803 804 0 0 0 0 215
////////////////////////////////////////////////////////////////////
//       Class : LMatrix4
// Description : This is a 4-by-4 transform matrix.
////////////////////////////////////////////////////////////////////

776 18 BoundingHexahedron 0 2048 18 BoundingHexahedron 18 BoundingHexahedron 0 0 0 0 0 0 0 2 805 806 0 0 0 0 556
////////////////////////////////////////////////////////////////////
//       Class : BoundingHexahedron
// Description : This defines a bounding convex hexahedron.  It is
//               typically used to represent a frustum, but may
//               represent any enclosing convex hexahedron, including
//               simple boxes.  However, if all you want is an
//               axis-aligned bounding box, you may be better off with
//               the simpler BoundingBox class.
////////////////////////////////////////////////////////////////////

777 16 LPoint2d const * 0 8576 16 LPoint2d const * 16 LPoint2d const * 0 0 778 0 0 0 0 0 0 0 0 0 0

778 14 LPoint2d const 0 8832 14 LPoint2d const 14 LPoint2d const 0 0 779 0 0 0 0 0 0 0 0 0 0

779 8 LPoint2d 0 2048 8 LPoint2d 8 LPoint2d 0 0 0 0 0 0 0 0 0 0 0 0 706
// Filename: lpoint2_src.h
// Created by:  drose (08Mar00)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//       Class : LPoint2
// Description : This is a two-component point in space.
////////////////////////////////////////////////////////////////////

780 20 BoundingHexahedron * 0 8576 20 BoundingHexahedron * 20 BoundingHexahedron * 0 0 776 0 0 0 0 0 0 0 0 0 0

781 10 PyObject * 0 8576 10 PyObject * 10 PyObject * 0 0 782 0 0 0 0 0 0 0 0 0 0

782 8 PyObject 0 2048 8 PyObject 8 PyObject 0 0 0 0 0 0 0 0 0 0 0 0 0

783 11 Py_buffer * 0 8576 11 Py_buffer * 11 Py_buffer * 0 0 784 0 0 0 0 0 0 0 0 0 0

784 9 Py_buffer 0 1024 9 Py_buffer 9 Py_buffer 0 0 0 0 0 0 0 0 0 0 0 0 0

785 10 PNMBrush * 0 8576 10 PNMBrush * 10 PNMBrush * 0 0 684 0 0 0 0 0 0 0 0 0 0

786 12 LVecBase3d * 0 8576 12 LVecBase3d * 12 LVecBase3d * 0 0 749 0 0 0 0 0 0 0 0 0 0

787 21 StackedPerlinNoise2 * 0 8576 21 StackedPerlinNoise2 * 21 StackedPerlinNoise2 * 0 0 788 0 0 0 0 0 0 0 0 0 0

788 19 StackedPerlinNoise2 0 2048 19 StackedPerlinNoise2 19 StackedPerlinNoise2 0 0 0 0 0 0 0 0 0 0 0 0 359
////////////////////////////////////////////////////////////////////
//       Class : StackedPerlinNoise2
// Description : Implements a multi-layer PerlinNoise, with one or
//               more high-frequency noise functions added to a
//               lower-frequency base noise function.
////////////////////////////////////////////////////////////////////

789 17 unsigned long int 0 8214 17 unsigned long int 17 unsigned long int 0 1 0 0 0 0 0 0 0 0 0 0 0

790 12 PNMPainter * 0 8576 12 PNMPainter * 12 PNMPainter * 0 0 688 0 0 0 0 0 0 0 0 0 0

791 18 PNMPainter const * 0 8576 18 PNMPainter const * 18 PNMPainter const * 0 0 792 0 0 0 0 0 0 0 0 0 0

792 16 PNMPainter const 0 8832 16 PNMPainter const 16 PNMPainter const 0 0 688 0 0 0 0 0 0 0 0 0 0

0
3
793 1 b 0 6 674 420 421 8 pixel::b 
794 1 g 0 6 674 422 423 8 pixel::g 
795 1 r 0 6 674 424 425 8 pixel::r 
11
796 0 0 23 14 get_extensions 18 get_num_extensions 13 get_extension 
797 0 0 30 9 get_types 13 get_num_types 8 get_type 
798 0 0 82 10 get_pixels 14 get_num_pixels 9 get_pixel 
799 0 0 545 8 get_rows 4 size 7 get_row 
800 0 0 545 8 get_cols 4 size 7 get_col 
801 0 0 545 9 get_row3s 4 size 8 get_row3 
802 0 0 549 8 get_rows 4 size 7 get_row 
803 0 0 549 8 get_cols 4 size 7 get_col 
804 0 0 549 9 get_row3s 4 size 8 get_row3 
805 0 0 561 10 get_points 14 get_num_points 9 get_point 
806 0 0 561 10 get_planes 14 get_num_planes 9 get_plane 
