Source code for ClearMap.ParallelProcessing.DataProcessing.DevolvePointList

# -*- coding: utf-8 -*-
"""
DevolvePointList
================

Converts point data into a devolved or smeared out image for 
visulalization and analysis purposes. 

Note
----
This is effecitively blurring with a specified kernel.
"""
__author__    = 'Christoph Kirst <christoph.kirst.ck@gmail.com>'
__license__   = 'GPLv3 - GNU General Pulic License v3 (see LICENSE)'
__copyright__ = 'Copyright © 2020 by Christoph Kirst'
__webpage__   = 'http://idisco.info'
__download__  = 'http://www.github.com/ChristophKirst/ClearMap2'

import math
import numpy as np

import pyximport;
pyximport.install(setup_args={"include_dirs":np.get_include()}, reload_support=True)

import ClearMap.IO.IO as io

import ClearMap.ParallelProcessing.DataProcessing.ArrayProcessing as ap

import ClearMap.ParallelProcessing.DataProcessing.DevolvePointListCode as code

###############################################################################
### Voxelization
###############################################################################

[docs] def devolve(source, sink = None, shape = None, dtype = None, weights = None, indices = None, kernel = None, processes = None, verbose = False): """Converts 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.as_source(source).as_buffer(); 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); 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); 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); ap.finalize_processing(verbose=verbose, function='devolve', timer=timer); return sink;
############################################################################### ### Tests ############################################################################### def _test(): """Tests""" import numpy as np import ClearMap.Visualization.Plot3d as p3d import ClearMap.ParallelProcessing.DataProcessing.DevolvePointList as dpl from importlib import reload reload(dpl) points = np.array([1,9,10], dtype=float) indices = [-2,-1,0,1]; v = dpl.devolve(points, shape=(11,), indices=indices); print(v.array) points = np.array([[10,10,18]]) indices = [[-1,-1,-1],[0,0,0],[1,1,1]]; v = dpl.devolve(points, shape=(20,20,20), indices=indices, weights=None); p3d.plot(v) points = np.array([[10,10,10]]); weights = np.random.rand(len(points)); v = dpl.devolve(points, shape=(20,20,20), indices=indices, weights=weights); p3d.plot(v) kernel = np.random.rand(len(indices)); v = dpl.devolve(points, shape=(20,20,20), indices=indices, weights=None, kernel=kernel); p3d.plot(v)