From 222dce71b65eddaec1a1655b8c9e7f21d1fdca9d Mon Sep 17 00:00:00 2001
From: ac_sb33
Date: Fri, 22 Feb 2019 11:17:17 -0500
Subject: [PATCH] rebuilt agains cuda 9.1
---
src/MATLAB/+HIP/@Cuda/Closure.m | 44 +-
src/MATLAB/+HIP/@Cuda/Cuda.m | 58 +--
src/MATLAB/+HIP/@Cuda/DeviceCount.m | 16 +-
src/MATLAB/+HIP/@Cuda/DeviceStats.m | 14 +-
src/MATLAB/+HIP/@Cuda/ElementWiseDifference.m | 36 +-
src/MATLAB/+HIP/@Cuda/EntropyFilter.m | 36 +-
src/MATLAB/+HIP/@Cuda/Gaussian.m | 42 +-
src/MATLAB/+HIP/@Cuda/GetMinMax.m | 26 +-
src/MATLAB/+HIP/@Cuda/Help.m | 12 +-
src/MATLAB/+HIP/@Cuda/HighPassFilter.m | 34 +-
src/MATLAB/+HIP/@Cuda/Info.m | 20 +-
src/MATLAB/+HIP/@Cuda/LoG.m | 34 +-
src/MATLAB/+HIP/@Cuda/MaxFilter.m | 44 +-
src/MATLAB/+HIP/@Cuda/MeanFilter.m | 44 +-
src/MATLAB/+HIP/@Cuda/MedianFilter.m | 44 +-
src/MATLAB/+HIP/@Cuda/Mex.mexw64 | 4 +-
src/MATLAB/+HIP/@Cuda/MinFilter.m | 44 +-
src/MATLAB/+HIP/@Cuda/MinMax.m | 30 +-
src/MATLAB/+HIP/@Cuda/MultiplySum.m | 44 +-
src/MATLAB/+HIP/@Cuda/Opener.m | 44 +-
src/MATLAB/+HIP/@Cuda/StdFilter.m | 44 +-
src/MATLAB/+HIP/@Cuda/Sum.m | 28 +-
src/MATLAB/+HIP/@Cuda/VarFilter.m | 44 +-
src/MATLAB/+HIP/@Cuda/WienerFilter.m | 44 +-
src/MATLAB/+HIP/Closure.m | 56 +--
src/MATLAB/+HIP/ElementWiseDifference.m | 48 +-
src/MATLAB/+HIP/EntropyFilter.m | 48 +-
src/MATLAB/+HIP/Gaussian.m | 54 +--
src/MATLAB/+HIP/GetMinMax.m | 38 +-
src/MATLAB/+HIP/Help.m | 10 +-
src/MATLAB/+HIP/HighPassFilter.m | 46 +-
src/MATLAB/+HIP/Info.m | 32 +-
src/MATLAB/+HIP/LoG.m | 46 +-
src/MATLAB/+HIP/MaxFilter.m | 56 +--
src/MATLAB/+HIP/MeanFilter.m | 56 +--
src/MATLAB/+HIP/MedianFilter.m | 56 +--
src/MATLAB/+HIP/MinFilter.m | 56 +--
src/MATLAB/+HIP/MinMax.m | 42 +-
src/MATLAB/+HIP/MultiplySum.m | 56 +--
src/MATLAB/+HIP/Opener.m | 56 +--
src/MATLAB/+HIP/StdFilter.m | 56 +--
src/MATLAB/+HIP/Sum.m | 40 +-
src/MATLAB/+HIP/VarFilter.m | 56 +--
src/MATLAB/+HIP/WienerFilter.m | 56 +--
src/c/CudaImageProcessor.vcxproj | 404 ++++++++---------
src/c/CudaMex.vcxproj | 275 ++++++------
src/c/CudaPy3DLL.vcxproj | 424 +++++++++---------
src/c/Mex.mexw64 | 4 +-
src/c/Mex/MexDeviceStats.cpp | 2 +-
49 files changed, 1453 insertions(+), 1450 deletions(-)
diff --git a/src/MATLAB/+HIP/@Cuda/Closure.m b/src/MATLAB/+HIP/@Cuda/Closure.m
index de14b6d..cd7afdd 100644
--- a/src/MATLAB/+HIP/@Cuda/Closure.m
+++ b/src/MATLAB/+HIP/@Cuda/Closure.m
@@ -1,22 +1,22 @@
-% Closure - This kernel will dilate follow by an erosion.
-% arrayOut = HIP.Cuda.Closure(arrayIn,kernel,[numIterations],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the max neighborhood.
-%
-% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
-% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
-% Can be empty an array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-function arrayOut = Closure(arrayIn,kernel,numIterations,device)
- [arrayOut] = HIP.Cuda.Mex('Closure',arrayIn,kernel,numIterations,device);
-end
+% Closure - This kernel will dilate follow by an erosion.
+% arrayOut = HIP.Cuda.Closure(arrayIn,kernel,[numIterations],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the max neighborhood.
+%
+% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
+% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
+% Can be empty an array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+function arrayOut = Closure(arrayIn,kernel,numIterations,device)
+ [arrayOut] = HIP.Cuda.Mex('Closure',arrayIn,kernel,numIterations,device);
+end
diff --git a/src/MATLAB/+HIP/@Cuda/Cuda.m b/src/MATLAB/+HIP/@Cuda/Cuda.m
index 5d64212..f6a8664 100644
--- a/src/MATLAB/+HIP/@Cuda/Cuda.m
+++ b/src/MATLAB/+HIP/@Cuda/Cuda.m
@@ -1,29 +1,29 @@
-classdef (Abstract,Sealed) Cuda
-methods (Static)
- commandInfo = Info()
- Help(command)
- [numCudaDevices,memoryStats] = DeviceCount()
- deviceStatsArray = DeviceStats()
- arrayOut = Closure(arrayIn,kernel,numIterations,device)
- arrayOut = ElementWiseDifference(array1In,array2In,device)
- arrayOut = EntropyFilter(arrayIn,kernel,device)
- arrayOut = Gaussian(arrayIn,sigmas,numIterations,device)
- [minValue,maxValue] = GetMinMax(arrayIn,device)
- arrayOut = HighPassFilter(arrayIn,sigmas,device)
- arrayOut = LoG(arrayIn,sigmas,device)
- arrayOut = MaxFilter(arrayIn,kernel,numIterations,device)
- arrayOut = MeanFilter(arrayIn,kernel,numIterations,device)
- arrayOut = MedianFilter(arrayIn,kernel,numIterations,device)
- arrayOut = MinFilter(arrayIn,kernel,numIterations,device)
- [minOut,maxOut] = MinMax(arrayIn,device)
- arrayOut = MultiplySum(arrayIn,kernel,numIterations,device)
- arrayOut = Opener(arrayIn,kernel,numIterations,device)
- arrayOut = StdFilter(arrayIn,kernel,numIterations,device)
- valueOut = Sum(arrayIn,device)
- arrayOut = VarFilter(arrayIn,kernel,numIterations,device)
- arrayOut = WienerFilter(arrayIn,kernel,noiseVariance,device)
-end
-methods (Static, Access = private)
- varargout = Mex(command, varargin)
-end
-end
+classdef (Abstract,Sealed) Cuda
+methods (Static)
+ commandInfo = Info()
+ Help(command)
+ [numCudaDevices,memoryStats] = DeviceCount()
+ deviceStatsArray = DeviceStats()
+ arrayOut = Closure(arrayIn,kernel,numIterations,device)
+ arrayOut = ElementWiseDifference(array1In,array2In,device)
+ arrayOut = EntropyFilter(arrayIn,kernel,device)
+ arrayOut = Gaussian(arrayIn,sigmas,numIterations,device)
+ [minValue,maxValue] = GetMinMax(arrayIn,device)
+ arrayOut = HighPassFilter(arrayIn,sigmas,device)
+ arrayOut = LoG(arrayIn,sigmas,device)
+ arrayOut = MaxFilter(arrayIn,kernel,numIterations,device)
+ arrayOut = MeanFilter(arrayIn,kernel,numIterations,device)
+ arrayOut = MedianFilter(arrayIn,kernel,numIterations,device)
+ arrayOut = MinFilter(arrayIn,kernel,numIterations,device)
+ [minOut,maxOut] = MinMax(arrayIn,device)
+ arrayOut = MultiplySum(arrayIn,kernel,numIterations,device)
+ arrayOut = Opener(arrayIn,kernel,numIterations,device)
+ arrayOut = StdFilter(arrayIn,kernel,numIterations,device)
+ valueOut = Sum(arrayIn,device)
+ arrayOut = VarFilter(arrayIn,kernel,numIterations,device)
+ arrayOut = WienerFilter(arrayIn,kernel,noiseVariance,device)
+end
+methods (Static, Access = private)
+ varargout = Mex(command, varargin)
+end
+end
diff --git a/src/MATLAB/+HIP/@Cuda/DeviceCount.m b/src/MATLAB/+HIP/@Cuda/DeviceCount.m
index e98fcdd..e1dd4f2 100644
--- a/src/MATLAB/+HIP/@Cuda/DeviceCount.m
+++ b/src/MATLAB/+HIP/@Cuda/DeviceCount.m
@@ -1,8 +1,8 @@
-% DeviceCount - This will return the number of Cuda devices available, and their memory.
-% [numCudaDevices,memoryStats] = HIP.Cuda.DeviceCount()
-% NumCudaDevices -- this is the number of Cuda devices available.
-% MemoryStats -- this is an array of structures where each entry corresponds to a Cuda device.
-% The memory structure contains the total memory on the device and the memory available for a Cuda call.
-function [numCudaDevices,memoryStats] = DeviceCount()
- [numCudaDevices,memoryStats] = HIP.Cuda.Mex('DeviceCount');
-end
+% DeviceCount - This will return the number of Cuda devices available, and their memory.
+% [numCudaDevices,memoryStats] = HIP.Cuda.DeviceCount()
+% NumCudaDevices -- this is the number of Cuda devices available.
+% MemoryStats -- this is an array of structures where each entry corresponds to a Cuda device.
+% The memory structure contains the total memory on the device and the memory available for a Cuda call.
+function [numCudaDevices,memoryStats] = DeviceCount()
+ [numCudaDevices,memoryStats] = HIP.Cuda.Mex('DeviceCount');
+end
diff --git a/src/MATLAB/+HIP/@Cuda/DeviceStats.m b/src/MATLAB/+HIP/@Cuda/DeviceStats.m
index 72369ad..14a8091 100644
--- a/src/MATLAB/+HIP/@Cuda/DeviceStats.m
+++ b/src/MATLAB/+HIP/@Cuda/DeviceStats.m
@@ -1,7 +1,7 @@
-% DeviceStats - This will return the statistics of each Cuda capable device installed.
-% deviceStatsArray = HIP.Cuda.DeviceStats()
-% DeviceStatsArray -- this is an array of structs, one struct per device.
-% The struct has these fields: name, major, minor, constMem, sharedMem, totalMem, tccDriver, mpCount, threadsPerMP, warpSize, maxThreads.
-function deviceStatsArray = DeviceStats()
- [deviceStatsArray] = HIP.Cuda.Mex('DeviceStats');
-end
+% DeviceStats - This will return the statistics of each Cuda capable device installed.
+% deviceStatsArray = HIP.Cuda.DeviceStats()
+% DeviceStatsArray -- this is an array of structs, one struct per device.
+% The struct has these fields: name, major, minor, constMem, sharedMem, totalMem, tccDriver, mpCount, threadsPerMP, warpSize, maxThreads.
+function deviceStatsArray = DeviceStats()
+ [deviceStatsArray] = HIP.Cuda.Mex('DeviceStats');
+end
diff --git a/src/MATLAB/+HIP/@Cuda/ElementWiseDifference.m b/src/MATLAB/+HIP/@Cuda/ElementWiseDifference.m
index 3a79d97..ad77343 100644
--- a/src/MATLAB/+HIP/@Cuda/ElementWiseDifference.m
+++ b/src/MATLAB/+HIP/@Cuda/ElementWiseDifference.m
@@ -1,18 +1,18 @@
-% ElementWiseDifference - This subtracts the second array from the first, element by element (A-B).
-% arrayOut = HIP.Cuda.ElementWiseDifference(array1In,array2In,[device])
-% image1In = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% image2In = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-function arrayOut = ElementWiseDifference(array1In,array2In,device)
- [arrayOut] = HIP.Cuda.Mex('ElementWiseDifference',array1In,array2In,device);
-end
+% ElementWiseDifference - This subtracts the second array from the first, element by element (A-B).
+% arrayOut = HIP.Cuda.ElementWiseDifference(array1In,array2In,[device])
+% image1In = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% image2In = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+function arrayOut = ElementWiseDifference(array1In,array2In,device)
+ [arrayOut] = HIP.Cuda.Mex('ElementWiseDifference',array1In,array2In,device);
+end
diff --git a/src/MATLAB/+HIP/@Cuda/EntropyFilter.m b/src/MATLAB/+HIP/@Cuda/EntropyFilter.m
index 8e3ccda..c6d0025 100644
--- a/src/MATLAB/+HIP/@Cuda/EntropyFilter.m
+++ b/src/MATLAB/+HIP/@Cuda/EntropyFilter.m
@@ -1,18 +1,18 @@
-% EntropyFilter - This calculates the entropy within the neighborhood given by the kernel.
-% arrayOut = HIP.Cuda.EntropyFilter(arrayIn,kernel,[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the max neighborhood.
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-function arrayOut = EntropyFilter(arrayIn,kernel,device)
- [arrayOut] = HIP.Cuda.Mex('EntropyFilter',arrayIn,kernel,device);
-end
+% EntropyFilter - This calculates the entropy within the neighborhood given by the kernel.
+% arrayOut = HIP.Cuda.EntropyFilter(arrayIn,kernel,[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the max neighborhood.
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+function arrayOut = EntropyFilter(arrayIn,kernel,device)
+ [arrayOut] = HIP.Cuda.Mex('EntropyFilter',arrayIn,kernel,device);
+end
diff --git a/src/MATLAB/+HIP/@Cuda/Gaussian.m b/src/MATLAB/+HIP/@Cuda/Gaussian.m
index e4cb71f..683be0b 100644
--- a/src/MATLAB/+HIP/@Cuda/Gaussian.m
+++ b/src/MATLAB/+HIP/@Cuda/Gaussian.m
@@ -1,21 +1,21 @@
-% Gaussian - Gaussian smoothing.
-% arrayOut = HIP.Cuda.Gaussian(arrayIn,sigmas,[numIterations],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% Sigmas = This should be an array of three positive values that represent the standard deviation of a Gaussian curve.
-% Zeros (0) in this array will not smooth in that direction.
-%
-% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
-% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
-% Can be empty an array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-function arrayOut = Gaussian(arrayIn,sigmas,numIterations,device)
- [arrayOut] = HIP.Cuda.Mex('Gaussian',arrayIn,sigmas,numIterations,device);
-end
+% Gaussian - Gaussian smoothing.
+% arrayOut = HIP.Cuda.Gaussian(arrayIn,sigmas,[numIterations],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% Sigmas = This should be an array of three positive values that represent the standard deviation of a Gaussian curve.
+% Zeros (0) in this array will not smooth in that direction.
+%
+% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
+% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
+% Can be empty an array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+function arrayOut = Gaussian(arrayIn,sigmas,numIterations,device)
+ [arrayOut] = HIP.Cuda.Mex('Gaussian',arrayIn,sigmas,numIterations,device);
+end
diff --git a/src/MATLAB/+HIP/@Cuda/GetMinMax.m b/src/MATLAB/+HIP/@Cuda/GetMinMax.m
index c5c12c4..6e883dd 100644
--- a/src/MATLAB/+HIP/@Cuda/GetMinMax.m
+++ b/src/MATLAB/+HIP/@Cuda/GetMinMax.m
@@ -1,13 +1,13 @@
-% GetMinMax - This function finds the lowest and highest value in the array that is passed in.
-% [minValue,maxValue] = HIP.Cuda.GetMinMax(arrayIn,[device])
-% imageIn = This is a one to five dimensional array.
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% minValue = This is the lowest value found in the array.
-% maxValue = This is the highest value found in the array.
-function [minValue,maxValue] = GetMinMax(arrayIn,device)
- [minValue,maxValue] = HIP.Cuda.Mex('GetMinMax',arrayIn,device);
-end
+% GetMinMax - This function finds the lowest and highest value in the array that is passed in.
+% [minValue,maxValue] = HIP.Cuda.GetMinMax(arrayIn,[device])
+% imageIn = This is a one to five dimensional array.
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% minValue = This is the lowest value found in the array.
+% maxValue = This is the highest value found in the array.
+function [minValue,maxValue] = GetMinMax(arrayIn,device)
+ [minValue,maxValue] = HIP.Cuda.Mex('GetMinMax',arrayIn,device);
+end
diff --git a/src/MATLAB/+HIP/@Cuda/Help.m b/src/MATLAB/+HIP/@Cuda/Help.m
index a446a6f..90b6dae 100644
--- a/src/MATLAB/+HIP/@Cuda/Help.m
+++ b/src/MATLAB/+HIP/@Cuda/Help.m
@@ -1,6 +1,6 @@
-% Help - Help on a specified command.
-% HIP.Cuda.Help(command)
-% Print detailed usage information for the specified command.
-function Help(command)
- HIP.Cuda.Mex('Help',command);
-end
+% Help - Help on a specified command.
+% HIP.Cuda.Help(command)
+% Print detailed usage information for the specified command.
+function Help(command)
+ HIP.Cuda.Mex('Help',command);
+end
diff --git a/src/MATLAB/+HIP/@Cuda/HighPassFilter.m b/src/MATLAB/+HIP/@Cuda/HighPassFilter.m
index cb5b62e..844661e 100644
--- a/src/MATLAB/+HIP/@Cuda/HighPassFilter.m
+++ b/src/MATLAB/+HIP/@Cuda/HighPassFilter.m
@@ -1,17 +1,17 @@
-% HighPassFilter - Filters out low frequency by subtracting a Gaussian blurred version of the input based on the sigmas provided.
-% arrayOut = HIP.Cuda.HighPassFilter(arrayIn,sigmas,[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% Sigmas = This should be an array of three positive values that represent the standard deviation of a Gaussian curve.
-% Zeros (0) in this array will not smooth in that direction.
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-function arrayOut = HighPassFilter(arrayIn,sigmas,device)
- [arrayOut] = HIP.Cuda.Mex('HighPassFilter',arrayIn,sigmas,device);
-end
+% HighPassFilter - Filters out low frequency by subtracting a Gaussian blurred version of the input based on the sigmas provided.
+% arrayOut = HIP.Cuda.HighPassFilter(arrayIn,sigmas,[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% Sigmas = This should be an array of three positive values that represent the standard deviation of a Gaussian curve.
+% Zeros (0) in this array will not smooth in that direction.
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+function arrayOut = HighPassFilter(arrayIn,sigmas,device)
+ [arrayOut] = HIP.Cuda.Mex('HighPassFilter',arrayIn,sigmas,device);
+end
diff --git a/src/MATLAB/+HIP/@Cuda/Info.m b/src/MATLAB/+HIP/@Cuda/Info.m
index 1ab3948..ce16a78 100644
--- a/src/MATLAB/+HIP/@Cuda/Info.m
+++ b/src/MATLAB/+HIP/@Cuda/Info.m
@@ -1,10 +1,10 @@
-% Info - Get information on all available mex commands.
-% commandInfo = HIP.Cuda.Info()
-% Returns commandInfo structure array containing information on all mex commands.
-% commandInfo.command - Command string
-% commandInfo.outArgs - Cell array of output arguments
-% commandInfo.inArgs - Cell array of input arguments
-% commandInfo.helpLines - Cell array of input arguments
-function commandInfo = Info()
- [commandInfo] = HIP.Cuda.Mex('Info');
-end
+% Info - Get information on all available mex commands.
+% commandInfo = HIP.Cuda.Info()
+% Returns commandInfo structure array containing information on all mex commands.
+% commandInfo.command - Command string
+% commandInfo.outArgs - Cell array of output arguments
+% commandInfo.inArgs - Cell array of input arguments
+% commandInfo.helpLines - Cell array of input arguments
+function commandInfo = Info()
+ [commandInfo] = HIP.Cuda.Mex('Info');
+end
diff --git a/src/MATLAB/+HIP/@Cuda/LoG.m b/src/MATLAB/+HIP/@Cuda/LoG.m
index e6d5bb4..18eafca 100644
--- a/src/MATLAB/+HIP/@Cuda/LoG.m
+++ b/src/MATLAB/+HIP/@Cuda/LoG.m
@@ -1,17 +1,17 @@
-% LoG - Apply a Lapplacian of Gaussian filter with the given sigmas.
-% arrayOut = HIP.Cuda.LoG(arrayIn,sigmas,[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% Sigmas = This should be an array of three positive values that represent the standard deviation of a Gaussian curve.
-% Zeros (0) in this array will not smooth in that direction.
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-function arrayOut = LoG(arrayIn,sigmas,device)
- [arrayOut] = HIP.Cuda.Mex('LoG',arrayIn,sigmas,device);
-end
+% LoG - Apply a Lapplacian of Gaussian filter with the given sigmas.
+% arrayOut = HIP.Cuda.LoG(arrayIn,sigmas,[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% Sigmas = This should be an array of three positive values that represent the standard deviation of a Gaussian curve.
+% Zeros (0) in this array will not smooth in that direction.
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+function arrayOut = LoG(arrayIn,sigmas,device)
+ [arrayOut] = HIP.Cuda.Mex('LoG',arrayIn,sigmas,device);
+end
diff --git a/src/MATLAB/+HIP/@Cuda/MaxFilter.m b/src/MATLAB/+HIP/@Cuda/MaxFilter.m
index 2715cc5..f598ed2 100644
--- a/src/MATLAB/+HIP/@Cuda/MaxFilter.m
+++ b/src/MATLAB/+HIP/@Cuda/MaxFilter.m
@@ -1,22 +1,22 @@
-% MaxFilter - This will set each pixel/voxel to the max value of the neighborhood defined by the given kernel.
-% arrayOut = HIP.Cuda.MaxFilter(arrayIn,kernel,[numIterations],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the max neighborhood.
-%
-% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
-% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
-% Can be empty an array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-function arrayOut = MaxFilter(arrayIn,kernel,numIterations,device)
- [arrayOut] = HIP.Cuda.Mex('MaxFilter',arrayIn,kernel,numIterations,device);
-end
+% MaxFilter - This will set each pixel/voxel to the max value of the neighborhood defined by the given kernel.
+% arrayOut = HIP.Cuda.MaxFilter(arrayIn,kernel,[numIterations],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the max neighborhood.
+%
+% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
+% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
+% Can be empty an array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+function arrayOut = MaxFilter(arrayIn,kernel,numIterations,device)
+ [arrayOut] = HIP.Cuda.Mex('MaxFilter',arrayIn,kernel,numIterations,device);
+end
diff --git a/src/MATLAB/+HIP/@Cuda/MeanFilter.m b/src/MATLAB/+HIP/@Cuda/MeanFilter.m
index 95ce167..8f9e43c 100644
--- a/src/MATLAB/+HIP/@Cuda/MeanFilter.m
+++ b/src/MATLAB/+HIP/@Cuda/MeanFilter.m
@@ -1,22 +1,22 @@
-% MeanFilter - This will take the mean of the given neighborhood.
-% arrayOut = HIP.Cuda.MeanFilter(arrayIn,kernel,[numIterations],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the max neighborhood.
-%
-% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
-% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
-% Can be empty an array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-function arrayOut = MeanFilter(arrayIn,kernel,numIterations,device)
- [arrayOut] = HIP.Cuda.Mex('MeanFilter',arrayIn,kernel,numIterations,device);
-end
+% MeanFilter - This will take the mean of the given neighborhood.
+% arrayOut = HIP.Cuda.MeanFilter(arrayIn,kernel,[numIterations],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the max neighborhood.
+%
+% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
+% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
+% Can be empty an array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+function arrayOut = MeanFilter(arrayIn,kernel,numIterations,device)
+ [arrayOut] = HIP.Cuda.Mex('MeanFilter',arrayIn,kernel,numIterations,device);
+end
diff --git a/src/MATLAB/+HIP/@Cuda/MedianFilter.m b/src/MATLAB/+HIP/@Cuda/MedianFilter.m
index 28cbc93..719c233 100644
--- a/src/MATLAB/+HIP/@Cuda/MedianFilter.m
+++ b/src/MATLAB/+HIP/@Cuda/MedianFilter.m
@@ -1,22 +1,22 @@
-% MedianFilter - This will calculate the median for each neighborhood defined by the kernel.
-% arrayOut = HIP.Cuda.MedianFilter(arrayIn,kernel,[numIterations],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the max neighborhood.
-%
-% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
-% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
-% Can be empty an array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-function arrayOut = MedianFilter(arrayIn,kernel,numIterations,device)
- [arrayOut] = HIP.Cuda.Mex('MedianFilter',arrayIn,kernel,numIterations,device);
-end
+% MedianFilter - This will calculate the median for each neighborhood defined by the kernel.
+% arrayOut = HIP.Cuda.MedianFilter(arrayIn,kernel,[numIterations],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the max neighborhood.
+%
+% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
+% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
+% Can be empty an array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+function arrayOut = MedianFilter(arrayIn,kernel,numIterations,device)
+ [arrayOut] = HIP.Cuda.Mex('MedianFilter',arrayIn,kernel,numIterations,device);
+end
diff --git a/src/MATLAB/+HIP/@Cuda/Mex.mexw64 b/src/MATLAB/+HIP/@Cuda/Mex.mexw64
index cb4a5d0..21d8408 100644
--- a/src/MATLAB/+HIP/@Cuda/Mex.mexw64
+++ b/src/MATLAB/+HIP/@Cuda/Mex.mexw64
@@ -1,3 +1,3 @@
version https://git-lfs.github.com/spec/v1
-oid sha256:cdb438ba333536eccf6069eb1b9d794788f4a892c6c6f6a455247ac94cdbb129
-size 10299392
+oid sha256:2c56c475050e469809d1f10e6fca2f7a6ec92668d72913bbd6981ae2f2da8e4a
+size 10274816
diff --git a/src/MATLAB/+HIP/@Cuda/MinFilter.m b/src/MATLAB/+HIP/@Cuda/MinFilter.m
index 9513b84..2a29f8d 100644
--- a/src/MATLAB/+HIP/@Cuda/MinFilter.m
+++ b/src/MATLAB/+HIP/@Cuda/MinFilter.m
@@ -1,22 +1,22 @@
-% MinFilter - This will set each pixel/voxel to the max value of the neighborhood defined by the given kernel.
-% arrayOut = HIP.Cuda.MinFilter(arrayIn,kernel,[numIterations],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the max neighborhood.
-%
-% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
-% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
-% Can be empty an array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-function arrayOut = MinFilter(arrayIn,kernel,numIterations,device)
- [arrayOut] = HIP.Cuda.Mex('MinFilter',arrayIn,kernel,numIterations,device);
-end
+% MinFilter - This will set each pixel/voxel to the max value of the neighborhood defined by the given kernel.
+% arrayOut = HIP.Cuda.MinFilter(arrayIn,kernel,[numIterations],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the max neighborhood.
+%
+% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
+% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
+% Can be empty an array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+function arrayOut = MinFilter(arrayIn,kernel,numIterations,device)
+ [arrayOut] = HIP.Cuda.Mex('MinFilter',arrayIn,kernel,numIterations,device);
+end
diff --git a/src/MATLAB/+HIP/@Cuda/MinMax.m b/src/MATLAB/+HIP/@Cuda/MinMax.m
index ee05695..ce2847b 100644
--- a/src/MATLAB/+HIP/@Cuda/MinMax.m
+++ b/src/MATLAB/+HIP/@Cuda/MinMax.m
@@ -1,15 +1,15 @@
-% MinMax - This returns the global min and max values.
-% [minOut,maxOut] = HIP.Cuda.MinMax(arrayIn,[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% minOut = This is the minimum value found in the input.
-% maxOut = This is the maximum value found in the input.
-function [minOut,maxOut] = MinMax(arrayIn,device)
- [minOut,maxOut] = HIP.Cuda.Mex('MinMax',arrayIn,device);
-end
+% MinMax - This returns the global min and max values.
+% [minOut,maxOut] = HIP.Cuda.MinMax(arrayIn,[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% minOut = This is the minimum value found in the input.
+% maxOut = This is the maximum value found in the input.
+function [minOut,maxOut] = MinMax(arrayIn,device)
+ [minOut,maxOut] = HIP.Cuda.Mex('MinMax',arrayIn,device);
+end
diff --git a/src/MATLAB/+HIP/@Cuda/MultiplySum.m b/src/MATLAB/+HIP/@Cuda/MultiplySum.m
index 3499c3b..9d6d421 100644
--- a/src/MATLAB/+HIP/@Cuda/MultiplySum.m
+++ b/src/MATLAB/+HIP/@Cuda/MultiplySum.m
@@ -1,22 +1,22 @@
-% MultiplySum - Multiplies the kernel with the neighboring values and sums these new values.
-% arrayOut = HIP.Cuda.MultiplySum(arrayIn,kernel,[numIterations],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the max neighborhood.
-%
-% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
-% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
-% Can be empty an array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-function arrayOut = MultiplySum(arrayIn,kernel,numIterations,device)
- [arrayOut] = HIP.Cuda.Mex('MultiplySum',arrayIn,kernel,numIterations,device);
-end
+% MultiplySum - Multiplies the kernel with the neighboring values and sums these new values.
+% arrayOut = HIP.Cuda.MultiplySum(arrayIn,kernel,[numIterations],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the max neighborhood.
+%
+% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
+% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
+% Can be empty an array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+function arrayOut = MultiplySum(arrayIn,kernel,numIterations,device)
+ [arrayOut] = HIP.Cuda.Mex('MultiplySum',arrayIn,kernel,numIterations,device);
+end
diff --git a/src/MATLAB/+HIP/@Cuda/Opener.m b/src/MATLAB/+HIP/@Cuda/Opener.m
index 7f53f8e..a86ff7b 100644
--- a/src/MATLAB/+HIP/@Cuda/Opener.m
+++ b/src/MATLAB/+HIP/@Cuda/Opener.m
@@ -1,22 +1,22 @@
-% Opener - This kernel will erode follow by a dilation.
-% arrayOut = HIP.Cuda.Opener(arrayIn,kernel,[numIterations],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the max neighborhood.
-%
-% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
-% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
-% Can be empty an array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-function arrayOut = Opener(arrayIn,kernel,numIterations,device)
- [arrayOut] = HIP.Cuda.Mex('Opener',arrayIn,kernel,numIterations,device);
-end
+% Opener - This kernel will erode follow by a dilation.
+% arrayOut = HIP.Cuda.Opener(arrayIn,kernel,[numIterations],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the max neighborhood.
+%
+% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
+% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
+% Can be empty an array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+function arrayOut = Opener(arrayIn,kernel,numIterations,device)
+ [arrayOut] = HIP.Cuda.Mex('Opener',arrayIn,kernel,numIterations,device);
+end
diff --git a/src/MATLAB/+HIP/@Cuda/StdFilter.m b/src/MATLAB/+HIP/@Cuda/StdFilter.m
index ba66eec..5cabc56 100644
--- a/src/MATLAB/+HIP/@Cuda/StdFilter.m
+++ b/src/MATLAB/+HIP/@Cuda/StdFilter.m
@@ -1,22 +1,22 @@
-% StdFilter - This will take the standard deviation of the given neighborhood.
-% arrayOut = HIP.Cuda.StdFilter(arrayIn,kernel,[numIterations],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the max neighborhood.
-%
-% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
-% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
-% Can be empty an array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-function arrayOut = StdFilter(arrayIn,kernel,numIterations,device)
- [arrayOut] = HIP.Cuda.Mex('StdFilter',arrayIn,kernel,numIterations,device);
-end
+% StdFilter - This will take the standard deviation of the given neighborhood.
+% arrayOut = HIP.Cuda.StdFilter(arrayIn,kernel,[numIterations],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the max neighborhood.
+%
+% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
+% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
+% Can be empty an array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+function arrayOut = StdFilter(arrayIn,kernel,numIterations,device)
+ [arrayOut] = HIP.Cuda.Mex('StdFilter',arrayIn,kernel,numIterations,device);
+end
diff --git a/src/MATLAB/+HIP/@Cuda/Sum.m b/src/MATLAB/+HIP/@Cuda/Sum.m
index 36d0e46..c765f8a 100644
--- a/src/MATLAB/+HIP/@Cuda/Sum.m
+++ b/src/MATLAB/+HIP/@Cuda/Sum.m
@@ -1,14 +1,14 @@
-% Sum - This sums up the entire array in.
-% valueOut = HIP.Cuda.Sum(arrayIn,[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% valueOut = This is the summation of the entire array.
-function valueOut = Sum(arrayIn,device)
- [valueOut] = HIP.Cuda.Mex('Sum',arrayIn,device);
-end
+% Sum - This sums up the entire array in.
+% valueOut = HIP.Cuda.Sum(arrayIn,[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% valueOut = This is the summation of the entire array.
+function valueOut = Sum(arrayIn,device)
+ [valueOut] = HIP.Cuda.Mex('Sum',arrayIn,device);
+end
diff --git a/src/MATLAB/+HIP/@Cuda/VarFilter.m b/src/MATLAB/+HIP/@Cuda/VarFilter.m
index 758d61d..cc1d665 100644
--- a/src/MATLAB/+HIP/@Cuda/VarFilter.m
+++ b/src/MATLAB/+HIP/@Cuda/VarFilter.m
@@ -1,22 +1,22 @@
-% VarFilter - This will take the variance deviation of the given neighborhood.
-% arrayOut = HIP.Cuda.VarFilter(arrayIn,kernel,[numIterations],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the max neighborhood.
-%
-% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
-% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
-% Can be empty an array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-function arrayOut = VarFilter(arrayIn,kernel,numIterations,device)
- [arrayOut] = HIP.Cuda.Mex('VarFilter',arrayIn,kernel,numIterations,device);
-end
+% VarFilter - This will take the variance deviation of the given neighborhood.
+% arrayOut = HIP.Cuda.VarFilter(arrayIn,kernel,[numIterations],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the max neighborhood.
+%
+% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
+% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
+% Can be empty an array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+function arrayOut = VarFilter(arrayIn,kernel,numIterations,device)
+ [arrayOut] = HIP.Cuda.Mex('VarFilter',arrayIn,kernel,numIterations,device);
+end
diff --git a/src/MATLAB/+HIP/@Cuda/WienerFilter.m b/src/MATLAB/+HIP/@Cuda/WienerFilter.m
index bc8ccd0..5e8fbcc 100644
--- a/src/MATLAB/+HIP/@Cuda/WienerFilter.m
+++ b/src/MATLAB/+HIP/@Cuda/WienerFilter.m
@@ -1,22 +1,22 @@
-% WienerFilter - A Wiener filter aims to denoise an image in a linear fashion.
-% arrayOut = HIP.Cuda.WienerFilter(arrayIn,[kernel],[noiseVariance],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel (optional) = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the neighborhood.
-% This can be an empty array [] and which will use a 3x3x3 neighborhood (or equivalent given input dimension).
-%
-% noiseVariance (optional) = This is the expected variance of the noise.
-% This should be a scalar value or an empty array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-function arrayOut = WienerFilter(arrayIn,kernel,noiseVariance,device)
- [arrayOut] = HIP.Cuda.Mex('WienerFilter',arrayIn,kernel,noiseVariance,device);
-end
+% WienerFilter - A Wiener filter aims to denoise an image in a linear fashion.
+% arrayOut = HIP.Cuda.WienerFilter(arrayIn,[kernel],[noiseVariance],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel (optional) = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the neighborhood.
+% This can be an empty array [] and which will use a 3x3x3 neighborhood (or equivalent given input dimension).
+%
+% noiseVariance (optional) = This is the expected variance of the noise.
+% This should be a scalar value or an empty array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+function arrayOut = WienerFilter(arrayIn,kernel,noiseVariance,device)
+ [arrayOut] = HIP.Cuda.Mex('WienerFilter',arrayIn,kernel,noiseVariance,device);
+end
diff --git a/src/MATLAB/+HIP/Closure.m b/src/MATLAB/+HIP/Closure.m
index fe80d7b..0493722 100644
--- a/src/MATLAB/+HIP/Closure.m
+++ b/src/MATLAB/+HIP/Closure.m
@@ -1,28 +1,28 @@
-% Closure - This kernel will dilate follow by an erosion.
-% arrayOut = HIP.Closure(arrayIn,kernel,[numIterations],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the max neighborhood.
-%
-% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
-% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
-% Can be empty an array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-
-function arrayOut = Closure(arrayIn,kernel,numIterations,device)
- try
- arrayOut = HIP.Cuda.Closure(arrayIn,kernel,numIterations,device);
- catch errMsg
- warning(errMsg.message);
- arrayOut = HIP.Local.Closure(arrayIn,kernel,numIterations,device);
- end
-end
+% Closure - This kernel will dilate follow by an erosion.
+% arrayOut = HIP.Closure(arrayIn,kernel,[numIterations],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the max neighborhood.
+%
+% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
+% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
+% Can be empty an array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+
+function arrayOut = Closure(arrayIn,kernel,numIterations,device)
+ try
+ arrayOut = HIP.Cuda.Closure(arrayIn,kernel,numIterations,device);
+ catch errMsg
+ warning(errMsg.message);
+ arrayOut = HIP.Local.Closure(arrayIn,kernel,numIterations,device);
+ end
+end
diff --git a/src/MATLAB/+HIP/ElementWiseDifference.m b/src/MATLAB/+HIP/ElementWiseDifference.m
index d8ed3e0..bd984bd 100644
--- a/src/MATLAB/+HIP/ElementWiseDifference.m
+++ b/src/MATLAB/+HIP/ElementWiseDifference.m
@@ -1,24 +1,24 @@
-% ElementWiseDifference - This subtracts the second array from the first, element by element (A-B).
-% arrayOut = HIP.ElementWiseDifference(array1In,array2In,[device])
-% image1In = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% image2In = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-
-function arrayOut = ElementWiseDifference(array1In,array2In,device)
- try
- arrayOut = HIP.Cuda.ElementWiseDifference(array1In,array2In,device);
- catch errMsg
- warning(errMsg.message);
- arrayOut = HIP.Local.ElementWiseDifference(array1In,array2In,device);
- end
-end
+% ElementWiseDifference - This subtracts the second array from the first, element by element (A-B).
+% arrayOut = HIP.ElementWiseDifference(array1In,array2In,[device])
+% image1In = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% image2In = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+
+function arrayOut = ElementWiseDifference(array1In,array2In,device)
+ try
+ arrayOut = HIP.Cuda.ElementWiseDifference(array1In,array2In,device);
+ catch errMsg
+ warning(errMsg.message);
+ arrayOut = HIP.Local.ElementWiseDifference(array1In,array2In,device);
+ end
+end
diff --git a/src/MATLAB/+HIP/EntropyFilter.m b/src/MATLAB/+HIP/EntropyFilter.m
index 600fc33..767d971 100644
--- a/src/MATLAB/+HIP/EntropyFilter.m
+++ b/src/MATLAB/+HIP/EntropyFilter.m
@@ -1,24 +1,24 @@
-% EntropyFilter - This calculates the entropy within the neighborhood given by the kernel.
-% arrayOut = HIP.EntropyFilter(arrayIn,kernel,[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the max neighborhood.
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-
-function arrayOut = EntropyFilter(arrayIn,kernel,device)
- try
- arrayOut = HIP.Cuda.EntropyFilter(arrayIn,kernel,device);
- catch errMsg
- warning(errMsg.message);
- arrayOut = HIP.Local.EntropyFilter(arrayIn,kernel,device);
- end
-end
+% EntropyFilter - This calculates the entropy within the neighborhood given by the kernel.
+% arrayOut = HIP.EntropyFilter(arrayIn,kernel,[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the max neighborhood.
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+
+function arrayOut = EntropyFilter(arrayIn,kernel,device)
+ try
+ arrayOut = HIP.Cuda.EntropyFilter(arrayIn,kernel,device);
+ catch errMsg
+ warning(errMsg.message);
+ arrayOut = HIP.Local.EntropyFilter(arrayIn,kernel,device);
+ end
+end
diff --git a/src/MATLAB/+HIP/Gaussian.m b/src/MATLAB/+HIP/Gaussian.m
index 86cef7b..efb4142 100644
--- a/src/MATLAB/+HIP/Gaussian.m
+++ b/src/MATLAB/+HIP/Gaussian.m
@@ -1,27 +1,27 @@
-% Gaussian - Gaussian smoothing.
-% arrayOut = HIP.Gaussian(arrayIn,sigmas,[numIterations],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% Sigmas = This should be an array of three positive values that represent the standard deviation of a Gaussian curve.
-% Zeros (0) in this array will not smooth in that direction.
-%
-% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
-% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
-% Can be empty an array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-
-function arrayOut = Gaussian(arrayIn,sigmas,numIterations,device)
- try
- arrayOut = HIP.Cuda.Gaussian(arrayIn,sigmas,numIterations,device);
- catch errMsg
- warning(errMsg.message);
- arrayOut = HIP.Local.Gaussian(arrayIn,sigmas,numIterations,device);
- end
-end
+% Gaussian - Gaussian smoothing.
+% arrayOut = HIP.Gaussian(arrayIn,sigmas,[numIterations],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% Sigmas = This should be an array of three positive values that represent the standard deviation of a Gaussian curve.
+% Zeros (0) in this array will not smooth in that direction.
+%
+% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
+% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
+% Can be empty an array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+
+function arrayOut = Gaussian(arrayIn,sigmas,numIterations,device)
+ try
+ arrayOut = HIP.Cuda.Gaussian(arrayIn,sigmas,numIterations,device);
+ catch errMsg
+ warning(errMsg.message);
+ arrayOut = HIP.Local.Gaussian(arrayIn,sigmas,numIterations,device);
+ end
+end
diff --git a/src/MATLAB/+HIP/GetMinMax.m b/src/MATLAB/+HIP/GetMinMax.m
index b50e4d9..642f4d9 100644
--- a/src/MATLAB/+HIP/GetMinMax.m
+++ b/src/MATLAB/+HIP/GetMinMax.m
@@ -1,19 +1,19 @@
-% GetMinMax - This function finds the lowest and highest value in the array that is passed in.
-% [minValue,maxValue] = HIP.GetMinMax(arrayIn,[device])
-% imageIn = This is a one to five dimensional array.
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% minValue = This is the lowest value found in the array.
-% maxValue = This is the highest value found in the array.
-
-function [minValue,maxValue] = GetMinMax(arrayIn,device)
- try
- [minValue,maxValue] = HIP.Cuda.GetMinMax(arrayIn,device);
- catch errMsg
- warning(errMsg.message);
- [minValue,maxValue] = HIP.Local.GetMinMax(arrayIn,device);
- end
-end
+% GetMinMax - This function finds the lowest and highest value in the array that is passed in.
+% [minValue,maxValue] = HIP.GetMinMax(arrayIn,[device])
+% imageIn = This is a one to five dimensional array.
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% minValue = This is the lowest value found in the array.
+% maxValue = This is the highest value found in the array.
+
+function [minValue,maxValue] = GetMinMax(arrayIn,device)
+ try
+ [minValue,maxValue] = HIP.Cuda.GetMinMax(arrayIn,device);
+ catch errMsg
+ warning(errMsg.message);
+ [minValue,maxValue] = HIP.Local.GetMinMax(arrayIn,device);
+ end
+end
diff --git a/src/MATLAB/+HIP/Help.m b/src/MATLAB/+HIP/Help.m
index b2aeb1c..ade8af0 100644
--- a/src/MATLAB/+HIP/Help.m
+++ b/src/MATLAB/+HIP/Help.m
@@ -1,5 +1,5 @@
-% Help - Help on a specified command.
-% HIP.Help(command)
-% Print detailed usage information for the specified command.
-function Help(command)
-end
+% Help - Help on a specified command.
+% HIP.Help(command)
+% Print detailed usage information for the specified command.
+function Help(command)
+end
diff --git a/src/MATLAB/+HIP/HighPassFilter.m b/src/MATLAB/+HIP/HighPassFilter.m
index f34c3fb..de70751 100644
--- a/src/MATLAB/+HIP/HighPassFilter.m
+++ b/src/MATLAB/+HIP/HighPassFilter.m
@@ -1,23 +1,23 @@
-% HighPassFilter - Filters out low frequency by subtracting a Gaussian blurred version of the input based on the sigmas provided.
-% arrayOut = HIP.HighPassFilter(arrayIn,sigmas,[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% Sigmas = This should be an array of three positive values that represent the standard deviation of a Gaussian curve.
-% Zeros (0) in this array will not smooth in that direction.
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-
-function arrayOut = HighPassFilter(arrayIn,sigmas,device)
- try
- arrayOut = HIP.Cuda.HighPassFilter(arrayIn,sigmas,device);
- catch errMsg
- warning(errMsg.message);
- arrayOut = HIP.Local.HighPassFilter(arrayIn,sigmas,device);
- end
-end
+% HighPassFilter - Filters out low frequency by subtracting a Gaussian blurred version of the input based on the sigmas provided.
+% arrayOut = HIP.HighPassFilter(arrayIn,sigmas,[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% Sigmas = This should be an array of three positive values that represent the standard deviation of a Gaussian curve.
+% Zeros (0) in this array will not smooth in that direction.
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+
+function arrayOut = HighPassFilter(arrayIn,sigmas,device)
+ try
+ arrayOut = HIP.Cuda.HighPassFilter(arrayIn,sigmas,device);
+ catch errMsg
+ warning(errMsg.message);
+ arrayOut = HIP.Local.HighPassFilter(arrayIn,sigmas,device);
+ end
+end
diff --git a/src/MATLAB/+HIP/Info.m b/src/MATLAB/+HIP/Info.m
index c73ddaa..eaa9f3b 100644
--- a/src/MATLAB/+HIP/Info.m
+++ b/src/MATLAB/+HIP/Info.m
@@ -1,16 +1,16 @@
-% Info - Get information on all available mex commands.
-% commandInfo = HIP.Info()
-% Returns commandInfo structure array containing information on all mex commands.
-% commandInfo.command - Command string
-% commandInfo.outArgs - Cell array of output arguments
-% commandInfo.inArgs - Cell array of input arguments
-% commandInfo.helpLines - Cell array of input arguments
-
-function commandInfo = Info()
- try
- commandInfo = HIP.Cuda.Info();
- catch errMsg
- warning(errMsg.message);
- commandInfo = HIP.Local.Info();
- end
-end
+% Info - Get information on all available mex commands.
+% commandInfo = HIP.Info()
+% Returns commandInfo structure array containing information on all mex commands.
+% commandInfo.command - Command string
+% commandInfo.outArgs - Cell array of output arguments
+% commandInfo.inArgs - Cell array of input arguments
+% commandInfo.helpLines - Cell array of input arguments
+
+function commandInfo = Info()
+ try
+ commandInfo = HIP.Cuda.Info();
+ catch errMsg
+ warning(errMsg.message);
+ commandInfo = HIP.Local.Info();
+ end
+end
diff --git a/src/MATLAB/+HIP/LoG.m b/src/MATLAB/+HIP/LoG.m
index b67f335..faf7317 100644
--- a/src/MATLAB/+HIP/LoG.m
+++ b/src/MATLAB/+HIP/LoG.m
@@ -1,23 +1,23 @@
-% LoG - Apply a Lapplacian of Gaussian filter with the given sigmas.
-% arrayOut = HIP.LoG(arrayIn,sigmas,[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% Sigmas = This should be an array of three positive values that represent the standard deviation of a Gaussian curve.
-% Zeros (0) in this array will not smooth in that direction.
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-
-function arrayOut = LoG(arrayIn,sigmas,device)
- try
- arrayOut = HIP.Cuda.LoG(arrayIn,sigmas,device);
- catch errMsg
- warning(errMsg.message);
- arrayOut = HIP.Local.LoG(arrayIn,sigmas,device);
- end
-end
+% LoG - Apply a Lapplacian of Gaussian filter with the given sigmas.
+% arrayOut = HIP.LoG(arrayIn,sigmas,[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% Sigmas = This should be an array of three positive values that represent the standard deviation of a Gaussian curve.
+% Zeros (0) in this array will not smooth in that direction.
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+
+function arrayOut = LoG(arrayIn,sigmas,device)
+ try
+ arrayOut = HIP.Cuda.LoG(arrayIn,sigmas,device);
+ catch errMsg
+ warning(errMsg.message);
+ arrayOut = HIP.Local.LoG(arrayIn,sigmas,device);
+ end
+end
diff --git a/src/MATLAB/+HIP/MaxFilter.m b/src/MATLAB/+HIP/MaxFilter.m
index 6c4a71b..31df730 100644
--- a/src/MATLAB/+HIP/MaxFilter.m
+++ b/src/MATLAB/+HIP/MaxFilter.m
@@ -1,28 +1,28 @@
-% MaxFilter - This will set each pixel/voxel to the max value of the neighborhood defined by the given kernel.
-% arrayOut = HIP.MaxFilter(arrayIn,kernel,[numIterations],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the max neighborhood.
-%
-% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
-% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
-% Can be empty an array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-
-function arrayOut = MaxFilter(arrayIn,kernel,numIterations,device)
- try
- arrayOut = HIP.Cuda.MaxFilter(arrayIn,kernel,numIterations,device);
- catch errMsg
- warning(errMsg.message);
- arrayOut = HIP.Local.MaxFilter(arrayIn,kernel,numIterations,device);
- end
-end
+% MaxFilter - This will set each pixel/voxel to the max value of the neighborhood defined by the given kernel.
+% arrayOut = HIP.MaxFilter(arrayIn,kernel,[numIterations],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the max neighborhood.
+%
+% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
+% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
+% Can be empty an array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+
+function arrayOut = MaxFilter(arrayIn,kernel,numIterations,device)
+ try
+ arrayOut = HIP.Cuda.MaxFilter(arrayIn,kernel,numIterations,device);
+ catch errMsg
+ warning(errMsg.message);
+ arrayOut = HIP.Local.MaxFilter(arrayIn,kernel,numIterations,device);
+ end
+end
diff --git a/src/MATLAB/+HIP/MeanFilter.m b/src/MATLAB/+HIP/MeanFilter.m
index ffb7569..c6fbb10 100644
--- a/src/MATLAB/+HIP/MeanFilter.m
+++ b/src/MATLAB/+HIP/MeanFilter.m
@@ -1,28 +1,28 @@
-% MeanFilter - This will take the mean of the given neighborhood.
-% arrayOut = HIP.MeanFilter(arrayIn,kernel,[numIterations],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the max neighborhood.
-%
-% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
-% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
-% Can be empty an array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-
-function arrayOut = MeanFilter(arrayIn,kernel,numIterations,device)
- try
- arrayOut = HIP.Cuda.MeanFilter(arrayIn,kernel,numIterations,device);
- catch errMsg
- warning(errMsg.message);
- arrayOut = HIP.Local.MeanFilter(arrayIn,kernel,numIterations,device);
- end
-end
+% MeanFilter - This will take the mean of the given neighborhood.
+% arrayOut = HIP.MeanFilter(arrayIn,kernel,[numIterations],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the max neighborhood.
+%
+% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
+% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
+% Can be empty an array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+
+function arrayOut = MeanFilter(arrayIn,kernel,numIterations,device)
+ try
+ arrayOut = HIP.Cuda.MeanFilter(arrayIn,kernel,numIterations,device);
+ catch errMsg
+ warning(errMsg.message);
+ arrayOut = HIP.Local.MeanFilter(arrayIn,kernel,numIterations,device);
+ end
+end
diff --git a/src/MATLAB/+HIP/MedianFilter.m b/src/MATLAB/+HIP/MedianFilter.m
index 73209ee..8ea6f32 100644
--- a/src/MATLAB/+HIP/MedianFilter.m
+++ b/src/MATLAB/+HIP/MedianFilter.m
@@ -1,28 +1,28 @@
-% MedianFilter - This will calculate the median for each neighborhood defined by the kernel.
-% arrayOut = HIP.MedianFilter(arrayIn,kernel,[numIterations],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the max neighborhood.
-%
-% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
-% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
-% Can be empty an array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-
-function arrayOut = MedianFilter(arrayIn,kernel,numIterations,device)
- try
- arrayOut = HIP.Cuda.MedianFilter(arrayIn,kernel,numIterations,device);
- catch errMsg
- warning(errMsg.message);
- arrayOut = HIP.Local.MedianFilter(arrayIn,kernel,numIterations,device);
- end
-end
+% MedianFilter - This will calculate the median for each neighborhood defined by the kernel.
+% arrayOut = HIP.MedianFilter(arrayIn,kernel,[numIterations],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the max neighborhood.
+%
+% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
+% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
+% Can be empty an array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+
+function arrayOut = MedianFilter(arrayIn,kernel,numIterations,device)
+ try
+ arrayOut = HIP.Cuda.MedianFilter(arrayIn,kernel,numIterations,device);
+ catch errMsg
+ warning(errMsg.message);
+ arrayOut = HIP.Local.MedianFilter(arrayIn,kernel,numIterations,device);
+ end
+end
diff --git a/src/MATLAB/+HIP/MinFilter.m b/src/MATLAB/+HIP/MinFilter.m
index 6d72066..d7b8d7d 100644
--- a/src/MATLAB/+HIP/MinFilter.m
+++ b/src/MATLAB/+HIP/MinFilter.m
@@ -1,28 +1,28 @@
-% MinFilter - This will set each pixel/voxel to the max value of the neighborhood defined by the given kernel.
-% arrayOut = HIP.MinFilter(arrayIn,kernel,[numIterations],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the max neighborhood.
-%
-% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
-% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
-% Can be empty an array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-
-function arrayOut = MinFilter(arrayIn,kernel,numIterations,device)
- try
- arrayOut = HIP.Cuda.MinFilter(arrayIn,kernel,numIterations,device);
- catch errMsg
- warning(errMsg.message);
- arrayOut = HIP.Local.MinFilter(arrayIn,kernel,numIterations,device);
- end
-end
+% MinFilter - This will set each pixel/voxel to the max value of the neighborhood defined by the given kernel.
+% arrayOut = HIP.MinFilter(arrayIn,kernel,[numIterations],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the max neighborhood.
+%
+% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
+% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
+% Can be empty an array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+
+function arrayOut = MinFilter(arrayIn,kernel,numIterations,device)
+ try
+ arrayOut = HIP.Cuda.MinFilter(arrayIn,kernel,numIterations,device);
+ catch errMsg
+ warning(errMsg.message);
+ arrayOut = HIP.Local.MinFilter(arrayIn,kernel,numIterations,device);
+ end
+end
diff --git a/src/MATLAB/+HIP/MinMax.m b/src/MATLAB/+HIP/MinMax.m
index bc3888e..6ba7fb0 100644
--- a/src/MATLAB/+HIP/MinMax.m
+++ b/src/MATLAB/+HIP/MinMax.m
@@ -1,21 +1,21 @@
-% MinMax - This returns the global min and max values.
-% [minOut,maxOut] = HIP.MinMax(arrayIn,[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% minOut = This is the minimum value found in the input.
-% maxOut = This is the maximum value found in the input.
-
-function [minOut,maxOut] = MinMax(arrayIn,device)
- try
- [minOut,maxOut] = HIP.Cuda.MinMax(arrayIn,device);
- catch errMsg
- warning(errMsg.message);
- [minOut,maxOut] = HIP.Local.MinMax(arrayIn,device);
- end
-end
+% MinMax - This returns the global min and max values.
+% [minOut,maxOut] = HIP.MinMax(arrayIn,[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% minOut = This is the minimum value found in the input.
+% maxOut = This is the maximum value found in the input.
+
+function [minOut,maxOut] = MinMax(arrayIn,device)
+ try
+ [minOut,maxOut] = HIP.Cuda.MinMax(arrayIn,device);
+ catch errMsg
+ warning(errMsg.message);
+ [minOut,maxOut] = HIP.Local.MinMax(arrayIn,device);
+ end
+end
diff --git a/src/MATLAB/+HIP/MultiplySum.m b/src/MATLAB/+HIP/MultiplySum.m
index caa3155..14b1692 100644
--- a/src/MATLAB/+HIP/MultiplySum.m
+++ b/src/MATLAB/+HIP/MultiplySum.m
@@ -1,28 +1,28 @@
-% MultiplySum - Multiplies the kernel with the neighboring values and sums these new values.
-% arrayOut = HIP.MultiplySum(arrayIn,kernel,[numIterations],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the max neighborhood.
-%
-% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
-% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
-% Can be empty an array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-
-function arrayOut = MultiplySum(arrayIn,kernel,numIterations,device)
- try
- arrayOut = HIP.Cuda.MultiplySum(arrayIn,kernel,numIterations,device);
- catch errMsg
- warning(errMsg.message);
- arrayOut = HIP.Local.MultiplySum(arrayIn,kernel,numIterations,device);
- end
-end
+% MultiplySum - Multiplies the kernel with the neighboring values and sums these new values.
+% arrayOut = HIP.MultiplySum(arrayIn,kernel,[numIterations],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the max neighborhood.
+%
+% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
+% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
+% Can be empty an array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+
+function arrayOut = MultiplySum(arrayIn,kernel,numIterations,device)
+ try
+ arrayOut = HIP.Cuda.MultiplySum(arrayIn,kernel,numIterations,device);
+ catch errMsg
+ warning(errMsg.message);
+ arrayOut = HIP.Local.MultiplySum(arrayIn,kernel,numIterations,device);
+ end
+end
diff --git a/src/MATLAB/+HIP/Opener.m b/src/MATLAB/+HIP/Opener.m
index 2246b8a..f3e15b5 100644
--- a/src/MATLAB/+HIP/Opener.m
+++ b/src/MATLAB/+HIP/Opener.m
@@ -1,28 +1,28 @@
-% Opener - This kernel will erode follow by a dilation.
-% arrayOut = HIP.Opener(arrayIn,kernel,[numIterations],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the max neighborhood.
-%
-% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
-% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
-% Can be empty an array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-
-function arrayOut = Opener(arrayIn,kernel,numIterations,device)
- try
- arrayOut = HIP.Cuda.Opener(arrayIn,kernel,numIterations,device);
- catch errMsg
- warning(errMsg.message);
- arrayOut = HIP.Local.Opener(arrayIn,kernel,numIterations,device);
- end
-end
+% Opener - This kernel will erode follow by a dilation.
+% arrayOut = HIP.Opener(arrayIn,kernel,[numIterations],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the max neighborhood.
+%
+% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
+% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
+% Can be empty an array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+
+function arrayOut = Opener(arrayIn,kernel,numIterations,device)
+ try
+ arrayOut = HIP.Cuda.Opener(arrayIn,kernel,numIterations,device);
+ catch errMsg
+ warning(errMsg.message);
+ arrayOut = HIP.Local.Opener(arrayIn,kernel,numIterations,device);
+ end
+end
diff --git a/src/MATLAB/+HIP/StdFilter.m b/src/MATLAB/+HIP/StdFilter.m
index 46360e6..96cb3db 100644
--- a/src/MATLAB/+HIP/StdFilter.m
+++ b/src/MATLAB/+HIP/StdFilter.m
@@ -1,28 +1,28 @@
-% StdFilter - This will take the standard deviation of the given neighborhood.
-% arrayOut = HIP.StdFilter(arrayIn,kernel,[numIterations],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the max neighborhood.
-%
-% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
-% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
-% Can be empty an array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-
-function arrayOut = StdFilter(arrayIn,kernel,numIterations,device)
- try
- arrayOut = HIP.Cuda.StdFilter(arrayIn,kernel,numIterations,device);
- catch errMsg
- warning(errMsg.message);
- arrayOut = HIP.Local.StdFilter(arrayIn,kernel,numIterations,device);
- end
-end
+% StdFilter - This will take the standard deviation of the given neighborhood.
+% arrayOut = HIP.StdFilter(arrayIn,kernel,[numIterations],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the max neighborhood.
+%
+% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
+% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
+% Can be empty an array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+
+function arrayOut = StdFilter(arrayIn,kernel,numIterations,device)
+ try
+ arrayOut = HIP.Cuda.StdFilter(arrayIn,kernel,numIterations,device);
+ catch errMsg
+ warning(errMsg.message);
+ arrayOut = HIP.Local.StdFilter(arrayIn,kernel,numIterations,device);
+ end
+end
diff --git a/src/MATLAB/+HIP/Sum.m b/src/MATLAB/+HIP/Sum.m
index 3529691..2e06d38 100644
--- a/src/MATLAB/+HIP/Sum.m
+++ b/src/MATLAB/+HIP/Sum.m
@@ -1,20 +1,20 @@
-% Sum - This sums up the entire array in.
-% valueOut = HIP.Sum(arrayIn,[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% valueOut = This is the summation of the entire array.
-
-function valueOut = Sum(arrayIn,device)
- try
- valueOut = HIP.Cuda.Sum(arrayIn,device);
- catch errMsg
- warning(errMsg.message);
- valueOut = HIP.Local.Sum(arrayIn,device);
- end
-end
+% Sum - This sums up the entire array in.
+% valueOut = HIP.Sum(arrayIn,[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% valueOut = This is the summation of the entire array.
+
+function valueOut = Sum(arrayIn,device)
+ try
+ valueOut = HIP.Cuda.Sum(arrayIn,device);
+ catch errMsg
+ warning(errMsg.message);
+ valueOut = HIP.Local.Sum(arrayIn,device);
+ end
+end
diff --git a/src/MATLAB/+HIP/VarFilter.m b/src/MATLAB/+HIP/VarFilter.m
index 738cdbc..3c6b52b 100644
--- a/src/MATLAB/+HIP/VarFilter.m
+++ b/src/MATLAB/+HIP/VarFilter.m
@@ -1,28 +1,28 @@
-% VarFilter - This will take the variance deviation of the given neighborhood.
-% arrayOut = HIP.VarFilter(arrayIn,kernel,[numIterations],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the max neighborhood.
-%
-% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
-% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
-% Can be empty an array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-
-function arrayOut = VarFilter(arrayIn,kernel,numIterations,device)
- try
- arrayOut = HIP.Cuda.VarFilter(arrayIn,kernel,numIterations,device);
- catch errMsg
- warning(errMsg.message);
- arrayOut = HIP.Local.VarFilter(arrayIn,kernel,numIterations,device);
- end
-end
+% VarFilter - This will take the variance deviation of the given neighborhood.
+% arrayOut = HIP.VarFilter(arrayIn,kernel,[numIterations],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the max neighborhood.
+%
+% numIterations (optional) = This is the number of iterations to run the max filter for a given position.
+% This is useful for growing regions by the shape of the structuring element or for very large neighborhoods.
+% Can be empty an array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+
+function arrayOut = VarFilter(arrayIn,kernel,numIterations,device)
+ try
+ arrayOut = HIP.Cuda.VarFilter(arrayIn,kernel,numIterations,device);
+ catch errMsg
+ warning(errMsg.message);
+ arrayOut = HIP.Local.VarFilter(arrayIn,kernel,numIterations,device);
+ end
+end
diff --git a/src/MATLAB/+HIP/WienerFilter.m b/src/MATLAB/+HIP/WienerFilter.m
index da0a607..67475b2 100644
--- a/src/MATLAB/+HIP/WienerFilter.m
+++ b/src/MATLAB/+HIP/WienerFilter.m
@@ -1,28 +1,28 @@
-% WienerFilter - A Wiener filter aims to denoise an image in a linear fashion.
-% arrayOut = HIP.WienerFilter(arrayIn,[kernel],[noiseVariance],[device])
-% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
-% The spatial dimensions will have the kernel applied. The last two dimensions will determine
-% how to stride or jump to the next spatial block.
-%
-% kernel (optional) = This is a one to three dimensional array that will be used to determine neighborhood operations.
-% In this case, the positions in the kernel that do not equal zeros will be evaluated.
-% In other words, this can be viewed as a structuring element for the neighborhood.
-% This can be an empty array [] and which will use a 3x3x3 neighborhood (or equivalent given input dimension).
-%
-% noiseVariance (optional) = This is the expected variance of the noise.
-% This should be a scalar value or an empty array [].
-%
-% device (optional) = Use this if you have multiple devices and want to select one explicitly.
-% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
-% the data across multiple devices.
-%
-% imageOut = This will be an array of the same type and shape as the input array.
-
-function arrayOut = WienerFilter(arrayIn,kernel,noiseVariance,device)
- try
- arrayOut = HIP.Cuda.WienerFilter(arrayIn,kernel,noiseVariance,device);
- catch errMsg
- warning(errMsg.message);
- arrayOut = HIP.Local.WienerFilter(arrayIn,kernel,noiseVariance,device);
- end
-end
+% WienerFilter - A Wiener filter aims to denoise an image in a linear fashion.
+% arrayOut = HIP.WienerFilter(arrayIn,[kernel],[noiseVariance],[device])
+% imageIn = This is a one to five dimensional array. The first three dimensions are treated as spatial.
+% The spatial dimensions will have the kernel applied. The last two dimensions will determine
+% how to stride or jump to the next spatial block.
+%
+% kernel (optional) = This is a one to three dimensional array that will be used to determine neighborhood operations.
+% In this case, the positions in the kernel that do not equal zeros will be evaluated.
+% In other words, this can be viewed as a structuring element for the neighborhood.
+% This can be an empty array [] and which will use a 3x3x3 neighborhood (or equivalent given input dimension).
+%
+% noiseVariance (optional) = This is the expected variance of the noise.
+% This should be a scalar value or an empty array [].
+%
+% device (optional) = Use this if you have multiple devices and want to select one explicitly.
+% Setting this to [] allows the algorithm to either pick the best device and/or will try to split
+% the data across multiple devices.
+%
+% imageOut = This will be an array of the same type and shape as the input array.
+
+function arrayOut = WienerFilter(arrayIn,kernel,noiseVariance,device)
+ try
+ arrayOut = HIP.Cuda.WienerFilter(arrayIn,kernel,noiseVariance,device);
+ catch errMsg
+ warning(errMsg.message);
+ arrayOut = HIP.Local.WienerFilter(arrayIn,kernel,noiseVariance,device);
+ end
+end
diff --git a/src/c/CudaImageProcessor.vcxproj b/src/c/CudaImageProcessor.vcxproj
index 9ec9de4..45becbe 100644
--- a/src/c/CudaImageProcessor.vcxproj
+++ b/src/c/CudaImageProcessor.vcxproj
@@ -1,203 +1,203 @@
-﻿
-
-
-
- Debug
- x64
-
-
- Release
- x64
-
-
-
- {3E663AF2-4E6F-487B-9072-CCA90C66A822}
- v4.5.2
- ManagedCProj
- CudaImageProcessor
- 8.1
-
-
-
- StaticLibrary
- true
- v140
- false
- MultiByte
-
-
- StaticLibrary
- false
- v140
- false
- MultiByte
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- true
- $(SolutionDir)Output\$(ProjectName)\$(Configuration)_$(PlatformName)\
- $(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\
- CudaImageProcessor_d
- .lib
-
-
- false
- $(SolutionDir)Output\$(ProjectName)\$(Configuration)_$(PlatformName)\
- $(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\
- CudaImageProcessor
- .lib
-
-
-
- Level3
- Disabled
- _DEBUG;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)
- $(CudaToolkitIncludeDir)
- true
- true
-
-
-
-
-
- true
-
-
- 64
-
-
- MDd
- compute_30,sm_30;compute_35,sm_35;compute_37,sm_37;compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;
- -Xcompiler /openmp %(AdditionalOptions)
-
-
- cudart_static.lib
- $(CudaToolkitLibDir)
-
-
-
-
- Level3
- NDEBUG;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)
- $(CudaToolkitIncludeDir)
- true
- Speed
-
-
-
-
-
- true
-
-
- 64
-
-
- MD
- compute_30,sm_30;compute_35,sm_35;compute_37,sm_37;compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;
- -Xcompiler /openmp %(AdditionalOptions)
-
-
- cudart_static.lib
- $(CudaToolkitLibDir)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- CppCode
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Document
-
-
- Document
-
-
- Document
-
-
- Document
-
-
- Document
-
-
- Document
-
-
- Document
-
-
-
-
- Document
-
-
- Document
-
-
- Document
-
-
- Document
-
-
-
-
-
-
+﻿
+
+
+
+ Debug
+ x64
+
+
+ Release
+ x64
+
+
+
+ {3E663AF2-4E6F-487B-9072-CCA90C66A822}
+ v4.5.2
+ ManagedCProj
+ CudaImageProcessor
+ 10.0.15063.0
+
+
+
+ StaticLibrary
+ true
+ v141
+ false
+ MultiByte
+
+
+ StaticLibrary
+ false
+ v141
+ false
+ MultiByte
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ true
+ $(SolutionDir)Output\$(ProjectName)\$(Configuration)_$(PlatformName)\
+ $(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\
+ CudaImageProcessor_d
+ .lib
+
+
+ false
+ $(SolutionDir)Output\$(ProjectName)\$(Configuration)_$(PlatformName)\
+ $(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\
+ CudaImageProcessor
+ .lib
+
+
+
+ Level3
+ Disabled
+ _DEBUG;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)
+ $(CudaToolkitIncludeDir)
+ true
+ true
+
+
+
+
+
+ true
+
+
+ 64
+
+
+ MDd
+ compute_30,sm_30;compute_35,sm_35;compute_37,sm_37;compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;
+ -Xcompiler /openmp %(AdditionalOptions)
+
+
+ cudart_static.lib
+ $(CudaToolkitLibDir)
+
+
+
+
+ Level3
+ NDEBUG;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)
+ $(CudaToolkitIncludeDir)
+ true
+ Speed
+
+
+
+
+
+ true
+
+
+ 64
+
+
+ MD
+ compute_30,sm_30;compute_35,sm_35;compute_37,sm_37;compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;
+ -Xcompiler /openmp %(AdditionalOptions)
+
+
+ cudart_static.lib
+ $(CudaToolkitLibDir)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ CppCode
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Document
+
+
+ Document
+
+
+ Document
+
+
+ Document
+
+
+ Document
+
+
+ Document
+
+
+ Document
+
+
+
+
+ Document
+
+
+ Document
+
+
+ Document
+
+
+ Document
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/c/CudaMex.vcxproj b/src/c/CudaMex.vcxproj
index 917c42b..aac842b 100644
--- a/src/c/CudaMex.vcxproj
+++ b/src/c/CudaMex.vcxproj
@@ -1,139 +1,142 @@
-﻿
-
-
-
- Debug
- x64
-
-
- Release
- x64
-
-
-
- {6698E8EC-49D9-421E-AA87-5BCC6B466347}
- CudaMex
-
-
-
- DynamicLibrary
- true
- v140
- MultiByte
-
-
- DynamicLibrary
- false
- v140
- true
- MultiByte
-
-
-
-
-
-
-
-
-
-
-
-
- $(SolutionDir)Output\$(ProjectName)\$(Configuration)_$(PlatformName)\
- $(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\
- .dll
-
-
- $(SolutionDir)Output\$(ProjectName)\$(Configuration)_$(PlatformName)\
- $(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\
- .dll
-
-
-
- Level3
- Disabled
- true
- $(MATLAB_DIR)\extern\include;external
- _WINDLL;_CRT_SECURE_NO_WARNINGS;_CRTDBG_MAP_ALLOC;%(PreprocessorDefinitions)
- false
-
-
- true
- $(MATLAB_DIR)\extern\lib\win64\microsoft;$(SolutionDir)Output\CudaImageProcessor\$(Configuration)_$(PlatformName)\
- CudaImageProcessor_d.lib;libmx.lib;libmex.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)
- $(SolutionDir)Mex\CudaMex.def
-
-
+﻿
+
+
+
+ Debug
+ x64
+
+
+ Release
+ x64
+
+
+
+ {6698E8EC-49D9-421E-AA87-5BCC6B466347}
+ CudaMex
+ 10.0.15063.0
+
+
+
+ DynamicLibrary
+ true
+ v141
+ MultiByte
+
+
+ DynamicLibrary
+ false
+ v141
+ true
+ MultiByte
+
+
+
+
+
+
+
+
+
+
+
+
+ $(SolutionDir)Output\$(ProjectName)\$(Configuration)_$(PlatformName)\
+ $(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\
+ .dll
+
+
+ $(SolutionDir)Output\$(ProjectName)\$(Configuration)_$(PlatformName)\
+ $(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\
+ .dll
+ $(VC_IncludePath);$(WindowsSDK_IncludePath);C:\Program Files\MATLAB\R2017b\extern\include
+ $(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);$(NETFXKitsDir)Lib\um\x64;C:\Program Files\MATLAB\R2017b\extern\lib\win64\microsoft
+
+
+
+ Level3
+ Disabled
+ true
+ $(MATLAB_DIR)\extern\include;external
+ _WINDLL;_CRT_SECURE_NO_WARNINGS;_CRTDBG_MAP_ALLOC;%(PreprocessorDefinitions)
+ false
+
+
+ true
+ $(MATLAB_DIR)\extern\lib\win64\microsoft;$(SolutionDir)Output\CudaImageProcessor\$(Configuration)_$(PlatformName)\
+ CudaImageProcessor_d.lib;libmx.lib;libmex.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)
+ $(SolutionDir)Mex\CudaMex.def
+
+ echo copy $(OutDir)CudaMex.dll "$(ProjectDir)Mex.mexw64"
-copy $(OutDir)CudaMex.dll "$(ProjectDir)Mex.mexw64"
-
-
-
-
- Level3
- MaxSpeed
- true
- true
- true
- $(MATLAB_DIR)\extern\include;external
- _WINDLL;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)
- false
-
-
- true
- true
- true
- $(MATLAB_DIR)\extern\lib\win64\microsoft;$(SolutionDir)Output\CudaImageProcessor\$(Configuration)_$(PlatformName)\
- CudaImageProcessor.lib;libmx.lib;libmex.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)
- $(SolutionDir)Mex\CudaMex.def
-
-
+copy $(OutDir)CudaMex.dll "$(ProjectDir)Mex.mexw64"
+
+
+
+
+ Level3
+ MaxSpeed
+ true
+ true
+ true
+ $(MATLAB_DIR)\extern\include;external
+ _WINDLL;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)
+ false
+
+
+ true
+ true
+ true
+ $(MATLAB_DIR)\extern\lib\win64\microsoft;$(SolutionDir)Output\CudaImageProcessor\$(Configuration)_$(PlatformName)\
+ CudaImageProcessor.lib;libmx.lib;libmex.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)
+ $(SolutionDir)Mex\CudaMex.def
+
+ echo copy $(OutDir)CudaMex.dll "$(ProjectDir)Mex.mexw64"
-copy $(OutDir)CudaMex.dll "$(ProjectDir)Mex.mexw64"
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+copy $(OutDir)CudaMex.dll "$(ProjectDir)Mex.mexw64"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/c/CudaPy3DLL.vcxproj b/src/c/CudaPy3DLL.vcxproj
index 8bd3907..30df2ca 100644
--- a/src/c/CudaPy3DLL.vcxproj
+++ b/src/c/CudaPy3DLL.vcxproj
@@ -1,213 +1,213 @@
-﻿
-
-
-
- Debug
- Win32
-
-
- Release
- Win32
-
-
- Debug
- x64
-
-
- Release
- x64
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- {0957901A-E67A-40C2-9EF5-76DF8EFBC2D5}
- Win32Proj
- CudaPy3DLL
- 8.1
-
-
-
- DynamicLibrary
- true
- v140
- MultiByte
-
-
- DynamicLibrary
- false
- v140
- true
- MultiByte
-
-
- DynamicLibrary
- true
- v140
- MultiByte
-
-
- DynamicLibrary
- false
- v140
- true
- MultiByte
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- true
- $(SolutionDir)..\Python\
- $(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\
- HIP
- .pyd
-
-
- true
- $(SolutionDir)..\Python\
- $(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\
- HIP
- .pyd
-
-
- false
- $(SolutionDir)..\Python\
- $(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\
- HIP
- .pyd
-
-
- false
- $(SolutionDir)..\Python\
- $(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\
- HIP
- .pyd
-
-
-
-
-
- Level3
- Disabled
- WIN32;_DEBUG;_WINDOWS;_USRDLL;CUDAPY3DLL_EXPORTS;%(PreprocessorDefinitions)
- external;Python;$(PYTHON3_DIR)/include;$(NUMPY3_DIR)/core/include;%(AdditionalIncludeDirectories)
- false
-
-
- Windows
- true
- $(PYTHON3_DIR)\libs;$(SolutionDir)Output\CudaImageProcessor\$(Configuration)_$(PlatformName)
- CudaImageProcessor_d.lib;%(AdditionalDependencies)
-
-
-
-
-
-
- Level3
- Disabled
- _DEBUG;_WINDOWS;_USRDLL;CUDAPY3DLL_EXPORTS;%(PreprocessorDefinitions)
- external;Python;$(PYTHON3_DIR)/include;$(NUMPY3_DIR)/core/include;%(AdditionalIncludeDirectories)
- false
-
-
- Windows
- true
- $(PYTHON3_DIR)\libs;$(SolutionDir)Output\CudaImageProcessor\$(Configuration)_$(PlatformName)
- CudaImageProcessor_d.lib;%(AdditionalDependencies)
-
-
-
-
- Level3
-
-
- MaxSpeed
- true
- true
- WIN32;NDEBUG;_WINDOWS;_USRDLL;CUDAPY3DLL_EXPORTS;%(PreprocessorDefinitions)
- external;Python;$(PYTHON3_DIR)/include;$(NUMPY3_DIR)/core/include;%(AdditionalIncludeDirectories)
- false
-
-
- Windows
- true
- true
- true
- $(PYTHON3_DIR)\libs;$(SolutionDir)Output\CudaImageProcessor\$(Configuration)_$(PlatformName)
- CudaImageProcessor.lib;%(AdditionalDependencies)
-
-
-
-
- Level3
-
-
- MaxSpeed
- true
- true
- NDEBUG;_WINDOWS;_USRDLL;CUDAPY3DLL_EXPORTS;%(PreprocessorDefinitions)
- external;Python;$(PYTHON3_DIR)/include;$(NUMPY3_DIR)/core/include;%(AdditionalIncludeDirectories)
- false
-
-
- Windows
- true
- true
- true
- $(PYTHON3_DIR)\libs;$(SolutionDir)Output\CudaImageProcessor\$(Configuration)_$(PlatformName)
- CudaImageProcessor.lib;%(AdditionalDependencies)
-
-
-
-
-
+﻿
+
+
+
+ Debug
+ Win32
+
+
+ Release
+ Win32
+
+
+ Debug
+ x64
+
+
+ Release
+ x64
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {0957901A-E67A-40C2-9EF5-76DF8EFBC2D5}
+ Win32Proj
+ CudaPy3DLL
+ 10.0.15063.0
+
+
+
+ DynamicLibrary
+ true
+ v141
+ MultiByte
+
+
+ DynamicLibrary
+ false
+ v141
+ true
+ MultiByte
+
+
+ DynamicLibrary
+ true
+ v141
+ MultiByte
+
+
+ DynamicLibrary
+ false
+ v141
+ true
+ MultiByte
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ true
+ $(SolutionDir)..\Python\
+ $(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\
+ HIP
+ .pyd
+
+
+ true
+ $(SolutionDir)..\Python\
+ $(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\
+ HIP
+ .pyd
+
+
+ false
+ $(SolutionDir)..\Python\
+ $(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\
+ HIP
+ .pyd
+
+
+ false
+ $(SolutionDir)..\Python\
+ $(SolutionDir)Intermediate\$(ProjectName)\$(Configuration)_$(PlatformName)\
+ HIP
+ .pyd
+
+
+
+
+
+ Level3
+ Disabled
+ WIN32;_DEBUG;_WINDOWS;_USRDLL;CUDAPY3DLL_EXPORTS;%(PreprocessorDefinitions)
+ external;Python;$(PYTHON3_DIR)/include;$(NUMPY3_DIR)/core/include;%(AdditionalIncludeDirectories)
+ false
+
+
+ Windows
+ true
+ $(PYTHON3_DIR)\libs;$(SolutionDir)Output\CudaImageProcessor\$(Configuration)_$(PlatformName)
+ CudaImageProcessor_d.lib;%(AdditionalDependencies)
+
+
+
+
+
+
+ Level3
+ Disabled
+ _DEBUG;_WINDOWS;_USRDLL;CUDAPY3DLL_EXPORTS;%(PreprocessorDefinitions)
+ external;Python;$(PYTHON3_DIR)/include;$(NUMPY3_DIR)/core/include;%(AdditionalIncludeDirectories)
+ false
+
+
+ Windows
+ true
+ $(PYTHON3_DIR)\libs;$(SolutionDir)Output\CudaImageProcessor\$(Configuration)_$(PlatformName)
+ CudaImageProcessor_d.lib;%(AdditionalDependencies)
+
+
+
+
+ Level3
+
+
+ MaxSpeed
+ true
+ true
+ WIN32;NDEBUG;_WINDOWS;_USRDLL;CUDAPY3DLL_EXPORTS;%(PreprocessorDefinitions)
+ external;Python;$(PYTHON3_DIR)/include;$(NUMPY3_DIR)/core/include;%(AdditionalIncludeDirectories)
+ false
+
+
+ Windows
+ true
+ true
+ true
+ $(PYTHON3_DIR)\libs;$(SolutionDir)Output\CudaImageProcessor\$(Configuration)_$(PlatformName)
+ CudaImageProcessor.lib;%(AdditionalDependencies)
+
+
+
+
+ Level3
+
+
+ MaxSpeed
+ true
+ true
+ NDEBUG;_WINDOWS;_USRDLL;CUDAPY3DLL_EXPORTS;%(PreprocessorDefinitions)
+ external;Python;$(PYTHON3_DIR)/include;$(NUMPY3_DIR)/core/include;%(AdditionalIncludeDirectories)
+ false
+
+
+ Windows
+ true
+ true
+ true
+ $(PYTHON3_DIR)\libs;$(SolutionDir)Output\CudaImageProcessor\$(Configuration)_$(PlatformName)
+ CudaImageProcessor.lib;%(AdditionalDependencies)
+
+
+
+
+
\ No newline at end of file
diff --git a/src/c/Mex.mexw64 b/src/c/Mex.mexw64
index cb4a5d0..21d8408 100644
--- a/src/c/Mex.mexw64
+++ b/src/c/Mex.mexw64
@@ -1,3 +1,3 @@
version https://git-lfs.github.com/spec/v1
-oid sha256:cdb438ba333536eccf6069eb1b9d794788f4a892c6c6f6a455247ac94cdbb129
-size 10299392
+oid sha256:2c56c475050e469809d1f10e6fca2f7a6ec92668d72913bbd6981ae2f2da8e4a
+size 10274816
diff --git a/src/c/Mex/MexDeviceStats.cpp b/src/c/Mex/MexDeviceStats.cpp
index c3a6765..283f209 100644
--- a/src/c/Mex/MexDeviceStats.cpp
+++ b/src/c/Mex/MexDeviceStats.cpp
@@ -6,7 +6,7 @@ void MexDeviceStats::execute(int nlhs, mxArray* plhs[], int nrhs, const mxArray*
{
DevStats* devStats;
mwSize numDevices = (mwSize)deviceStats(&devStats);
-
+ printf("ljsHIP\n");
mwSize dims[2] = {numDevices, 1};
const char* fieldNames[] = {"name", "major", "minor", "constMem", "sharedMem", "totalMem", "tccDriver", "mpCount", "threadsPerMP", "warpSize", "maxThreads"};
plhs[0] = mxCreateStructArray(2, dims, 11, fieldNames);
--
2.21.0