       Efficient arbitrary resampling of an array

• To: mathgroup at smc.vnet.net
• Subject: [mg69667] Efficient arbitrary resampling of an array
• From: Gareth Russell <russell at njit.edu>
• Date: Wed, 20 Sep 2006 02:44:26 -0400 (EDT)
• Organization: New Jersey Institute of Technology

```Hi Group,

Does anyone know how to efficiently run a kernel over an array, but
where the kernel is centered arbitrarily instead of exactly on original
array elements, and may be of 'non-integer' size?

Here's the background/explanation:

I need to downsample a 2D array of reals -- an operation similar to
reducing the resolution of a grayscale image. The array represents
values from a grid of squares. There are two catches. The first is that
the grid represented by the original array, and the grid represented by
the resampled array, are arbitrarily located relative to one another.
Thus each value (grid cell) in the resampled array not only samples
more than one cell in the original array, but may sample fractions of
various cells. The other catch is that the resampled cells should be
accurate weighted means of the original cells that they cover, where
the weights are the proportion of each cell in the resampling area.
That prevents me using ListInterpolation (which would be easy, and what
is often done in image processing).

The problem is how to do this efficiently. In my application, the
original array might have dimensions of, say, 3000 by 3000, and the
resampled array perhaps 200 by 200. So there would be 40,000 new array
values, each of which has to be calculated from approximately 225 of
the original values (depending on how each new grid cell lies over the
old grid cells).

The inputs to the function would be

resample[array_, arrayCorners_, newArrayCorners_, newArrayResolution_]

where arrayCorners is a 2 x 2 list giving the {x,y} coordinates of the
lower left and upper right of the original grid, newArrayCorners is the
same but for the new resampled grid, and newArrayResolution is a
two-element list giving the number of cells in the x and y direction in
the new grid. The output would be a new array with dimensions
{newArrayResolution[], newArrayResolution[]}. As mentioned above,
the kernel should be calculating a weighted mean.

A lot of this is bookkeeping, and I can do that, but I'm having trouble
creating a fast version of the core routine, which is the 'kernel
problem' above. Any help would be appreciated. I'll compile a list of
any suggestions and test them all on the same machine for a speed
comparison...

Gareth Russell
Rutgers/NJIT

```

• Prev by Date: Re: an equation containg radicals
• Next by Date: Re: an equation containg radicals