def interpolate(vertex_coordinates,
triangles,
vertex_values,
interpolation_points,
mesh_origin=None,
start_blocking_len=500000,
use_cache=False,
verbose=False,
output_centroids=False):
"""Interpolate vertex_values to interpolation points.
Inputs (mandatory):
vertex_coordinates: List of coordinate pairs [xi, eta] of
points constituting a mesh
(or an m x 2 numeric array or
a geospatial object)
Points may appear multiple times
(e.g. if vertices have discontinuities)
triangles: List of 3-tuples (or a numeric array) of
integers representing indices of all vertices
in the mesh.
vertex_values: Vector or array of data at the mesh vertices.
If array, interpolation will be done for each column as
per underlying matrix-matrix multiplication
interpolation_points: Interpolate mesh data to these positions.
List of coordinate pairs [x, y] of
data points or an nx2 numeric array or a
Geospatial_data object
Inputs (optional)
mesh_origin: A geo_reference object or 3-tuples consisting of
UTM zone, easting and northing.
If specified vertex coordinates are assumed to be
relative to their respective origins.
Note: Don't supply a vertex coords as a geospatial
object and a mesh origin, since geospatial has its
own mesh origin.
start_blocking_len: If the # of points is more or greater than this,
start blocking
use_cache: True or False
Output:
Interpolated values at specified point_coordinates
Note: This function is a simple shortcut for case where
interpolation matrix is unnecessary
Note: This function does not take blocking into account,
but allows caching.
"""
# FIXME(Ole): Probably obsolete since I is precomputed and
# interpolate_block caches
from anuga.caching import cache
# Create interpolation object with matrix
args = (ensure_numeric(vertex_coordinates,
num.float), ensure_numeric(triangles))
kwargs = {'mesh_origin': mesh_origin, 'verbose': verbose}
if use_cache is True:
I = cache(Interpolate, args, kwargs, verbose=verbose)
else:
I = Interpolate(*args, **kwargs)
# Call interpolate method with interpolation points
result = I.interpolate_block(vertex_values,
interpolation_points,
use_cache=use_cache,
verbose=verbose,
output_centroids=output_centroids)
return result
def interpolate(vertex_coordinates,
triangles,
vertex_values,
interpolation_points,
mesh_origin=None,
start_blocking_len=500000,
use_cache=False,
verbose=False,
output_centroids=False):
"""Interpolate vertex_values to interpolation points.
Inputs (mandatory):
vertex_coordinates: List of coordinate pairs [xi, eta] of
points constituting a mesh
(or an m x 2 numeric array or
a geospatial object)
Points may appear multiple times
(e.g. if vertices have discontinuities)
triangles: List of 3-tuples (or a numeric array) of
integers representing indices of all vertices
in the mesh.
vertex_values: Vector or array of data at the mesh vertices.
If array, interpolation will be done for each column as
per underlying matrix-matrix multiplication
interpolation_points: Interpolate mesh data to these positions.
List of coordinate pairs [x, y] of
data points or an nx2 numeric array or a
Geospatial_data object
Inputs (optional)
mesh_origin: A geo_reference object or 3-tuples consisting of
UTM zone, easting and northing.
If specified vertex coordinates are assumed to be
relative to their respective origins.
Note: Don't supply a vertex coords as a geospatial
object and a mesh origin, since geospatial has its
own mesh origin.
start_blocking_len: If the # of points is more or greater than this,
start blocking
use_cache: True or False
Output:
Interpolated values at specified point_coordinates
Note: This function is a simple shortcut for case where
interpolation matrix is unnecessary
Note: This function does not take blocking into account,
but allows caching.
"""
# FIXME(Ole): Probably obsolete since I is precomputed and
# interpolate_block caches
from anuga.caching import cache
# Create interpolation object with matrix
args = (ensure_numeric(vertex_coordinates, num.float),
ensure_numeric(triangles))
kwargs = {'mesh_origin': mesh_origin,
'verbose': verbose}
if use_cache is True:
I = cache(Interpolate, args, kwargs, verbose=verbose)
else:
I = apply(Interpolate, args, kwargs)
# Call interpolate method with interpolation points
result = I.interpolate_block(vertex_values, interpolation_points,
use_cache=use_cache,
verbose=verbose,
output_centroids=output_centroids)
return result
def interpolate_block(self,
f,
point_coordinates,
NODATA_value=NAN,
use_cache=False,
verbose=False,
output_centroids=False):
"""
Call this if you want to control the blocking or make sure blocking
doesn't occur.
Return the point data, z.
See interpolate for doc info.
"""
# FIXME (Ole): I reckon we should change the interface so that
# the user can specify the interpolation matrix instead of the
# interpolation points to save time.
if isinstance(point_coordinates, Geospatial_data):
point_coordinates = point_coordinates.get_data_points(
absolute=True)
# Convert lists to numeric arrays if necessary
point_coordinates = ensure_numeric(point_coordinates, num.float)
f = ensure_numeric(f, num.float)
from anuga.caching import myhash
import sys
if use_cache is True:
if sys.platform != 'win32':
# FIXME (Ole): (Why doesn't this work on windoze?)
# Still absolutely fails on Win 24 Oct 2008
X = cache(self._build_interpolation_matrix_A,
args=(point_coordinates, output_centroids),
kwargs={'verbose': verbose},
verbose=verbose)
else:
# FIXME
# Hash point_coordinates to memory location, reuse if possible
# This will work on Linux as well if we want to use it there.
key = myhash(point_coordinates)
reuse_A = False
if key in self.interpolation_matrices:
X, stored_points = self.interpolation_matrices[key]
if num.alltrue(stored_points == point_coordinates):
reuse_A = True # Reuse interpolation matrix
if reuse_A is False:
X = self._build_interpolation_matrix_A(point_coordinates,
output_centroids,
verbose=verbose)
self.interpolation_matrices[key] = (X, point_coordinates)
else:
X = self._build_interpolation_matrix_A(point_coordinates,
output_centroids,
verbose=verbose)
# Unpack result
self._A, self.inside_poly_indices, self.outside_poly_indices, self.centroids = X
# Check that input dimensions are compatible
msg = 'Two columns must be specified in point coordinates. ' \
'I got shape=%s' % (str(point_coordinates.shape))
assert point_coordinates.shape[1] == 2, msg
msg = 'The number of rows in matrix A must be the same as the '
msg += 'number of points supplied.'
msg += ' I got %d points and %d matrix rows.' \
% (point_coordinates.shape[0], self._A.shape[0])
assert point_coordinates.shape[0] == self._A.shape[0], msg
msg = 'The number of columns in matrix A must be the same as the '
msg += 'number of mesh vertices.'
msg += ' I got %d vertices and %d matrix columns.' \
% (f.shape[0], self._A.shape[1])
assert self._A.shape[1] == f.shape[0], msg
# Compute Matrix vector product and return
return self._get_point_data_z(f, NODATA_value=NODATA_value)
def interpolate_block(self, f, point_coordinates, NODATA_value=NAN,
use_cache=False, verbose=False, output_centroids=False):
"""
Call this if you want to control the blocking or make sure blocking
doesn't occur.
Return the point data, z.
See interpolate for doc info.
"""
# FIXME (Ole): I reckon we should change the interface so that
# the user can specify the interpolation matrix instead of the
# interpolation points to save time.
if isinstance(point_coordinates, Geospatial_data):
point_coordinates = point_coordinates.get_data_points(absolute=True)
# Convert lists to numeric arrays if necessary
point_coordinates = ensure_numeric(point_coordinates, num.float)
f = ensure_numeric(f, num.float)
from anuga.caching import myhash
import sys
if use_cache is True:
if sys.platform != 'win32':
# FIXME (Ole): (Why doesn't this work on windoze?)
# Still absolutely fails on Win 24 Oct 2008
X = cache(self._build_interpolation_matrix_A,
args=(point_coordinates, output_centroids),
kwargs={'verbose': verbose},
verbose=verbose)
else:
# FIXME
# Hash point_coordinates to memory location, reuse if possible
# This will work on Linux as well if we want to use it there.
key = myhash(point_coordinates)
reuse_A = False
if self.interpolation_matrices.has_key(key):
X, stored_points = self.interpolation_matrices[key]
if num.alltrue(stored_points == point_coordinates):
reuse_A = True # Reuse interpolation matrix
if reuse_A is False:
X = self._build_interpolation_matrix_A(point_coordinates,
output_centroids,
verbose=verbose)
self.interpolation_matrices[key] = (X, point_coordinates)
else:
X = self._build_interpolation_matrix_A(point_coordinates, output_centroids,
verbose=verbose)
# Unpack result
self._A, self.inside_poly_indices, self.outside_poly_indices, self.centroids = X
# Check that input dimensions are compatible
msg = 'Two columns must be specified in point coordinates. ' \
'I got shape=%s' % (str(point_coordinates.shape))
assert point_coordinates.shape[1] == 2, msg
msg = 'The number of rows in matrix A must be the same as the '
msg += 'number of points supplied.'
msg += ' I got %d points and %d matrix rows.' \
% (point_coordinates.shape[0], self._A.shape[0])
assert point_coordinates.shape[0] == self._A.shape[0], msg
msg = 'The number of columns in matrix A must be the same as the '
msg += 'number of mesh vertices.'
msg += ' I got %d vertices and %d matrix columns.' \
% (f.shape[0], self._A.shape[1])
assert self._A.shape[1] == f.shape[0], msg
# Compute Matrix vector product and return
return self._get_point_data_z(f, NODATA_value=NODATA_value)
