Am 01.03.21 um 14:10 schrieb Monkey:
> > and it's use of image pyramids relies on a variant of image pyramids
> based on b-splines.
>
> > To me, the implementation of the Burt/Adelson Algorithm is a
> major breakthrough.
>
> Is there a simple way to explain how this/these differ from a standard
> Laplacian pyramid?
My code uses a different pyramid generation scheme for the gaussian
pyramids. The laplacian pyramids are not made explicit but calculated
on-the-fly by functor composition - the result is the same, the
difference between a scaled-up 'top' level and the unmodified 'bottom
level' at every stage - but the process is less memory-hungry and uses
vspline's fast multithreaded SIMD code to do the operation in one go.
Standard gaussian pyramids have a set of samples at each level. To get
the next smaller level ('reduce' stage), a digital low-pass filter is
applied - usually a small-kernel FIR filter - and the result is
decimated, discarding every other sample. Everything works along the
initial sampling grid, every pyramid stage is precisely half as large as
the previous. The 'expand' stage uses the same FIR filter for upscaling
from a grid filled with zeros where only every other sample is filled in
from the 'top' level.
My pyramid technique has a b-spline at each level. This is a continuous
function, and low-pass-filtering is done by modifications of the
b-spline evaluation function; the resulting (continuous) low-pass signal
can then be sampled at arbitrary positions. This method is grid-free:
you can choose decimation steps different from two, and you're free to
place the samples which the smaller-level spline is built from in
off-grid positions. I use this in pv to get a set of splines which have
the same boundary behavior, so by slotting in a simple shift+scale, I
can evaluate them with the same coordinates at every level, which
simplifies the code a great deal. The 'expand' stage of the pyramid uses
simple b-spline evaluation, which is good for upscaling a signal.
pv offers the parameter 'pyramid_scaling_step' which allows you to build
'steeper' or 'shallower' pyramids scaling each level with an arbitrary
real factor - 2.0 by default, but sensible values go down to, say, 1.1.
you can simply try it out and see if it makes any difference - the
effect is subtle and hard to spot unless you know what to look for, if
you're interested I can say more about it.
Employing my spline-based pyramid technique to implement an equivalent
of the 'classic' Burt and Adelson (B&A) approach is experimental, but
with the latest pv commits I provide a working implementation so it can
be evaluated and experimented with, to see where it's advantages and
disadvantages are, and to figure out where my initial choices in
mimicking the B&A algorithm can be improved. It may well turn out to be
inferior to the classic approach - the intention in pv is to produce
'decent' stitches and expoure fusions for the currently displayed view -
if I can get the quality up to a level which approaches the standard
technique, this would be great, but I'm not making such claims yet.
To sum it up: The main difference to 'classic' pyramids and B&A in the
current pv code is the off-grid evaluation for up- and downsampling,
arbitrary scaling factor from one pyramid level to the next, use of a
small binomial FIR filter (.25, .5, .25) for low-pass filtering, and use
of b-spline evaluation for upsampling.
I hope this answers your question - the B&A algorithm and image pyramids
are quite involved stuff, and it's hard to explain the differences
'simply' because the algorithm in itself is not simple.
Kay
--
A list of frequently asked questions is available at:
http://wiki.panotools.org/Hugin_FAQ
---
You received this message because you are subscribed to the Google Groups "hugin and other free panoramic software" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To view this discussion on the web visit
https://groups.google.com/d/msgid/hugin-ptx/4aa29bee-1563-3ea0-4080-5d091a838e4a%40yahoo.com.
