247 lines
6.1 KiB
C++
247 lines
6.1 KiB
C++
// Copyright 2002, 2003, 2004 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
|
|
*/
|
|
|
|
/*
|
|
* zero_image.h: Image that is zero everywhere.
|
|
*/
|
|
|
|
#ifndef __image_zero_h__
|
|
#define __image_zero_h__
|
|
|
|
#include "point.h"
|
|
#include "pixel.h"
|
|
#include "exposure/exposure.h"
|
|
|
|
class image_zero : public image_weighted_avg {
|
|
public:
|
|
|
|
spixel get_pixel(unsigned int y, unsigned int x) const {
|
|
return pixel::zero();
|
|
}
|
|
|
|
void set_pixel(unsigned int y, unsigned int x, spixel p) {
|
|
assert(0);
|
|
}
|
|
|
|
void set_chan(unsigned int y, unsigned int x, unsigned int k, ale_sreal c) {
|
|
assert(0);
|
|
}
|
|
|
|
ale_sreal get_chan(unsigned int y, unsigned int x, unsigned int k) const {
|
|
return 0;
|
|
}
|
|
|
|
ale_real maxval() const {
|
|
return 0;
|
|
}
|
|
|
|
ale_real minval() const {
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Get a color value at a given position using bilinear interpolation between the
|
|
* four nearest pixels. Result values:
|
|
*
|
|
* result[0] == pixel value
|
|
* result[1] == pixel confidence
|
|
*/
|
|
void get_bl(point x, pixel result[2]) const {
|
|
result[0] = pixel::zero();
|
|
result[1] = pixel::zero();
|
|
}
|
|
|
|
pixel get_bl(point x) const {
|
|
pixel result[2];
|
|
|
|
get_bl(x, result);
|
|
|
|
return result[0];
|
|
}
|
|
|
|
pixel get_scaled_bl(point x, ale_pos f) const {
|
|
return pixel::zero();
|
|
}
|
|
|
|
|
|
/*
|
|
* Make a new image suitable for receiving scaled values.
|
|
*/
|
|
virtual image *scale_generator(int height, int width, int depth, const char *name) const {
|
|
|
|
image *is = new image_zero(height, width, depth, name);
|
|
|
|
assert(is);
|
|
|
|
return is;
|
|
}
|
|
|
|
/*
|
|
* Return an image scaled by some factor >= 1.0
|
|
*/
|
|
image *scale(ale_pos f, const char *name) const {
|
|
|
|
image *is = new image_zero(
|
|
(int) floor(height() * f),
|
|
(int) floor(width() * f), depth());
|
|
|
|
assert(is);
|
|
|
|
return is;
|
|
}
|
|
|
|
/*
|
|
* Scale by half. We use the following filter:
|
|
*
|
|
* 1/16 1/8 1/16
|
|
* 1/8 1/4 1/8
|
|
* 1/16 1/8 1/16
|
|
*
|
|
* At the edges, these values are normalized so that the sum of
|
|
* contributing pixels is 1.
|
|
*/
|
|
image *scale_by_half(const char *name) const {
|
|
ale_pos f = 0.5;
|
|
|
|
image *result = new image_zero(
|
|
(int) floor(height() * f),
|
|
(int) floor(width() * f), depth());
|
|
|
|
assert(result);
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Scale an image definition array by 1/2.
|
|
*
|
|
* ALE considers an image definition array as a special kind of image
|
|
* weight array (typedefs of which should appear below the definition
|
|
* of this class). ALE uses nonzero pixel values to mean 'defined' and
|
|
* zero values to mean 'undefined'. Through this interpretation, the
|
|
* image weight array implementation that ALE uses allows image weight
|
|
* arrays to also serve as image definition arrays.
|
|
*
|
|
* Whereas scaling of image weight arrays is not generally obvious in
|
|
* either purpose or method, ALE requires that image definition arrays
|
|
* be scalable, and the method we implement here is a fairly obvious
|
|
* one. In particular, if any source pixel contributing to the value of
|
|
* a scaled target pixel has an undefined value, then the scaled target
|
|
* pixel is undefined (zero). Otherwise, it is defined (non-zero).
|
|
*
|
|
* Since there are many possible ways of implementing this function, we
|
|
* choose an easy way and simply multiply the numerical values of the
|
|
* source pixels to obtain the value of the scaled target pixel.
|
|
*
|
|
* XXX: we consider all pixels within a 9-pixel square to contribute.
|
|
* There are other approaches. For example, edge pixels could be
|
|
* considered to have six contributing pixels and corner pixels four
|
|
* contributing pixels. To use this convention, change the ': 0' text
|
|
* in the code below to ': 1'.
|
|
*/
|
|
|
|
image *defined_scale_by_half(const char *name) const {
|
|
ale_pos f = 0.5;
|
|
|
|
image *result = new image_zero(
|
|
(int) floor(height() * f),
|
|
(int) floor(width() * f), depth());
|
|
|
|
assert(result);
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Extend the image area to the top, bottom, left, and right,
|
|
* initializing the new image areas with black pixels.
|
|
*/
|
|
virtual image *_extend(int top, int bottom, int left, int right) {
|
|
_dimy += top + bottom;
|
|
_dimx += left + right;
|
|
_offset[0] -= top;
|
|
_offset[1] -= left;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Clone
|
|
*/
|
|
image *clone(const char *name) const {
|
|
return new image_zero(_dimy, _dimx, _depth, name);
|
|
}
|
|
|
|
/*
|
|
* Calculate the average (mean) clamped magnitude of a channel across
|
|
* all pixels in an image. The magnitude is clamped to the range of
|
|
* real inputs.
|
|
*/
|
|
ale_real avg_channel_clamped_magnitude(unsigned int k) const {
|
|
return 0;
|
|
}
|
|
|
|
pixel avg_channel_clamped_magnitude() const {
|
|
return pixel::zero();
|
|
}
|
|
|
|
/*
|
|
* Calculate the average (mean) magnitude of a channel across all
|
|
* pixels in an image.
|
|
*/
|
|
ale_real avg_channel_magnitude(unsigned int k) const {
|
|
return 0;
|
|
}
|
|
|
|
pixel avg_channel_magnitude() const {
|
|
return pixel::zero();
|
|
}
|
|
|
|
/*
|
|
* Calculate the average (mean) magnitude of a pixel (where magnitude
|
|
* is defined as the mean of the channel values).
|
|
*/
|
|
ale_real avg_pixel_magnitude() const {
|
|
return 0;
|
|
}
|
|
|
|
image_zero(unsigned int dimy, unsigned int dimx, unsigned int depth,
|
|
const char *name = "anonymous") : image_weighted_avg(dimy, dimx, depth, name) {
|
|
}
|
|
|
|
int accumulate_norender(int i, int j) {
|
|
return 1;
|
|
}
|
|
|
|
void accumulate(int i, int j, int f, pixel new_value, pixel new_weight) {
|
|
assert(0);
|
|
}
|
|
|
|
image *get_colors() {
|
|
return this;
|
|
}
|
|
|
|
image *get_weights() {
|
|
return this;
|
|
}
|
|
};
|
|
|
|
#endif
|