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 (AB).
% 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 (AB).
+% 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://gitlfs.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 (AB).
% 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 (AB).
+% 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



 {3E663AF24E6F487B9072CCA90C66A822}
 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
+
+
+
+ {3E663AF24E6F487B9072CCA90C66A822}
+ 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



 {6698E8EC49D9421EAA875BCC6B466347}
 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
+
+
+
+ {6698E8EC49D9421EAA875BCC6B466347}
+ 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





































 {0957901AE67A40C29EF576DF8EFBC2D5}
 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
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {0957901AE67A40C29EF576DF8EFBC2D5}
+ 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://gitlfs.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