def __FilterData2D(self, data): mode = _ni_support._extend_mode_to_code("reflect") #lowpass filter to suppress noise #a = ndimage.gaussian_filter(data.astype('f4'), self.filterRadiusLowpass) #print data.shape data = data - data.mean() output, a = _ni_support._get_output(None, data) if self.PRIaxis == 'x': _nd_image.correlate1d(data, weightsLowpass, 0, output, mode, 0, 0) _nd_image.correlate1d(output, weightsHighpass, 1, output, mode, 0, 0) else: _nd_image.correlate1d(data, weightsHighpass, 0, output, mode, 0, 0) _nd_image.correlate1d(output, weightsLowpass, 1, output, mode, 0, 0) #print numpy.absolute(a - a_).mean() #lowpass filter again to find background #b = ndimage.gaussian_filter(a, self.filterRadiusHighpass) #output, b = _ni_support._get_output(None, data) #_nd_image.correlate1d(data, weightsHighpass, 0, output, mode, 0,0) #_nd_image.correlate1d(output, weightsHighpass, 1, output, mode, 0,0) return a #- b
def __FilterData2D(self,data): mode = _ni_support._extend_mode_to_code("reflect") #lowpass filter to suppress noise #a = ndimage.gaussian_filter(data.astype('f4'), self.filterRadiusLowpass) #print data.shape data = data - data.mean() output, a = _ni_support._get_output(None, data) if self.PRIaxis == 'x': _nd_image.correlate1d(data, weightsLowpass, 0, output, mode, 0,0) _nd_image.correlate1d(output, weightsHighpass, 1, output, mode, 0,0) else: _nd_image.correlate1d(data, weightsHighpass, 0, output, mode, 0,0) _nd_image.correlate1d(output, weightsLowpass, 1, output, mode, 0,0) #print numpy.absolute(a - a_).mean() #lowpass filter again to find background #b = ndimage.gaussian_filter(a, self.filterRadiusHighpass) #output, b = _ni_support._get_output(None, data) #_nd_image.correlate1d(data, weightsHighpass, 0, output, mode, 0,0) #_nd_image.correlate1d(output, weightsHighpass, 1, output, mode, 0,0) return a #- b
def _correlate_or_convolve(input, weights, output, mode, cval, origin, convolution): input = np.asarray(input) if np.iscomplexobj(input): raise TypeError('Complex type not supported') origins = _ni_support._normalize_sequence(origin, input.ndim) weights = np.asarray(weights, dtype=np.float64) wshape = [ii for ii in weights.shape if ii > 0] if len(wshape) != input.ndim: raise RuntimeError('filter weights array has incorrect shape.') if convolution: weights = weights[tuple([slice(None, None, -1)] * weights.ndim)] for ii in range(len(origins)): origins[ii] = -origins[ii] if not weights.shape[ii] & 1: origins[ii] -= 1 for origin, lenw in zip(origins, wshape): if _invalid_origin(origin, lenw): raise ValueError('Invalid origin; origin must satisfy ' '-(weights.shape[k] // 2) <= origin[k] <= ' '(weights.shape[k]-1) // 2') if not weights.flags.contiguous: weights = weights.copy() output = _ni_support._get_output(output, input) mode = _ni_support._extend_mode_to_code(mode) _nd_image.correlate(input, weights, output, mode, cval, origins) return output
def correlate1d(input, weights, axis=-1, output=None, mode="reflect", cval=0.0, origin=0): """Calculate a one-dimensional correlation along the given axis. The lines of the array along the given axis are correlated with the given weights. Parameters ---------- %(input)s weights : array One-dimensional sequence of numbers. %(axis)s %(output)s %(mode)s %(cval)s %(origin)s """ input = numpy.asarray(input) if numpy.iscomplexobj(input): raise TypeError('Complex type not supported') output, return_value = _ni_support._get_output(output, input) weights = numpy.asarray(weights, dtype=numpy.float64) if weights.ndim != 1 or weights.shape[0] < 1: raise RuntimeError('no filter weights given') if not weights.flags.contiguous: weights = weights.copy() axis = _ni_support._check_axis(axis, input.ndim) if ((len(weights) // 2 + origin < 0) or (len(weights) // 2 + origin > len(weights))): raise ValueError('invalid origin') mode = _ni_support._extend_mode_to_code(mode) _nd_image.correlate1d(input, weights, axis, output, mode, cval, origin) return return_value
def __FilterDataFast(self): data = self.data[:,:,0] mode = _ni_support._extend_mode_to_code("reflect") # lowpass filter to suppress noise output, a = _ni_support._get_output(None, data) _nd_image.correlate1d(data, ofdP.weightsLowpass, 0, output, mode, 0, 0) _nd_image.correlate1d(output, ofdP.weightsLowpass, 1, output, mode, 0, 0) # lowpass filter again to find background output, b = _ni_support._get_output(None, data) _nd_image.correlate1d(data, ofdP.weightsHighpass, 0, output, mode, 0, 0) _nd_image.correlate1d(output, ofdP.weightsHighpass, 1, output, mode, 0, 0) return a - b
def __FilterDataFast(self): data = self.data[:, :, 0] mode = _ni_support._extend_mode_to_code("reflect") # lowpass filter to suppress noise output, a = _ni_support._get_output(None, data) _nd_image.correlate1d(data, ofdP.weightsLowpass, 0, output, mode, 0, 0) _nd_image.correlate1d(output, ofdP.weightsLowpass, 1, output, mode, 0, 0) # lowpass filter again to find background output, b = _ni_support._get_output(None, data) _nd_image.correlate1d(data, ofdP.weightsHighpass, 0, output, mode, 0, 0) _nd_image.correlate1d(output, ofdP.weightsHighpass, 1, output, mode, 0, 0) return a - b
def Afunc(self, f): """Forward transform - convolve with the PSF""" fs = np.reshape(f, (self.height, self.width, self.depth)) #d = ndimage.gaussian_filter(fs, self.sigma) mode = _ni_support._extend_mode_to_code("reflect") #lowpass filter to suppress noise #a = ndimage.gaussian_filter(data.astype('f4'), self.filterRadiusLowpass) #print data.shape output, a = _ni_support._get_output(None, fs) _nd_image.correlate1d(fs, self.kernel, 0, output, mode, 0, 0) _nd_image.correlate1d(output, self.kernel, 1, output, mode, 0, 0) #ndimage.uniform_filter(output, self.oversamp, output=output) #d = real(d); return np.ravel(output) #[::oversamp,::oversamp,:])
def Afunc(self, f): '''Forward transform - convolve with the PSF''' fs = reshape(f, (self.height, self.width, self.depth)) #d = ndimage.gaussian_filter(fs, self.sigma) mode = _ni_support._extend_mode_to_code("reflect") #lowpass filter to suppress noise #a = ndimage.gaussian_filter(data.astype('f4'), self.filterRadiusLowpass) #print data.shape output, a = _ni_support._get_output(None, fs) _nd_image.correlate1d(fs, self.kernel, 0, output, mode, 0,0) _nd_image.correlate1d(output, self.kernel, 1, output, mode, 0,0) #ndimage.uniform_filter(output, self.oversamp, output=output) #d = real(d); return ravel(output)#[::oversamp,::oversamp,:])
def __FilterData2D(self, data): mode = _ni_support._extend_mode_to_code("reflect") #lowpass filter to suppress noise #a = ndimage.gaussian_filter(data.astype('f4'), self.filterRadiusLowpass) #print data.shape #output, a = _ni_support._get_output(None, data) a = np.zeros(data.shape, dtype=data.dtype.name) _nd_image.correlate1d(data, weightsLowpass, 0, a, mode, 0, 0) _nd_image.correlate1d(a, weightsLowpass, 1, a, mode, 0, 0) #print np.absolute(a - a_).mean() #lowpass filter again to find background #b = ndimage.gaussian_filter(a, self.filterRadiusHighpass) b = np.zeros(data.shape, dtype=data.dtype.name) _nd_image.correlate1d(data, weightsHighpass, 0, b, mode, 0, 0) _nd_image.correlate1d(b, weightsHighpass, 1, b, mode, 0, 0) return a - b
def map_coordinates_parallel(input, coordinates, output=None, order=3, mode='constant', cval=0.0, prefilter=True, chunklen=None, threads=None): """ Parallalized version of `scipy.ndimage.map_coordinates`. `scipy.ndimage.map_coordinates` is slow for large datasets. Speed improvement can be achieved by * Splitting the data into chunks * Performing the transformation of chunks in parallel New parameters: chunklen: Size of the chunks in pixels per axis. Default: None Special values: None: Automatic (Chooses a default based on number of dimensions) 0: Do not split data into chunks. (implicitly sets threads==1) threads: Number of threads. Default: None None: Automatic (One thread per available processing unit) """ # this part is taken without change from scipy's serial implementation if order < 0 or order > 5: raise RuntimeError('spline order not supported') input = np.asarray(input) if np.iscomplexobj(input): raise TypeError('Complex type not supported') coordinates = np.asarray(coordinates) if np.iscomplexobj(coordinates): raise TypeError('Complex type not supported') output_shape = coordinates.shape[1:] if input.ndim < 1 or len(output_shape) < 1: raise RuntimeError('input and output rank must be > 0') if coordinates.shape[0] != input.ndim: raise RuntimeError('invalid shape for coordinate array') mode = _ni_support._extend_mode_to_code(mode) if prefilter and order > 1: filtered = spline_filter(input, order, output=np.float64) else: filtered = input # return value of `_ni_support._get_output` changed between scipy versions, code here is # adapted to work with both output = _ni_support._get_output(output, input, shape=output_shape) retval = output if isinstance(output, tuple): output, retval = output # below here there is the new code for splitting into chunks and parallel execution if chunklen is None: # set defaults chunklen = 128 if output.ndim < 3: chunklen = 1024 def chunk_arguments(filtered, coordinates, output): chunks = [] for axis in range(output.ndim): chunkstarts = np.arange(0, output.shape[axis], chunklen) chunkends = chunkstarts + chunklen chunkends[-1] = output.shape[axis] chunks.append([slice(start, stop) for start, stop in zip(chunkstarts, chunkends)]) for chunk in itertools.product(*chunks): sub_coordinates = coordinates[(slice(None),) + chunk].copy() filtered_region = [] for in_axis in range(filtered.ndim): c = sub_coordinates[in_axis, ...] cmin = max(0, int(np.floor(np.min(c)))-5) cmax = min(filtered.shape[in_axis], int(np.ceil(np.max(c)))+5) sub_coordinates[in_axis, ...] -= cmin filtered_region.append(slice(cmin, cmax)) sub_filtered = filtered[tuple(filtered_region)] sub_output = output[chunk] yield (sub_filtered, sub_coordinates, sub_output) def map_coordinates_chunk(arg): sub_filtered, sub_coordinates, sub_output = arg _nd_image.geometric_transform(sub_filtered, None, sub_coordinates, None, None, sub_output, order, mode, cval, None, None) if chunklen > 0: list_of_chunk_args = list(chunk_arguments(filtered, coordinates, output)) else: list_of_chunk_args = [(filtered, coordinates, output)] if len(list_of_chunk_args) == 1: threads = 1 if threads != 1: threadpool = ThreadPoolExecutor(threads) my_map = threadpool.map else: my_map = map # execution happens here list(my_map(map_coordinates_chunk, list_of_chunk_args)) if threads != 1: if have_concurrent_futures: threadpool.shutdown() else: threadpool.close() threadpool.join() return retval
def map_coordinates_parallel(input, coordinates, output=None, order=3, mode='constant', cval=0.0, prefilter=True, chunklen=None, threads=None): """ Parallalized version of `scipy.ndimage.map_coordinates`. `scipy.ndimage.map_coordinates` is slow for large datasets. Speed improvement can be achieved by * Splitting the data into chunks * Performing the transformation of chunks in parallel New parameters: chunklen: Size of the chunks in pixels per axis. Default: None Special values: None: Automatic (Chooses a default based on number of dimensions) 0: Do not split data into chunks. (implicitly sets threads==1) threads: Number of threads. Default: None None: Automatic (One thread per available processing unit) """ # this part is taken without change from scipy's serial implementation if order < 0 or order > 5: raise RuntimeError('spline order not supported') input = np.asarray(input) if np.iscomplexobj(input): raise TypeError('Complex type not supported') coordinates = np.asarray(coordinates) if np.iscomplexobj(coordinates): raise TypeError('Complex type not supported') output_shape = coordinates.shape[1:] if input.ndim < 1 or len(output_shape) < 1: raise RuntimeError('input and output rank must be > 0') if coordinates.shape[0] != input.ndim: raise RuntimeError('invalid shape for coordinate array') mode = _ni_support._extend_mode_to_code(mode) if prefilter and order > 1: filtered = spline_filter(input, order, output=np.float64) else: filtered = input # return value of `_ni_support._get_output` changed between scipy versions, code here is # adapted to work with both output = _ni_support._get_output(output, input, shape=output_shape) retval = output if isinstance(output, tuple): output, retval = output # below here there is the new code for splitting into chunks and parallel execution if chunklen is None: # set defaults chunklen = 128 if output.ndim < 3: chunklen = 1024 def chunk_arguments(filtered, coordinates, output): chunks = [] for axis in range(output.ndim): chunkstarts = np.arange(0, output.shape[axis], chunklen) chunkends = chunkstarts + chunklen chunkends[-1] = output.shape[axis] chunks.append([ slice(start, stop) for start, stop in zip(chunkstarts, chunkends) ]) for chunk in itertools.product(*chunks): sub_coordinates = coordinates[(slice(None), ) + chunk].copy() filtered_region = [] for in_axis in range(filtered.ndim): c = sub_coordinates[in_axis, ...] cmin = max(0, int(np.floor(np.min(c))) - 5) cmax = min(filtered.shape[in_axis], int(np.ceil(np.max(c))) + 5) sub_coordinates[in_axis, ...] -= cmin filtered_region.append(slice(cmin, cmax)) sub_filtered = filtered[tuple(filtered_region)] sub_output = output[chunk] yield (sub_filtered, sub_coordinates, sub_output) def map_coordinates_chunk(arg): sub_filtered, sub_coordinates, sub_output = arg _nd_image.geometric_transform(sub_filtered, None, sub_coordinates, None, None, sub_output, order, mode, cval, None, None) if chunklen > 0: list_of_chunk_args = list( chunk_arguments(filtered, coordinates, output)) else: list_of_chunk_args = [(filtered, coordinates, output)] if len(list_of_chunk_args) == 1: threads = 1 if threads != 1: threadpool = ThreadPoolExecutor(threads) my_map = threadpool.map else: my_map = map # execution happens here list(my_map(map_coordinates_chunk, list_of_chunk_args)) if threads != 1: if have_concurrent_futures: threadpool.shutdown() else: threadpool.close() threadpool.join() return retval