Hello

I've noticed that several programs such as Google's Picassa provide a very
impressive smooth zoom and pan which is highly responsive and maintains good
quality even with very large images.

Does anyone have any idea about the technology behind this? Is this done
with a simple filter running on the CPU or is it likely that the programs
are addressing my GPU directly. Can anyone point me to any sample source
code that might do a comparable pan and zoom?

Many thanks for any help

Pete

Pete wrote:


The technique I now, is using tiled image pyramids.

The image is low-pass filtered into several pyramid levels and each is
tiled into smaller tiles (e.g. 256x256). When a certain part of
the image is requested in a certain resolution tiles become loaded
on-demand. Thereby those viewers usually can show any-sized images.
The TIFF image format is widely used to store image pyramids
(although limited to 4GB), most pixel-suites have their own
working format.

"Frank Mertens" <frank at (no spam) cyblogic.de> wrote in message
news:g02qf4$77u$1 at (no spam) cb.generation-online.de...
Pete wrote:

The technique I now, is using tiled image pyramids.

The image is low-pass filtered into several pyramid levels and each is
tiled into smaller tiles (e.g. 256x256). When a certain part of
the image is requested in a certain resolution tiles become loaded
on-demand. Thereby those viewers usually can show any-sized images.
The TIFF image format is widely used to store image pyramids
(although limited to 4GB), most pixel-suites have their own
working format.


Thanks.

Yes, that sounds sensible. But for a really smooth zoom you need to include
lots of intermediate resolutions (ie not just 2x,4x etc).
Do you think those intermediate resolutions are scaled down from the nearest
half-resolution greater than the required resolution - or is there a nice
(ie quick) way to combine the two resolutions that bound the required
resolution?

Thanks again
Pete

I've noticed that several programs such as Google's Picassa provide a very
impressive smooth zoom and pan which is highly responsive and maintains good
quality even with very large images.

Yes, that sounds sensible. But for a really smooth zoom you need to include
lots of intermediate resolutions (ie not just 2x,4x etc).
Do you think those intermediate resolutions are scaled down from the nearest
half-resolution greater than the required resolution - or is there a nice
(ie quick) way to combine the two resolutions that bound the required
resolution?

I've noticed that several programs such as Google's Picassa provide a
very
impressive smooth zoom and pan which is highly responsive and maintains
good
quality even with very large images.

I too have been trying to implement something similar and have been
using the programming language IDL. As far as various image formats
go, I have come to the conclusion that the JPEG2000 format has the
best features that are needed.
* It can save multiple layers of information,
* enables you to read small portions out of it and
* even supports geographic information.

The IDL sample codes even have an application that make use of pyramid
of images and zoom and pan quite fluidly.

Hope this helps in someway.

"Jeff" <someone at (no spam) somewhere.com> writes:

Yes, that sounds sensible. But for a really smooth zoom you need to
include
lots of intermediate resolutions (ie not just 2x,4x etc).
Do you think those intermediate resolutions are scaled down from the
nearest
half-resolution greater than the required resolution - or is there a nice
(ie quick) way to combine the two resolutions that bound the required
resolution?

It's pretty common in computer graphics to use a pyramid of resolutions
for a texture, each level having half the resolution of the level above.
This takes only 4/3 as much space as a single maximum-resolution image.

When applying the texture, just linearly interpolate between the two
nearest texture resolutions.

On the other hand, modern graphics cards with programmable shaders have
enormous computational power - tens or hundreds of times as much as the
main CPU. Resampling an existing 2D image to a new size and position is
actually a pretty simple operation, easily distributed among all the
shaders available on the card. My home computer's graphics card has 96
stream (shader) processors; the one at work has 128. That's a lot of
parallellism that can be put to work on resampling.

The programs you mention may be completely recalculating the
displayed image every frame. With the power to do that, it's trivial
to use a new scale factor and center point location every frame, giving
perfectly smooth panning and zooming.