sergiotarxz/libvips
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
11352c8f1b
libvips/libsrc/mosaicing/yafrnohalo.c
John Cupitt 7496082f2c use type introspection for vipsinterpolate too
2008-11-30 09:32:18 +00:00

1083 lines
37 KiB
C
Raw Blame History

/* yafrnohalo ... yafr-nohalo as a vips interpolate class
*/
/*
This file is part of VIPS.
VIPS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program 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 Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*
These files are distributed with VIPS - http://www.vips.ecs.soton.ac.uk
*/
/*
#define DEBUG
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif /*HAVE_CONFIG_H*/
#include <vips/intl.h>
#include <stdio.h>
#include <stdlib.h>
#include <vips/vips.h>
#include <vips/internal.h>
#ifdef WITH_DMALLOC
#include <dmalloc.h>
#endif /*WITH_DMALLOC*/
/* "fast" floor() ... on my laptop, anyway.
*/
#define FLOOR( V ) ((V) >= 0 ? (int)(V) : (int)((V) - 1))
#define VIPS_TYPE_INTERPOLATE_YAFRNOHALO \
(vips_interpolate_yafrnohalo_get_type())
#define VIPS_INTERPOLATE_YAFRNOHALO( obj ) \
(G_TYPE_CHECK_INSTANCE_CAST( (obj), \
VIPS_TYPE_INTERPOLATE_YAFRNOHALO, VipsInterpolateYafrnohalo ))
#define VIPS_INTERPOLATE_YAFRNOHALO_CLASS( klass ) \
(G_TYPE_CHECK_CLASS_CAST( (klass), \
VIPS_TYPE_INTERPOLATE_YAFRNOHALO, VipsInterpolateYafrnohaloClass))
#define VIPS_IS_INTERPOLATE_YAFRNOHALO( obj ) \
(G_TYPE_CHECK_INSTANCE_TYPE( (obj), VIPS_TYPE_INTERPOLATE_YAFRNOHALO ))
#define VIPS_IS_INTERPOLATE_YAFRNOHALO_CLASS( klass ) \
(G_TYPE_CHECK_CLASS_TYPE( (klass), VIPS_TYPE_INTERPOLATE_YAFRNOHALO ))
#define VIPS_INTERPOLATE_YAFRNOHALO_GET_CLASS( obj ) \
(G_TYPE_INSTANCE_GET_CLASS( (obj), \
VIPS_TYPE_INTERPOLATE_YAFRNOHALO, VipsInterpolateYafrnohaloClass ))
typedef struct _VipsInterpolateYafrnohalo {
VipsInterpolate parent_object;
/* "sharpening" is a continuous method parameter which is
* proportional to the amount of "diagonal straightening" which the
* nonlinear correction part of the method may add to the underlying
* linear scheme. You may also think of it as a sharpening
* parameter: higher values correspond to more sharpening, and
* negative values lead to strange looking effects.
*
* The default value is sharpening = 4/3 when the scheme being
* "straightened" is bilinear---as is the case here. This value
* fixes key pixel values near the diagonal boundary between two
* monochrome regions (the diagonal boundary pixel values being set
* to the halfway colour).
*
* If resampling seems to add unwanted texture artifacts, push
* sharpening toward 0. It is not generally not recommended to set
* sharpening to a value larger than 2.
*
* In order to simplify interfacing with users, the parameter which
* should be set by the user is normalized so that user_sharpening =
* 1 when sharpening is equal to the recommended value. Consistently
* with the above discussion, values of user_sharpening between 0
* and about 1.5 give good results.
*/
double sharpening;
} VipsInterpolateYafrnohalo;
typedef struct _VipsInterpolateYafrnohaloClass {
VipsInterpolateClass parent_class;
} VipsInterpolateYafrnohaloClass;
G_DEFINE_TYPE( VipsInterpolateYafrnohalo, vips_interpolate_yafrnohalo,
VIPS_TYPE_INTERPOLATE );
/* Copy-paste of gegl-sampler-yafr-nohalo.c starts
*/
/*
* 2008 (c) Nicolas Robidoux (developer of Yet Another Fast
* Resampler).
*
* Acknowledgement: N. Robidoux's research on YAFR funded in part by
* an NSERC (National Science and Engineering Research Council of
* Canada) Discovery Grant.
*/
#ifndef restrict
#ifdef __restrict
#define restrict __restrict
#else
#ifdef __restrict__
#define restrict __restrict__
#else
#define restrict
#endif
#endif
#endif
#ifndef unlikely
#ifdef __builtin_expect
#define unlikely(x) __builtin_expect((x),0)
#else
#define unlikely(x) (x)
#endif
#endif
/*
* YAFR = Yet Another Fast Resampler
*
* Yet Another Fast Resampler is a nonlinear resampler which consists
* of a linear scheme (in this version, bilinear) plus a nonlinear
* sharpening correction the purpose of which is the straightening of
* diagonal interfaces between flat colour areas.
*
* Key properties:
*
* YAFR (nohalo) is a parameterized method:
*
* The key parameter is called "sharpening." When sharpening = 0, YAFR
* (nohalo) is standard bilinear interpolation, method which is
* coconvex (and comonotone). More generally, YAFR (nohalo) is a
* coconvex (and comonotone) method when sharpening <= .5, When
* sharpening <= 1, YAFR (nohalo) is comonotone (but not coconvex),
* and consequently does not add haloing where it is not present. For
* the default value of sharpening, namely 4/3, YAFR (nohalo) does add
* some haloing, so little that it is generally not noticeable;
* however, for this sharpening value, YAFR (nohalo) correctly fixes
* key values near a sharp diagonal interface between flat color
* areas. In some situations (for example, photographs of text),
* values of sharpening as large as 2 are recommended. (Negative
* values of sharpening gives "artistic" results, as do very large
* ones).
*
* YAFR (nohalo) is interpolatory:
*
* If asked for the value at the center of an input pixel, it will
* return the corresponding value, unchanged.
*
* YAFR (nohalo) preserves local averages:
*
* The average of the reconstructed intensity surface over any region
* is the same as the average of the piecewise constant surface with
* values over pixel areas equal to the input pixel values (the
* "nearest neighbour" surface), except for a small amount of blur at
* the boundary of the region. More precicely: YAFR (nohalo) is a box
* filtered exact area method.
*
* Main weaknesses of YAFR (nohalo):
*
* YAFR (nohalo) improves on the standard bilinear method only for
* images with at least a little bit of smoothness.
*
* Like bilinear, YAFR (nohalo) often suffers from noticeable Mach
* banding. When the images are reasonably smooth, however, the Mach
* banding produced by YAFR for moderate values of the sharpening
* parameter is much less noticeable than the one for bilinear.
*/
/* Pointers to write to / read from, how much to add to move right a pixel,
* how much to add to move down a line.
*/
static inline void
bilinear_yafrnohalo (float* restrict out, const float* restrict in,
const int channels,
const int pixels_per_buffer_row,
const float user_sharpening,
const gfloat c_horizo_left___up,
const gfloat c_horizo_left_down,
const gfloat c_horizo_rite___up,
const gfloat c_horizo_rite_down,
const gfloat c_vertic_left___up,
const gfloat c_vertic_rite___up,
const gfloat c_vertic_left_down,
const gfloat c_vertic_rite_down,
const gfloat c_settin_left___up,
const gfloat c_settin_rite___up,
const gfloat c_settin_left_down,
const gfloat c_settin_rite_down,
const gfloat c_rising_left___up,
const gfloat c_rising_rite___up,
const gfloat c_rising_left_down,
const gfloat c_rising_rite_down,
const gfloat left_width_times___up_hight,
const gfloat rite_width_times___up_hight,
const gfloat left_width_times_down_hight,
const gfloat rite_width_times_down_hight)
{
/*
* "sharpening" is a continuous method parameter which is
* proportional to the amount of "diagonal straightening" which the
* nonlinear correction part of the method may add to the underlying
* linear scheme. You may also think of it as a sharpening
* parameter: higher values correspond to more sharpening, and
* negative values lead to strange looking effects.
*
* The default value is sharpening = 4/3 when the scheme being
* "straightened" is bilinear---as is the case here. This value
* fixes key pixel values near the diagonal boundary between two
* monochrome regions (the diagonal boundary pixel values being set
* to the halfway colour).
*
* If resampling seems to add unwanted texture artifacts, push
* sharpening toward 0. It is not generally not recommended to set
* sharpening to a value much larger than 2.
*
* In order to simplify interfacing with users, the parameter which
* should be set by the user is normalized so that user_sharpening =
* 1 when sharpening is equal to the recommended value. Consistently
* with the above discussion, values of user_sharpening between 0
* and about 1.5 give good results.
*/
const gfloat sharpening = user_sharpening * ( 4.f / 3.f );
/*
* The input pixel values are described by the following stencil.
* Spanish abbreviations are used to label positions from top to
* bottom, English ones to label positions from left to right,:
*
* (ix-1,iy-1) (ix,iy-1) (ix+1,iy-1) (ix+2,iy-1)
* =uno_one =uno_two =uno_thr = uno_fou
*
* (ix-1,iy) (ix,iy) (ix+1,iy) (ix+2,iy)
* =dos_one =dos_two =dos_thr = dos_fou
*
* (ix-1,iy+1) (ix,iy+1) (ix+1,iy+1) (ix+2,iy+1)
* =tre_one =tre_two =tre_thr = tre_fou
*
* (ix-1,iy+2) (ix,iy+2) (ix+1,iy+2) (ix+2,iy+2)
* =qua_one =qua_two =qua_thr = qua_fou
*/
/*
* Load the useful pixel values for the channel under
* consideration. The in pointer is assumed
* to point to uno_one when bilinear_yafrnohalo is entered.
*/
const float uno_one = in[ 0 ];
const float uno_two = in[ channels ];
const float uno_thr = in[ 2 * channels ];
const float uno_fou = in[ 3 * channels ];
const float dos_one = in[ pixels_per_buffer_row * channels ];
const float dos_two = in[ ( 1 + pixels_per_buffer_row ) * channels ];
const float dos_thr = in[ ( 2 + pixels_per_buffer_row ) * channels ];
const float dos_fou = in[ ( 3 + pixels_per_buffer_row ) * channels ];
const float tre_one = in[ 2 * pixels_per_buffer_row * channels ];
const float tre_two = in[ ( 1 + 2 * pixels_per_buffer_row ) * channels ];
const float tre_thr = in[ ( 2 + 2 * pixels_per_buffer_row ) * channels ];
const float tre_fou = in[ ( 3 + 2 * pixels_per_buffer_row ) * channels ];
const float qua_one = in[ 3 * pixels_per_buffer_row * channels ];
const float qua_two = in[ ( 1 + 3 * pixels_per_buffer_row ) * channels ];
const float qua_thr = in[ ( 2 + 3 * pixels_per_buffer_row ) * channels ];
const float qua_fou = in[ ( 3 + 3 * pixels_per_buffer_row ) * channels ];
/*
* Bilinear (piecewise constant histopolant pieces) baseline
* contribution:
*/
const gfloat bilinear =
left_width_times___up_hight * dos_two
+
rite_width_times___up_hight * dos_thr
+
left_width_times_down_hight * tre_two
+
rite_width_times_down_hight * tre_thr;
/*
* Computation of the YAFR correction:
*
* Basically, if two consecutive pixel value differences have the
* same sign, the smallest one (in absolute value) is taken to be
* the corresponding slope. If they don't have the same sign, the
* corresponding slope is set to 0.
*
* For each of the four overlapped pixels, four slopes are thus
* computed: horizontal, vertical, "rising" (45 degree angle) and
* "setting" (-45 degree angle).
*/
/*
* Beginning of the computation of the "up" horizontal differences
* (left to right):
*/
const gfloat prem___up_horizo = dos_two - dos_one;
const gfloat deux___up_horizo = dos_thr - dos_two;
const gfloat troi___up_horizo = dos_fou - dos_thr;
/*
* "down" horizontal differences:
*/
const gfloat prem_down_horizo = tre_two - tre_one;
const gfloat deux_down_horizo = tre_thr - tre_two;
const gfloat troi_down_horizo = tre_fou - tre_thr;
/*
* "left" vertical differences (top to bottom):
*/
const gfloat prem_left_vertic = dos_two - uno_two;
const gfloat deux_left_vertic = tre_two - dos_two;
const gfloat troi_left_vertic = qua_two - tre_two;
/*
* "right" vertical differences:
*/
const gfloat prem_rite_vertic = dos_thr - uno_thr;
const gfloat deux_rite_vertic = tre_thr - dos_thr;
const gfloat troi_rite_vertic = qua_thr - tre_thr;
/*
* "left rising" diagonal differences (bottom left to upper right):
*/
const gfloat prem_left_rising = dos_two - tre_one;
const gfloat deux_left_rising = uno_thr - dos_two;
/*
* "middle rising" diagonal differences:
*/
const gfloat prem_midl_rising = tre_two - qua_one;
const gfloat deux_midl_rising = dos_thr - tre_two;
const gfloat troi_midl_rising = uno_fou - dos_thr;
/*
* "right rising" diagonal differences:
*/
const gfloat prem_rite_rising = tre_thr - qua_two;
const gfloat deux_rite_rising = dos_fou - tre_thr;
/*
* "left setting" diagonal differences (top left to bottom right):
*/
const gfloat prem_left_settin = tre_two - dos_one;
const gfloat deux_left_settin = qua_thr - tre_two;
/*
* "middle setting" diagonal differences:
*/
const gfloat prem_midl_settin = dos_two - uno_one;
const gfloat deux_midl_settin = tre_thr - dos_two;
const gfloat troi_midl_settin = qua_fou - tre_thr;
/*
* "right" setting diagonal differences:
*/
const gfloat prem_rite_settin = dos_thr - uno_two;
const gfloat deux_rite_settin = tre_fou - dos_thr;
/*
* Back to "up":
*/
const gfloat prem___up_horizo_squared = prem___up_horizo * prem___up_horizo;
const gfloat deux___up_horizo_squared = deux___up_horizo * deux___up_horizo;
const gfloat troi___up_horizo_squared = troi___up_horizo * troi___up_horizo;
/*
* Back to "down":
*/
const gfloat prem_down_horizo_squared = prem_down_horizo * prem_down_horizo;
const gfloat deux_down_horizo_squared = deux_down_horizo * deux_down_horizo;
const gfloat troi_down_horizo_squared = troi_down_horizo * troi_down_horizo;
/*
* Back to "left":
*/
const gfloat prem_left_vertic_squared = prem_left_vertic * prem_left_vertic;
const gfloat deux_left_vertic_squared = deux_left_vertic * deux_left_vertic;
const gfloat troi_left_vertic_squared = troi_left_vertic * troi_left_vertic;
/*
* Back to "right":
*/
const gfloat prem_rite_vertic_squared = prem_rite_vertic * prem_rite_vertic;
const gfloat deux_rite_vertic_squared = deux_rite_vertic * deux_rite_vertic;
const gfloat troi_rite_vertic_squared = troi_rite_vertic * troi_rite_vertic;
/*
* Back to "left rising":
*/
const gfloat prem_left_rising_squared = prem_left_rising * prem_left_rising;
const gfloat deux_left_rising_squared = deux_left_rising * deux_left_rising;
/*
* Back to "middle rising":
*/
const gfloat prem_midl_rising_squared = prem_midl_rising * prem_midl_rising;
const gfloat deux_midl_rising_squared = deux_midl_rising * deux_midl_rising;
const gfloat troi_midl_rising_squared = troi_midl_rising * troi_midl_rising;
/*
* Back to "right rising":
*/
const gfloat prem_rite_rising_squared = prem_rite_rising * prem_rite_rising;
const gfloat deux_rite_rising_squared = deux_rite_rising * deux_rite_rising;
/*
* Back to "left setting":
*/
const gfloat prem_left_settin_squared = prem_left_settin * prem_left_settin;
const gfloat deux_left_settin_squared = deux_left_settin * deux_left_settin;
/*
* Back to "middle setting":
*/
const gfloat prem_midl_settin_squared = prem_midl_settin * prem_midl_settin;
const gfloat deux_midl_settin_squared = deux_midl_settin * deux_midl_settin;
const gfloat troi_midl_settin_squared = troi_midl_settin * troi_midl_settin;
/*
* Back to "right setting":
*/
const gfloat prem_rite_settin_squared = prem_rite_settin * prem_rite_settin;
const gfloat deux_rite_settin_squared = deux_rite_settin * deux_rite_settin;
/*
* "up":
*/
const gfloat prem___up_horizo_times_deux___up_horizo =
prem___up_horizo * deux___up_horizo;
const gfloat deux___up_horizo_times_troi___up_horizo =
deux___up_horizo * troi___up_horizo;
/*
* "down":
*/
const gfloat prem_down_horizo_times_deux_down_horizo =
prem_down_horizo * deux_down_horizo;
const gfloat deux_down_horizo_times_troi_down_horizo =
deux_down_horizo * troi_down_horizo;
/*
* "left":
*/
const gfloat prem_left_vertic_times_deux_left_vertic =
prem_left_vertic * deux_left_vertic;
const gfloat deux_left_vertic_times_troi_left_vertic =
deux_left_vertic * troi_left_vertic;
/*
* "right":
*/
const gfloat prem_rite_vertic_times_deux_rite_vertic =
prem_rite_vertic * deux_rite_vertic;
const gfloat deux_rite_vertic_times_troi_rite_vertic =
deux_rite_vertic * troi_rite_vertic;
/*
* "left rising":
*/
const gfloat prem_left_rising_times_deux_left_rising =
prem_left_rising * deux_left_rising;
/*
* "middle rising":
*/
const gfloat prem_midl_rising_times_deux_midl_rising =
prem_midl_rising * deux_midl_rising;
const gfloat deux_midl_rising_times_troi_midl_rising =
deux_midl_rising * troi_midl_rising;
/*
* "right rising":
*/
const gfloat prem_rite_rising_times_deux_rite_rising =
prem_rite_rising * deux_rite_rising;
/*
* "left setting":
*/
const gfloat prem_left_settin_times_deux_left_settin =
prem_left_settin * deux_left_settin;
/*
* "middle setting":
*/
const gfloat prem_midl_settin_times_deux_midl_settin =
prem_midl_settin * deux_midl_settin;
const gfloat deux_midl_settin_times_troi_midl_settin =
deux_midl_settin * troi_midl_settin;
/*
* "right setting":
*/
const gfloat prem_rite_settin_times_deux_rite_settin =
prem_rite_settin * deux_rite_settin;
/*
* Branching parts of the computation of the YAFR correction (could
* be unbranched using arithmetic branching and C99 math intrinsics,
* although the compiler may be smart enough to remove the branching
* on its own):
*/
/*
* "up":
*/
const gfloat prem___up_horizo_vs_deux___up_horizo =
prem___up_horizo_squared < deux___up_horizo_squared
? prem___up_horizo
: deux___up_horizo;
const gfloat deux___up_horizo_vs_troi___up_horizo =
deux___up_horizo_squared < troi___up_horizo_squared
? deux___up_horizo
: troi___up_horizo;
/*
* "down":
*/
const gfloat prem_down_horizo_vs_deux_down_horizo =
prem_down_horizo_squared < deux_down_horizo_squared
? prem_down_horizo
: deux_down_horizo;
const gfloat deux_down_horizo_vs_troi_down_horizo =
deux_down_horizo_squared < troi_down_horizo_squared
? deux_down_horizo
: troi_down_horizo;
/*
* "left":
*/
const gfloat prem_left_vertic_vs_deux_left_vertic =
prem_left_vertic_squared < deux_left_vertic_squared
? prem_left_vertic
: deux_left_vertic;
const gfloat deux_left_vertic_vs_troi_left_vertic =
deux_left_vertic_squared < troi_left_vertic_squared
? deux_left_vertic
: troi_left_vertic;
/*
* "right":
*/
const gfloat prem_rite_vertic_vs_deux_rite_vertic =
prem_rite_vertic_squared < deux_rite_vertic_squared
? prem_rite_vertic
: deux_rite_vertic;
const gfloat deux_rite_vertic_vs_troi_rite_vertic =
deux_rite_vertic_squared < troi_rite_vertic_squared
? deux_rite_vertic
: troi_rite_vertic;
/*
* "left rising":
*/
const gfloat prem_left_rising_vs_deux_left_rising =
prem_left_rising_squared < deux_left_rising_squared
? prem_left_rising
: deux_left_rising;
/*
* "middle rising":
*/
const gfloat prem_midl_rising_vs_deux_midl_rising =
prem_midl_rising_squared < deux_midl_rising_squared
? prem_midl_rising
: deux_midl_rising;
const gfloat deux_midl_rising_vs_troi_midl_rising =
deux_midl_rising_squared < troi_midl_rising_squared
? deux_midl_rising
: troi_midl_rising;
/*
* "right rising":
*/
const gfloat prem_rite_rising_vs_deux_rite_rising =
prem_rite_rising_squared < deux_rite_rising_squared
? prem_rite_rising
: deux_rite_rising;
/*
* "left setting":
*/
const gfloat prem_left_settin_vs_deux_left_settin =
prem_left_settin_squared < deux_left_settin_squared
? prem_left_settin
: deux_left_settin;
/*
* "middle setting":
*/
const gfloat prem_midl_settin_vs_deux_midl_settin =
prem_midl_settin_squared < deux_midl_settin_squared
? prem_midl_settin
: deux_midl_settin;
const gfloat deux_midl_settin_vs_troi_midl_settin =
deux_midl_settin_squared < troi_midl_settin_squared
? deux_midl_settin
: troi_midl_settin;
/*
* "right setting":
*/
const gfloat prem_rite_settin_vs_deux_rite_settin =
prem_rite_settin_squared < deux_rite_settin_squared
? prem_rite_settin
: deux_rite_settin;
/*
* Computation of the YAFR slopes.
*/
/*
* "up":
*/
const gfloat slope_horizo_left___up =
prem___up_horizo_times_deux___up_horizo < 0.f
? 0.f
: prem___up_horizo_vs_deux___up_horizo;
const gfloat slope_horizo_rite___up =
deux___up_horizo_times_troi___up_horizo < 0.f
? 0.f
: deux___up_horizo_vs_troi___up_horizo;
/*
* "down":
*/
const gfloat slope_horizo_left_down =
prem_down_horizo_times_deux_down_horizo < 0.f
? 0.f
: prem_down_horizo_vs_deux_down_horizo;
const gfloat slope_horizo_rite_down =
deux_down_horizo_times_troi_down_horizo < 0.f
? 0.f
: deux_down_horizo_vs_troi_down_horizo;
/*
* "left":
*/
const gfloat slope_vertic_left___up =
prem_left_vertic_times_deux_left_vertic < 0.f
? 0.f
: prem_left_vertic_vs_deux_left_vertic;
const gfloat slope_vertic_left_down =
deux_left_vertic_times_troi_left_vertic < 0.f
? 0.f
: deux_left_vertic_vs_troi_left_vertic;
/*
* "down":
*/
const gfloat slope_vertic_rite___up =
prem_rite_vertic_times_deux_rite_vertic < 0.f
? 0.f
: prem_rite_vertic_vs_deux_rite_vertic;
const gfloat slope_vertic_rite_down =
deux_rite_vertic_times_troi_rite_vertic < 0.f
? 0.f
: deux_rite_vertic_vs_troi_rite_vertic;
/*
* "left rising":
*/
const gfloat slope_rising_left___up =
prem_left_rising_times_deux_left_rising < 0.f
? 0.f
: prem_left_rising_vs_deux_left_rising;
/*
* "middle rising":
*/
const gfloat slope_rising_left_down =
prem_midl_rising_times_deux_midl_rising < 0.f
? 0.f
: prem_midl_rising_vs_deux_midl_rising;
const gfloat slope_rising_rite___up =
deux_midl_rising_times_troi_midl_rising < 0.f
? 0.f
: deux_midl_rising_vs_troi_midl_rising;
/*
* "right rising":
*/
const gfloat slope_rising_rite_down =
prem_rite_rising_times_deux_rite_rising < 0.f
? 0.f
: prem_rite_rising_vs_deux_rite_rising;
/*
* "left setting":
*/
const gfloat slope_settin_left_down =
prem_left_settin_times_deux_left_settin < 0.f
? 0.f
: prem_left_settin_vs_deux_left_settin;
/*
* "middle setting":
*/
const gfloat slope_settin_left___up =
prem_midl_settin_times_deux_midl_settin < 0.f
? 0.f
: prem_midl_settin_vs_deux_midl_settin;
const gfloat slope_settin_rite_down =
deux_midl_settin_times_troi_midl_settin < 0.f
? 0.f
: deux_midl_settin_vs_troi_midl_settin;
/*
* "right setting":
*/
const gfloat slope_settin_rite___up =
prem_rite_settin_times_deux_rite_settin < 0.f
? 0.f
: prem_rite_settin_vs_deux_rite_settin;
/*
* Assemble the unweighted YAFR correction:
*/
const gfloat unweighted_yafr_correction =
c_horizo_left___up * slope_horizo_left___up
+
c_horizo_left_down * slope_horizo_left_down
+
c_horizo_rite___up * slope_horizo_rite___up
+
c_horizo_rite_down * slope_horizo_rite_down
+
c_vertic_left___up * slope_vertic_left___up
+
c_vertic_rite___up * slope_vertic_rite___up
+
c_vertic_left_down * slope_vertic_left_down
+
c_vertic_rite_down * slope_vertic_rite_down
+
c_settin_left___up * slope_settin_left___up
+
c_settin_rite___up * slope_settin_rite___up
+
c_settin_left_down * slope_settin_left_down
+
c_settin_rite_down * slope_settin_rite_down
+
c_rising_left___up * slope_rising_left___up
+
c_rising_rite___up * slope_rising_rite___up
+
c_rising_left_down * slope_rising_left_down
+
c_rising_rite_down * slope_rising_rite_down;
/*
* Add the bilinear baseline and the weighted YAFR correction:
*/
const gfloat newval = sharpening * unweighted_yafr_correction + bilinear;
*out = newval;
}
static void
vips_interpolate_yafrnohalo_interpolate( VipsInterpolate *interpolate,
PEL *out, REGION *in, double x, double y )
{
VipsInterpolateYafrnohalo *yafrnohalo =
VIPS_INTERPOLATE_YAFRNOHALO( interpolate );
/*
* Note: The computation is structured to foster software
* pipelining.
*/
/*
* x is understood to increase from left to right, y, from top to
* bottom. Consequently, ix and iy are the indices of the pixel
* located at or to the left, and at or above. the sampling point.
*
* floor is used to make sure that the transition through 0 is
* smooth. If it is known that negative x and y will never be used,
* cast (which truncates) could be used instead.
*/
const gint ix = FLOOR (x);
const gint iy = FLOOR (y);
/*
* Each (channel's) output pixel value is obtained by combining four
* "pieces," each piece corresponding to the set of points which are
* closest to the four pixels closest to the (x,y) position, pixel
* positions which have coordinates and labels as follows:
*
* (ix,iy) (ix+1,iy)
* =left__up =rite__up
*
* <- (x,y) is somewhere in the convex hull
*
* (ix,iy+1) (ix+1,iy+1)
* =left_dow =rite_dow
*/
/*
* rite_width is the width of the overlaps of the unit averaging box
* (which is centered at the position where an interpolated value is
* desired), with the closest unit pixel areas to the right.
*
* left_width is the width of the overlaps of the unit averaging box
* (which is centered at the position where an interpolated value is
* desired), with the closest unit pixel areas to the left.
*/
const gfloat rite_width = x - ix;
const gfloat down_hight = y - iy;
const gfloat left_width = 1.f - rite_width;
const gfloat up___hight = 1.f - down_hight;
const gfloat rite_width_minus_half = rite_width - .5f;
const gfloat down_hight_minus_half = down_hight - .5f;
const gfloat left_width_minus_half = left_width - .5f;
const gfloat up___hight_minus_half = up___hight - .5f;
const gfloat rite_rite_overlap =
rite_width_minus_half < 0.f ? 0.f : rite_width_minus_half;
const gfloat down_down_overlap =
down_hight_minus_half < 0.f ? 0.f : down_hight_minus_half;
/*
* Note that if rite_width_minus_half is (non)negative,
* left_width_minus_half is (non)positive. Consequently, the
* following two branching tests could be merged with the above two.
* The duplications are kept in the hope that the compiler translate
* them into "max" machine instructions:
*/
const gfloat left_left_overlap =
left_width_minus_half < 0.f ? 0.f : left_width_minus_half;
const gfloat up_____up_overlap =
up___hight_minus_half < 0.f ? 0.f : up___hight_minus_half;
/*
* The computation of quantities useful for the YAFR correction
* resumes after the computation of the needed bilinear baseline
* weights.
*/
/*
* Bilinear (the plain vanilla standard bilinear) weights:
*/
const gfloat left_width_times___up_hight = left_width * up___hight;
const gfloat rite_width_times___up_hight = rite_width * up___hight;
const gfloat left_width_times_down_hight = left_width * down_hight;
const gfloat rite_width_times_down_hight = rite_width * down_hight;
/*
* Back to quantities useful for the YAFR correction:
*/
/*
* Remaining overlap lengths:
*/
const gfloat rite_left_overlap = left_width - left_left_overlap;
const gfloat left_rite_overlap = rite_width - rite_rite_overlap;
const gfloat down___up_overlap = up___hight - up_____up_overlap;
const gfloat up___down_overlap = down_hight - down_down_overlap;
const gfloat one_minus_left_left_overlap = 1.f - left_left_overlap;
const gfloat one_minus_rite_rite_overlap = 1.f - rite_rite_overlap;
const gfloat one_minus_up_____up_overlap = 1.f - up_____up_overlap;
const gfloat one_minus_down_down_overlap = 1.f - down_down_overlap;
const gfloat one_minus_rite_left_overlap = 1.f - rite_left_overlap;
const gfloat one_minus_left_rite_overlap = 1.f - left_rite_overlap;
const gfloat one_minus_down___up_overlap = 1.f - down___up_overlap;
const gfloat one_minus_up___down_overlap = 1.f - up___down_overlap;
/*
* Recyclable products:
*/
const gfloat left_left_overlap_times_left_left_overlap =
left_left_overlap * left_left_overlap;
const gfloat rite_rite_overlap_times_rite_rite_overlap =
rite_rite_overlap * rite_rite_overlap;
const gfloat up_____up_overlap_times_up_____up_overlap =
up_____up_overlap * up_____up_overlap;
const gfloat down_down_overlap_times_down_down_overlap =
down_down_overlap * down_down_overlap;
const gfloat rite_left_overlap_times_one_minus_rite_left_overlap =
rite_left_overlap * one_minus_rite_left_overlap;
const gfloat left_rite_overlap_times_one_minus_left_rite_overlap =
left_rite_overlap * one_minus_left_rite_overlap;
const gfloat down___up_overlap_times_one_minus_down___up_overlap =
down___up_overlap * one_minus_down___up_overlap;
const gfloat up___down_overlap_times_one_minus_up___down_overlap =
up___down_overlap * one_minus_up___down_overlap;
/*
* "Cardinal" contributions of the various YAFR slopes. Each of the
* (up to) four contributing pixels contributes four slopes: one
* horizontal slope, one vertical slope, and two diagonal slopes
* (one "rising", and one "setting"). Consequently, sixteen
* "cardinal" basis contributions need to be computed.
*/
/*
* "Cardinal" contributions of the horizontal and vertical slopes:
*/
/*
* Common factors:
*/
const gfloat horizo___up =
up_____up_overlap /* height of the overlap */
*
one_minus_up_____up_overlap /* bilinear coefficient */
+ /* second interpolated value */
down___up_overlap /* height of the overlap */
*
down___up_overlap; /* bilinear coefficient */
const gfloat horizo_down =
down_down_overlap /* height of the overlap */
*
one_minus_down_down_overlap /* bilinear coefficient */
+ /* second interpolated value */
up___down_overlap /* height of the overlap */
*
up___down_overlap; /* bilinear coefficient */
const gfloat horizo_left =
rite_left_overlap_times_one_minus_rite_left_overlap
-
left_left_overlap_times_left_left_overlap;
const gfloat horizo_rite =
rite_rite_overlap_times_rite_rite_overlap
-
left_rite_overlap_times_one_minus_left_rite_overlap;
const gfloat vertic_left =
left_left_overlap
*
one_minus_left_left_overlap
+
rite_left_overlap
*
rite_left_overlap;
const gfloat vertic_rite =
rite_rite_overlap
*
one_minus_rite_rite_overlap
+
left_rite_overlap
*
left_rite_overlap;
const gfloat vertic___up =
down___up_overlap_times_one_minus_down___up_overlap
-
up_____up_overlap_times_up_____up_overlap;
const gfloat vertic_down =
down_down_overlap_times_down_down_overlap
-
up___down_overlap_times_one_minus_up___down_overlap;
/*
* "Cardinal" contribution of the left horizontal slopes:
*/
const gfloat c_horizo_left___up = horizo_left * horizo___up;
const gfloat c_horizo_left_down = horizo_left * horizo_down;
/*
* "Cardinal" contribution of the right horizontal slopes:
*/
const gfloat c_horizo_rite___up = horizo_rite * horizo___up;
const gfloat c_horizo_rite_down = horizo_rite * horizo_down;
/*
* "Cardinal" contribution of the up vertical slopes:
*/
const gfloat c_vertic_left___up = vertic___up * vertic_left;
const gfloat c_vertic_rite___up = vertic___up * vertic_rite;
/*
* "Cardinal" contribution of the down vertical slopes:
*/
const gfloat c_vertic_left_down = vertic_down * vertic_left;
const gfloat c_vertic_rite_down = vertic_down * vertic_rite;
/*
* "Cardinal" contributions of the diagonal slopes:
*/
const gfloat c_settin_left___up =
rite_left_overlap_times_one_minus_rite_left_overlap
*
down___up_overlap_times_one_minus_down___up_overlap
-
left_left_overlap_times_left_left_overlap
*
up_____up_overlap_times_up_____up_overlap;
const gfloat c_settin_rite___up =
rite_rite_overlap_times_rite_rite_overlap
*
down___up_overlap_times_one_minus_down___up_overlap
-
left_rite_overlap_times_one_minus_left_rite_overlap
*
up_____up_overlap_times_up_____up_overlap;
const gfloat c_settin_left_down =
rite_left_overlap_times_one_minus_rite_left_overlap
*
down_down_overlap_times_down_down_overlap
-
left_left_overlap_times_left_left_overlap
*
up___down_overlap_times_one_minus_up___down_overlap;
const gfloat c_settin_rite_down =
rite_rite_overlap_times_rite_rite_overlap
*
down_down_overlap_times_down_down_overlap
-
left_rite_overlap_times_one_minus_left_rite_overlap
*
up___down_overlap_times_one_minus_up___down_overlap;
const gfloat c_rising_left___up =
rite_left_overlap_times_one_minus_rite_left_overlap
*
up_____up_overlap_times_up_____up_overlap
-
left_left_overlap_times_left_left_overlap
*
down___up_overlap_times_one_minus_down___up_overlap;
const gfloat c_rising_rite___up =
rite_rite_overlap_times_rite_rite_overlap
*
up_____up_overlap_times_up_____up_overlap
-
left_rite_overlap_times_one_minus_left_rite_overlap
*
down___up_overlap_times_one_minus_down___up_overlap;
const gfloat c_rising_left_down =
rite_left_overlap_times_one_minus_rite_left_overlap
*
up___down_overlap_times_one_minus_up___down_overlap
-
left_left_overlap_times_left_left_overlap
*
down_down_overlap_times_down_down_overlap;
const gfloat c_rising_rite_down =
rite_rite_overlap_times_rite_rite_overlap
*
up___down_overlap_times_one_minus_up___down_overlap
-
left_rite_overlap_times_one_minus_left_rite_overlap
*
down_down_overlap_times_down_down_overlap;
/*
* Set the tile pointer to the first relevant value. Since the
* pointer initially points to dos_two, we need to rewind it one
* tile row, then go back one additional pixel.
*/
const PEL *p = (PEL *) IM_REGION_ADDR( in, ix - 1, iy - 1 );
/* Pel size and line size.
*/
const int channels = in->im->Bands;
const int pixels_per_buffer_row =
IM_REGION_LSKIP( in ) / (sizeof( float ) * channels);
/* Where we write the result.
*/
int z;
for( z = 0; z < channels; z++ )
bilinear_yafrnohalo ((float *) out + z, (float *) p + z,
channels, pixels_per_buffer_row,
yafrnohalo->sharpening,
c_horizo_left___up,
c_horizo_left_down,
c_horizo_rite___up,
c_horizo_rite_down,
c_vertic_left___up,
c_vertic_rite___up,
c_vertic_left_down,
c_vertic_rite_down,
c_settin_left___up,
c_settin_rite___up,
c_settin_left_down,
c_settin_rite_down,
c_rising_left___up,
c_rising_rite___up,
c_rising_left_down,
c_rising_rite_down,
left_width_times___up_hight,
rite_width_times___up_hight,
left_width_times_down_hight,
rite_width_times_down_hight);
}
static void
vips_interpolate_yafrnohalo_class_init( VipsInterpolateYafrnohaloClass *class )
{
VipsObjectClass *object_class = VIPS_OBJECT_CLASS( class );
VipsInterpolateClass *interpolate_class =
VIPS_INTERPOLATE_CLASS( class );
object_class->nickname = "yafrnohalo";
object_class->description = _( "YAFR nohalo interpolation" );
interpolate_class->interpolate =
vips_interpolate_yafrnohalo_interpolate;
interpolate_class->window_size = 4;
}
static void
vips_interpolate_yafrnohalo_init( VipsInterpolateYafrnohalo *yafrnohalo )
{
#ifdef DEBUG
printf( "vips_interpolate_yafrnohalo_init: " );
vips_object_print( VIPS_OBJECT( yafrnohalo ) );
#endif /*DEBUG*/
yafrnohalo->sharpening = 1.0;
}
Reference in New Issue View Git Blame Copy Permalink