sergiotarxz
/
libvips
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

remove LBB options

This commit is contained in:
Nicolas Robidoux 2011-11-22 10:42:39 -05:00
parent c0150ea3c3
commit b6dd1e0af1
1 changed files with 40 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

121
libvips/resample/lbb.cpp
View File

@ -3,6 +3,8 @@
* N. Robidoux, C. Racette and J. Cupitt, 23-28/03/2010 * N. Robidoux, C. Racette and J. Cupitt, 23-28/03/2010
* *
* N. Robidoux, 16-19/05/2010 * N. Robidoux, 16-19/05/2010
*
* N. Robidoux, 22/11/2011
*/ */
/* /*
@ -35,40 +37,18 @@
/* /*
* 2010 (c) Nicolas Robidoux, Chantal Racette, John Cupitt. * 2010 (c) Nicolas Robidoux, Chantal Racette, John Cupitt.
* *
* Nicolas Robidoux thanks Adam Turcotte, Geert Jordaens, Ralf Meyer, * N. Robidoux thanks Adam Turcotte, Geert Jordaens, Ralf Meyer,
* Øyvind Kolås, Minglun Gong, Eric Daoust and Sven Neumann for useful * Øyvind Kolås, Minglun Gong, Eric Daoust and Sven Neumann for useful
* comments and code. * comments and code.
* *
* Chantal Racette's image resampling research and programming funded * C. Racette's image resampling research and programming funded in
* in part by a NSERC Discovery Grant awarded to Julien Dompierre * part by an NSERC (National Science and Engineering Research Council
* (20-61098). * of Canada) Alexander Graham Bell Canada Graduate Scholarship, by an
* NSERC Discovery Grant awarded to Julien Dompierre (grant number
* 20-61098) and by N. Robidoux's Laurentian University professional
* allowance.
*/ */
/*
* LBB has two versions:
*
* A "soft" version, which shows a little less staircasing and a
* little more haloing, and which is a little more expensive to
* compute. We recommend this as the default.
*
* A "sharp" version, which shows a little more staircasing and a
* little less haloing, which is a little cheaper (it uses 6 less
* comparisons and 12 less "? :"), and which appears to lead to less
* "zebra striping" when two diagonal interfaces are close to each
* other.
*
* The only difference between the two is that the "soft" versions
* uses local minima and maxima computed over 3x3 square blocks, and
* the "sharp" version uses local minima and maxima computed over 3x3
* crosses.
*
* If you want to use the "soft" (more expensive) version, comment out
* the following three pre-processor code lines:
*/
#ifndef __LBB_CHEAP_H__
#define __LBB_CHEAP_H__
#endif
/* /*
* LBB (Locally Bounded Bicubic) is a high quality nonlinear variant * LBB (Locally Bounded Bicubic) is a high quality nonlinear variant
* of Catmull-Rom. Images resampled with LBB have much smaller halos * of Catmull-Rom. Images resampled with LBB have much smaller halos
@ -83,14 +63,16 @@
* final clamping is needed to stay "in range" (e.g., 0-255 for * final clamping is needed to stay "in range" (e.g., 0-255 for
* standard 8-bit images). * standard 8-bit images).
* *
* LBB was developed by Nicolas Robidoux and Chantal Racette of the * LBB was developed by N. Robidoux and C. Racette at the Department
* Department of Mathematics and Computer Science of Laurentian * of Mathematics and Computer Science of Laurentian University in the
* University in the course of C. Racette's Masters thesis in * course of C. Racette's Masters thesis in Computational
* Computational Sciences. Preliminary work directly leading to the * Sciences. Preliminary work directly leading to the LBB method and
* LBB method and code was performed by C. Racette and N. Robidoux in * code was performed by C. Racette and N. Robidoux in the course of
* the course of her honours thesis, and by N. Robidoux, A. Turcotte * her honours thesis, and by N. Robidoux, A. Turcotte and E. Daoust
* and E. Daoust during Google Summer of Code 2009 (through two awards * during Google Summer of Code 2009 (through two awards made to GIMP
* made to GIMP to improve GEGL). * to improve GEGL). The final version of LBB was formulated in
* October 2011 by N. Robidoux based on insight gained while reviewing
* C. Racette's masters thesis.
* *
* LBB is a novel method with the following properties: * LBB is a novel method with the following properties:
* *
@ -145,6 +127,9 @@
* *
* The above paragraph described the "soft" version of LBB. The * The above paragraph described the "soft" version of LBB. The
* "sharp" version is similar. * "sharp" version is similar.
*
* A slightly different preliminary version of LBB is documented in
* C. Racette's masters thesis.
*/ */
#ifdef HAVE_CONFIG_H #ifdef HAVE_CONFIG_H
@ -186,11 +171,14 @@ typedef struct _VipsInterpolateLbbClass {
} VipsInterpolateLbbClass; } VipsInterpolateLbbClass;
/*
* Absolute value and sign macros:
*/
#define LBB_ABS(x) ( ((x)>=0.) ? (x) : -(x) ) #define LBB_ABS(x) ( ((x)>=0.) ? (x) : -(x) )
#define LBB_SIGN(x) ( ((x)>=0.) ? 1.0 : -1.0 ) #define LBB_SIGN(x) ( ((x)>=0.) ? 1.0 : -1.0 )
/* /*
* MIN and MAX macros set up so that I can put the likely winner in * MIN and MAX macros set up so that I can put the likely winner in
* the first argument (forward branch likely blah blah blah): * the first argument (forward branch likely):
*/ */
#define LBB_MIN(x,y) ( ((x)<=(y)) ? (x) : (y) ) #define LBB_MIN(x,y) ( ((x)<=(y)) ? (x) : (y) )
#define LBB_MAX(x,y) ( ((x)>=(y)) ? (x) : (y) ) #define LBB_MAX(x,y) ( ((x)>=(y)) ? (x) : (y) )
@ -250,49 +238,21 @@ lbbicubic( const double c00,
* where ix is the (pseudo-)floor of the requested left-to-right * where ix is the (pseudo-)floor of the requested left-to-right
* location ("X"), and iy is the floor of the requested up-to-down * location ("X"), and iy is the floor of the requested up-to-down
* location. * location.
*
* Below, "00", "10", "01" and "11" refer to the index "shifts" from
* the (ix,iy) position. That is,
*
* "00" refers to the dos_two position,
* "10" refers to the dos_thr position,
* "01" refers to the tre_two position, and
* "11" refers to the tre_thr position.
*/ */
#if defined (__LBB_CHEAP_H__)
/* /*
* Computation of the four min and four max over 3x3 input data * Computation of the four pairs of horizontal min and max and four
* sub-crosses of the 4x4 input stencil, performed with only 22 * pairs of vertical min and max over aligned groups of three input
* comparisons and 28 "? :". If you can figure out how to do this * pixel values, and four pairs of min and max over 3x3 input data
* more efficiently, let us know. * sub-blocks of the 4x4 input stencil:
*/
const double m1 = (dos_two <= dos_thr) ? dos_two : dos_thr ;
const double M1 = (dos_two <= dos_thr) ? dos_thr : dos_two ;
const double m2 = (tre_two <= tre_thr) ? tre_two : tre_thr ;
const double M2 = (tre_two <= tre_thr) ? tre_thr : tre_two ;
const double m3 = (uno_two <= dos_one) ? uno_two : dos_one ;
const double M3 = (uno_two <= dos_one) ? dos_one : uno_two ;
const double m4 = (uno_thr <= dos_fou) ? uno_thr : dos_fou ;
const double M4 = (uno_thr <= dos_fou) ? dos_fou : uno_thr ;
const double m5 = (tre_one <= qua_two) ? tre_one : qua_two ;
const double M5 = (tre_one <= qua_two) ? qua_two : tre_one ;
const double m6 = (tre_fou <= qua_thr) ? tre_fou : qua_thr ;
const double M6 = (tre_fou <= qua_thr) ? qua_thr : tre_fou ;
const double m7 = LBB_MIN( m1, tre_two );
const double M7 = LBB_MAX( M1, tre_two );
const double m8 = LBB_MIN( m1, tre_thr );
const double M8 = LBB_MAX( M1, tre_thr );
const double m9 = LBB_MIN( m2, dos_two );
const double M9 = LBB_MAX( M2, dos_two );
const double m10 = LBB_MIN( m2, dos_thr );
const double M10 = LBB_MAX( M2, dos_thr );
const double min00 = LBB_MIN( m7, m3 );
const double max00 = LBB_MAX( M7, M3 );
const double min10 = LBB_MIN( m8, m4 );
const double max10 = LBB_MAX( M8, M4 );
const double min01 = LBB_MIN( m9, m5 );
const double max01 = LBB_MAX( M9, M5 );
const double min11 = LBB_MIN( m10, m6 );
const double max11 = LBB_MAX( M10, M6 );
#else
/*
* Computation of the four min and four max over 3x3 input data
* sub-blocks of the 4x4 input stencil, performed with only 28
* comparisons and 34 "? :". If you can figure how to do this more
* efficiently, let us know.
*/ */
const double m1 = (dos_two <= dos_thr) ? dos_two : dos_thr ; const double m1 = (dos_two <= dos_thr) ? dos_two : dos_thr ;
const double M1 = (dos_two <= dos_thr) ? dos_thr : dos_two ; const double M1 = (dos_two <= dos_thr) ? dos_thr : dos_two ;
@ -328,7 +288,6 @@ lbbicubic( const double c00,
const double max01 = LBB_MAX( M9, M11 ); const double max01 = LBB_MAX( M9, M11 );
const double min11 = LBB_MIN( m9, m13 ); const double min11 = LBB_MIN( m9, m13 );
const double max11 = LBB_MAX( M9, M13 ); const double max11 = LBB_MAX( M9, M13 );
#endif
/* /*
* The remainder of the "per channel" computation involves the * The remainder of the "per channel" computation involves the
@ -849,8 +808,8 @@ vips_interpolate_lbb_class_init( VipsInterpolateLbbClass *klass )
object_class->nickname = "lbb"; object_class->nickname = "lbb";
object_class->description = _( "Reduced halo bicubic" ); object_class->description = _( "Reduced halo bicubic" );
interpolate_class->interpolate = vips_interpolate_lbb_interpolate; interpolate_class->interpolate = vips_interpolate_lbb_interpolate;
interpolate_class->window_size = 4; interpolate_class->window_size = 4;
} }
static void static void