ale/d2/render/psf/psf.h
2022-07-30 14:46:04 -03:00

185 lines
4.1 KiB
C++

// Copyright 2003 David Hilvert <dhilvert@auricle.dyndns.org>,
// <dhilvert@ugcs.caltech.edu>
/* This file is part of the Anti-Lamenessing Engine.
The Anti-Lamenessing Engine is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
The Anti-Lamenessing Engine is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the Anti-Lamenessing Engine; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __psf_h__
#define __psf_h__
#include "../../point.h"
/*
* Point-spread function module abstract base class.
*/
class psf {
public:
/*
* Result type is a matrix.
*/
class psf_result {
friend class psf;
protected:
ale_real _matrix[3][3];
public:
psf_result() {
/*
* Simplified version -- diagonal matrix
*/
for (int i = 0; i < 3; i++)
_matrix[i][i] = 0;
}
ale_real get_matrix(unsigned int i, unsigned int j) {
assert (i < 3);
assert (j < 3);
/*
* Simplified version -- diagonal matrix
*/
if (i != j)
return 0;
else
return _matrix[i][j];
}
void set_matrix(unsigned int i, unsigned int j, ale_real value) {
assert (i < 3);
assert (j < 3);
/*
* Simplified version -- diagonal matrix
*/
assert (i == j || value == 0);
_matrix[i][j] = value;
}
ale_real &matrix(unsigned int i, unsigned int j) {
assert (i < 3);
assert (j < 3);
/*
* Simplified version -- diagonal matrix
*/
assert (i == j);
return _matrix[i][j];
}
pixel operator()(pixel p) {
/*
* Simplified version -- diagonal matrix
*/
return pixel(_matrix[0][0] * p[0],
_matrix[1][1] * p[1],
_matrix[2][2] * p[2]);
}
/*
* Weights associated with the result
*/
pixel weight() {
/*
* Simplified version -- diagonal matrix
*/
return pixel(
_matrix[0][0],
_matrix[1][1],
_matrix[2][2]);
}
void operator*=(ale_real scale) {
/*
* Simplified version -- diagonal matrix
*/
for (int i = 0; i < 3; i++)
_matrix[i][i] *= scale;
}
};
/*
* The following four functions indicate filter boundaries. Filter
* support may include everything up to and including the boundaries
* specified here.
*/
virtual ale_real min_i() const = 0;
virtual ale_real max_i() const = 0;
virtual ale_real min_j() const = 0;
virtual ale_real max_j() const = 0;
/*
* Get the number of varieties supported by this PSF. These usually
* correspond to different points in the sensor array.
*/
virtual unsigned int varieties() const {
return 1;
}
/*
* Select the variety appropriate for a given position in the sensor
* array.
*/
virtual unsigned int select(unsigned int i, unsigned int j) {
return 0;
}
/*
* Get the response to the rectangle bounded by (top, bot, lef, rig).
* This function must correctly handle points which fall outside of the
* filter support. One of several varieties can be selected, usually
* based on position (e.g. some sensor arrays stagger red, green, and
* blue sensors).
*/
virtual psf_result operator()(ale_real top, ale_real bot, ale_real lef, ale_real
rig, unsigned int variety) const = 0;
virtual psf_result operator()(ale_real top, ale_real bot, ale_real lef, ale_real
rig, unsigned int variety, char channels) const {
return operator()(top, bot, lef, rig, variety);
}
#if 0
/*
* Get the average pixel response. This function should be overloaded
* for PSFs that support multiple varieties.
*/
virtual psf_result operator()(ale_real top, ale_real bot, ale_real lef, ale_real rig) const {
return operator()(top, bot, lef, rig, 0);
}
#endif
virtual ~psf() {
}
};
#endif