Legacy ImageMagick Discussions Archive

magick wrote:Thanks for the continuity advice. I use alpha / beta / gamma as temporary variables. In many cases I had already used alpha / beta so that left gamma for dealing with transparency.

fmw42 wrote:Sorry to stick my nose in here. I don't want to make a lot of work for you here, but just wondering if this is limited to catmull-rom or can be done for the whole cubic family with B,C control. Would each B,C combination need separate optimization code?

Fred

NicolasRobidoux wrote:magick: My suggested fixes of

Code: Select all

gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);

do not make the result continuous, because "your" formula has two large jumps: one at MagickEpsilon (which my fixes took care of) and one at -MagickEpsilon (which I did not fix). The jumps are size abs(1/MagickEpsilon) - 1, that is, really big.

Gist: Clamp alpha to its natural range (which I assume is [0,1], although I understand that it may make sense to use a range related to the Quantum) in whatever computation you do, and if you use its reciprocal, clamp it to [MagickEpsilon,1]. In this context, this gives, for non-monotone interpolators:

Code: Select all

      /* This gamma is the interpolated alpha. */
      gamma=cy[0]*(cx[0]*alpha[0]+cx[1]*alpha[1]+cx[2]*alpha[2]+
        cx[3]*alpha[3])+cy[1]*(cx[0]*alpha[4]+cx[1]*alpha[5]+
        cx[2]*alpha[6]+cx[3]*alpha[7])+cy[2]*(cx[0]*alpha[8]+
        cx[1]*alpha[9]+cx[2]*alpha[10]+cx[3]*alpha[11])+cy[3]*(
        cx[0]*alpha[12]+cx[1]*alpha[13]+cx[2]*alpha[14]+cx[3]*alpha[15]);
      /* Clamp overshoot */
      gamma=(gamma>(MagickRealType) 1. ? (MagickRealType) 1. : gamma);
      /* Make sure you are not negative or too close to 0 */
      gamma=(gamma<(MagickRealType) MagickEpsilon ? (MagickRealType) MagickEpsilon : gamma);
      /* Take the reciprocal of the interpolated transparency */
      gamma = (MagickRealType) 1./gamma;

The casts are to prevent time wasting conversions to and from float and double (if MagickRealType is float), although those involving MagickEpsilon may be a waste since it would make sense that this global be declared as a MagickRealType (and I realize that modern compilers/chips may be smart enough not to do that).

It is probably over complicated. Whatever it should be, it will be added to a very large number of operators!
from composition though to convolution, morphology, and much more.

Another comment: The fabs is unnecessary in the current code for bilinear because bilinear is a monotone method: gamma can't be negative.

• #define MagickEpsilon ((MagickRealType) 1.0e-16)

static inline MagickRealType MagickReciprocal(const MagickRealType x)
{
  return((MagickRealType) 1.0/(((x) > (MagickRealType) 0.0 ? (x) : -(x)) < MagickEpsilon ? MagickEpsilon : x));
}

NicolasRobidoux wrote:Trying to figure out how to deal with the alpha channel, I am starting to think that the best solution is to only use monotone methods, e.g. bilinear with bilinear, Hermite with Hermite, quadratic B-spline with quadratic B-spline, but cubic B-spline with cubic B-spline, Mitchell and Catmull-Rom.
Overshoots and oscillations should be more deadly when something is used nonlinearly.

NicolasRobidoux wrote:Trying to figure out how to deal with the alpha channel, I am starting to think that the best solution is to only use monotone methods, e.g. bilinear with bilinear, Hermite with Hermite, quadratic B-spline with quadratic B-spline, but cubic B-spline with cubic B-spline, Mitchell and Catmull-Rom.
Overshoots and oscillations should be more deadly when something is used nonlinearly.