def clip(source, sink = None, clip_min = None, clip_max = None, clip_norm = None, processes = None, verbose = False):
"""Clip and normalize data.
Arguments
---------
source : array
Input source.
sink : array, dtype or None
output sink or output data type, if None, a new array is allocated.
clip_min : number
Minimal number to clip source data to.
clip_max : number
Maximal number to clip source data to.
clip_norm : number
Normalization constant.
Returns
-------
sink : array
Clipped output.
"""
processes, timer = ap.initialize_processing(verbose=verbose, processes=processes, function='clip');
source, source_buffer = ap.initialize_source(source);
if source.ndim != 3:
raise ValueError('Source assumed to be 3d found %dd!' % source.ndim);
if clip_min is None:
clip_min = ap.io.min_value(source);
if clip_max is None:
clip_max = ap.io.max_value(source);
if clip_norm is None:
clip_norm = clip_max - clip_min;
sink, sink_buffer = ap.initialize_sink(sink = sink, source = source);
code.clip(source_buffer, sink_buffer, clip_min, clip_max, clip_norm, processes);
return sink;
def average(source,
sink=None,
shape=None,
dtype=None,
weights=None,
indices=None,
kernel=None,
return_counts=False,
processes=None,
verbose=False):
"""Averages a list of points into an volumetric image array.
Arguments
---------
source : str, array or Source
Source of point of nxd coordinates.
sink : str, array or None
The sink for the devolved image, if None return array.
shape : tuple, str or None
Shape of the final devolved data. If None, determine from points.
If str, determine shape from the source at the specified location.
dtype : dtype or None
Optional data type of the sink.
weights : array or None
Weight array of length n for each point. If None, use uniform weights.
method : str
Method for voxelization: 'sphere', 'rectangle' or 'pixel'.
indices : array
The relative indices to the center to devolve over as nxd array.
kernel : array
Optional kernel weights for each index in indices.
processes : int or None
Number of processes to use.
verbose : bool
If True, print progress info.
Returns
-------
sink : str, array
Volumetric data of devolved point data.
"""
processes, timer = ap.initialize_processing(processes=processes,
verbose=verbose,
function='devolve')
#points, points_buffer = ap.initialize_source(points);
points_buffer = io.read(source)
if points_buffer.ndim == 1:
points_buffer = points_buffer[:, None]
if sink is None and shape is None:
if points_buffer.ndim > 1:
shape = tuple(
int(math.ceil(points_buffer[:, d].max()))
for d in range(points_buffer.shape[1]))
else:
shape = (int(math.ceil(points_buffer[:].max())), )
elif isinstance(shape, str):
shape = io.shape(shape)
if sink is None and dtype is None:
if weights is not None:
dtype = io.dtype(weights)
elif kernel is not None:
kernel = np.asarray(kernel)
dtype = kernel.dtype
else:
dtype = int
sink, sink_buffer, sink_shape, sink_strides = ap.initialize_sink(
sink=sink,
shape=shape,
dtype=dtype,
return_shape=True,
return_strides=True,
as_1d=True)
#TODO: initialize properly
counts = np.zeros(sink_shape, dtype=int, order=sink.order)
counts_buffer = counts.reshape(-1, order='A')
#print(counts.shape, counts_buffer.shape)
if indices is None:
return sink
indices = np.asarray(indices, dtype=int)
if indices.ndim == 1:
indices = indices[:, None]
if kernel is not None:
kernel = np.asarray(kernel, dtype=float)
#print(kernel);
#print(weights)
#return;
code.average(points_buffer, weights, indices, sink_buffer, sink_shape,
sink_strides, counts_buffer, processes)
# if weights is None:
# if kernel is None:
# code.devolve_uniform(points_buffer, indices, sink_buffer, sink_shape, sink_strides, processes);
# else:
# code.devolve_uniform_kernel(points_buffer, indices, kernel, sink_buffer, sink_shape, sink_strides, processes);
# else:
# if kernel is None:
# code.devolve_weights(points_buffer, weights, indices, sink_buffer, sink_shape, sink_strides, processes);
# else:
# code.devolve_weights_kernel(points_buffer, weights, indices, kernel, sink_buffer, sink_shape, sink_strides, processes);
#TODO: move to code
good = counts_buffer > 0
sink_buffer[good] /= counts_buffer[good]
ap.finalize_processing(verbose=verbose, function='devolve', timer=timer)
if return_counts:
return sink, counts
else:
return sink
def index_from_binary(source,
sink=None,
method='shared',
dtype='uint32',
processes=None,
verbose=False):
"""Calculate the local 3x3x3 configuration in a binary source.
Note
----
The configuration kernel is separable and convolution with it
is calculated via a sequence of 1d convolutions.
"""
processes, timer = ap.initialize_processing(processes=processes,
verbose=verbose,
function='index_from_binary')
#determine configuration
source, source_buffer, source_shape, source_strides, source_order = ap.initialize_source(
source,
as_1d=True,
return_shape=True,
return_strides=True,
return_order=True)
ndim = len(source_shape)
buffer_dtype = np.result_type(source_buffer.dtype, 'uint32')
delete_files = []
if source_order == 'C':
axis_range = range(ndim - 1, -1, -1)
axis_last = 0
else:
axis_range = range(ndim)
axis_last = ndim - 1
for axis in axis_range:
if axis == axis_last:
sink, sink_buffer, sink_shape, sink_strides = ap.initialize_sink(
sink=sink,
as_1d=True,
source=source,
dtype=dtype,
return_shape=True,
return_strides=True)
else:
if method == 'shared':
_, sink_buffer, sink_shape, sink_strides = ap.initialize_sink(
sink=None,
as_1d=True,
shape=source_shape,
dtype=buffer_dtype,
order=source_order,
return_shape=True,
return_strides=True)
else:
location = tempfile.mktemp() + '.npy'
_, sink_buffer, sink_shape, sink_strides = ap.initialize_sink(
sink=location,
as_1d=True,
shape=tuple(source_shape),
dtype=buffer_dtype,
order=source_order,
return_shape=True,
return_strides=True)
delete_files.append(location)
kernel = index_kernel(axis=axis, dtype=float)
#print(source_buffer.dtype, source_buffer.shape, source_shape, source_strides, axis, sink_buffer.shape, sink_buffer.dtype, sink_strides, kernel.dtype)
ap.code.correlate_1d(source_buffer, source_shape, source_strides,
sink_buffer, sink_shape, sink_strides, kernel,
axis, processes)
source_buffer = sink_buffer
for f in delete_files:
io.delete_file(f)
ap.finalize_processing(verbose=verbose,
function='index_from_binary',
timer=timer)
return sink