Name changed to Hydra Image Processor (HIP)

src/MATLAB/+HSP/@Cuda/Opener.m → src/MATLAB/+HIP/@Cuda/Opener.m

 % Opener - This kernel will erode follow by a dilation.
-%    arrayOut = HSP.Cuda.Opener(arrayIn,kernel,[numIterations],[device])
+%    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.
@@ -18,5 +18,5 @@
 %    
 %    	imageOut = This will be an array of the same type and shape as the input array.
 function arrayOut = Opener(arrayIn,kernel,numIterations,device)
-    [arrayOut] = HSP.Cuda.Mex('Opener',arrayIn,kernel,numIterations,device);
+    [arrayOut] = HIP.Cuda.Mex('Opener',arrayIn,kernel,numIterations,device);
 end

src/MATLAB/+HSP/@Cuda/StdFilter.m → src/MATLAB/+HIP/@Cuda/StdFilter.m

 % StdFilter - This will take the standard deviation of the given neighborhood.
-%    arrayOut = HSP.Cuda.StdFilter(arrayIn,kernel,[numIterations],[device])
+%    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.
@@ -18,5 +18,5 @@
 %    
 %    	imageOut = This will be an array of the same type and shape as the input array.
 function arrayOut = StdFilter(arrayIn,kernel,numIterations,device)
-    [arrayOut] = HSP.Cuda.Mex('StdFilter',arrayIn,kernel,numIterations,device);
+    [arrayOut] = HIP.Cuda.Mex('StdFilter',arrayIn,kernel,numIterations,device);
 end

src/MATLAB/+HSP/@Cuda/Sum.m → src/MATLAB/+HIP/@Cuda/Sum.m

 % Sum - This sums up the entire array in.
-%    valueOut = HSP.Cuda.Sum(arrayIn,[device])
+%    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.
@@ -10,5 +10,5 @@
 %    
 %    	valueOut = This is the summation of the entire array.
 function valueOut = Sum(arrayIn,device)
-    [valueOut] = HSP.Cuda.Mex('Sum',arrayIn,device);
+    [valueOut] = HIP.Cuda.Mex('Sum',arrayIn,device);
 end

src/MATLAB/+HSP/@Cuda/VarFilter.m → src/MATLAB/+HIP/@Cuda/VarFilter.m

 % VarFilter - This will take the variance deviation of the given neighborhood.
-%    arrayOut = HSP.Cuda.VarFilter(arrayIn,kernel,[numIterations],[device])
+%    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.
@@ -18,5 +18,5 @@
 %    
 %    	imageOut = This will be an array of the same type and shape as the input array.
 function arrayOut = VarFilter(arrayIn,kernel,numIterations,device)
-    [arrayOut] = HSP.Cuda.Mex('VarFilter',arrayIn,kernel,numIterations,device);
+    [arrayOut] = HIP.Cuda.Mex('VarFilter',arrayIn,kernel,numIterations,device);
 end

src/MATLAB/+HSP/@Cuda/WienerFilter.m → src/MATLAB/+HIP/@Cuda/WienerFilter.m

 % WienerFilter - A Wiener filter aims to denoise an image in a linear fashion.
-%    arrayOut = HSP.Cuda.WienerFilter(arrayIn,[kernel],[noiseVariance],[device])
+%    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.
@@ -18,5 +18,5 @@
 %    
 %    	imageOut = This will be an array of the same type and shape as the input array.
 function arrayOut = WienerFilter(arrayIn,kernel,noiseVariance,device)
-    [arrayOut] = HSP.Cuda.Mex('WienerFilter',arrayIn,kernel,noiseVariance,device);
+    [arrayOut] = HIP.Cuda.Mex('WienerFilter',arrayIn,kernel,noiseVariance,device);
 end

src/MATLAB/+HSP/BuildScript.m → src/MATLAB/+HIP/BuildScript.m

@@ -12,11 +12,11 @@ excludeList = ...
 curPath = pwd();
 
 % find where the image processing package is
-cudaPath = fileparts(which('HSP.BuildMexObject'));
+cudaPath = fileparts(which('HIP.BuildMexObject'));
 cd(cudaPath)
 
 % create the m files that correspond to the commands in the mex interface
-HSP.BuildMexObject('..\..\c\Mex.mexw64','Cuda','HSP');
+HIP.BuildMexObject('..\..\c\Mex.mexw64','Cuda','HIP');
 
 packagePath = cudaPath;
 cudaPath = fullfile(cudaPath,'@Cuda');
@@ -77,9 +77,9 @@ for i=1:length(dList)
             funcCallFilled = funcCall;
             fprintf(f,'\nfunction %s = %s(%s)\n',funcCall.out,funcCall.name,funcCall.param);
             fprintf(f,'    try\n');
-            fprintf(f,'        %s = HSP.Cuda.%s(%s);\n',funcCall.out,funcCall.name,funcCall.param);
+            fprintf(f,'        %s = HIP.Cuda.%s(%s);\n',funcCall.out,funcCall.name,funcCall.param);
             fprintf(f,'    catch errMsg\n');
-            localFuctionCall = sprintf('%s = HSP.Local.%s(%s)',funcCall.out,funcCall.name,funcCall.param);
+            localFuctionCall = sprintf('%s = HIP.Local.%s(%s)',funcCall.out,funcCall.name,funcCall.param);
             fprintf(f,'        warning(errMsg.message);\n');
             fprintf(f,'        %s;\n', localFuctionCall);
             fprintf(f,'    end\n');
@@ -136,6 +136,6 @@ for i=1:length(dList)
     end
 end
 
-fprintf('HSP BuildScript wrote %d functions\n',numFunctions);
+fprintf('HIP BuildScript wrote %d functions\n',numFunctions);
 % go back to the original directory
 cd(curPath)

src/MATLAB/+HSP/Closure.m → src/MATLAB/+HIP/Closure.m

 % Closure - This kernel will dilate follow by an erosion.
-%    arrayOut = HSP.Closure(arrayIn,kernel,[numIterations],[device])
+%    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.
@@ -20,9 +20,9 @@
 
 function arrayOut = Closure(arrayIn,kernel,numIterations,device)
     try
-        arrayOut = HSP.Cuda.Closure(arrayIn,kernel,numIterations,device);
+        arrayOut = HIP.Cuda.Closure(arrayIn,kernel,numIterations,device);
     catch errMsg
         warning(errMsg.message);
-        arrayOut = HSP.Local.Closure(arrayIn,kernel,numIterations,device);
+        arrayOut = HIP.Local.Closure(arrayIn,kernel,numIterations,device);
     end
 end

src/MATLAB/+HSP/ElementWiseDifference.m → src/MATLAB/+HIP/ElementWiseDifference.m

 % ElementWiseDifference - This subtracts the second array from the first, element by element (A-B).
-%    arrayOut = HSP.ElementWiseDifference(array1In,array2In,[device])
+%    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.
@@ -16,9 +16,9 @@
 
 function arrayOut = ElementWiseDifference(array1In,array2In,device)
     try
-        arrayOut = HSP.Cuda.ElementWiseDifference(array1In,array2In,device);
+        arrayOut = HIP.Cuda.ElementWiseDifference(array1In,array2In,device);
     catch errMsg
         warning(errMsg.message);
-        arrayOut = HSP.Local.ElementWiseDifference(array1In,array2In,device);
+        arrayOut = HIP.Local.ElementWiseDifference(array1In,array2In,device);
     end
 end

src/MATLAB/+HSP/EntropyFilter.m → src/MATLAB/+HIP/EntropyFilter.m

 % EntropyFilter - This calculates the entropy within the neighborhood given by the kernel.
-%    arrayOut = HSP.EntropyFilter(arrayIn,kernel,[device])
+%    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.
@@ -16,9 +16,9 @@
 
 function arrayOut = EntropyFilter(arrayIn,kernel,device)
     try
-        arrayOut = HSP.Cuda.EntropyFilter(arrayIn,kernel,device);
+        arrayOut = HIP.Cuda.EntropyFilter(arrayIn,kernel,device);
     catch errMsg
         warning(errMsg.message);
-        arrayOut = HSP.Local.EntropyFilter(arrayIn,kernel,device);
+        arrayOut = HIP.Local.EntropyFilter(arrayIn,kernel,device);
     end
 end

src/MATLAB/+HSP/Gaussian.m → src/MATLAB/+HIP/Gaussian.m

 % Gaussian - Gaussian smoothing.
-%    arrayOut = HSP.Gaussian(arrayIn,sigmas,[numIterations],[device])
+%    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.
@@ -19,9 +19,9 @@
 
 function arrayOut = Gaussian(arrayIn,sigmas,numIterations,device)
     try
-        arrayOut = HSP.Cuda.Gaussian(arrayIn,sigmas,numIterations,device);
+        arrayOut = HIP.Cuda.Gaussian(arrayIn,sigmas,numIterations,device);
     catch errMsg
         warning(errMsg.message);
-        arrayOut = HSP.Local.Gaussian(arrayIn,sigmas,numIterations,device);
+        arrayOut = HIP.Local.Gaussian(arrayIn,sigmas,numIterations,device);
     end
 end

src/MATLAB/+HSP/GetMinMax.m → src/MATLAB/+HIP/GetMinMax.m

 % GetMinMax - This function finds the lowest and highest value in the array that is passed in.
-%    [minValue,maxValue] = HSP.GetMinMax(arrayIn,[device])
+%    [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.
@@ -11,9 +11,9 @@
 
 function [minValue,maxValue] = GetMinMax(arrayIn,device)
     try
-        [minValue,maxValue] = HSP.Cuda.GetMinMax(arrayIn,device);
+        [minValue,maxValue] = HIP.Cuda.GetMinMax(arrayIn,device);
     catch errMsg
         warning(errMsg.message);
-        [minValue,maxValue] = HSP.Local.GetMinMax(arrayIn,device);
+        [minValue,maxValue] = HIP.Local.GetMinMax(arrayIn,device);
     end
 end

src/MATLAB/+HSP/Help.m → src/MATLAB/+HIP/Help.m

 % Help - Help on a specified command.
-%    HSP.Help(command)
+%    HIP.Help(command)
 %    Print detailed usage information for the specified command.
 function Help(command)
 end

src/MATLAB/+HSP/HighPassFilter.m → src/MATLAB/+HIP/HighPassFilter.m

 % HighPassFilter - Filters out low frequency by subtracting a Gaussian blurred version of the input based on the sigmas provided.
-%    arrayOut = HSP.HighPassFilter(arrayIn,sigmas,[device])
+%    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.
@@ -15,9 +15,9 @@
 
 function arrayOut = HighPassFilter(arrayIn,sigmas,device)
     try
-        arrayOut = HSP.Cuda.HighPassFilter(arrayIn,sigmas,device);
+        arrayOut = HIP.Cuda.HighPassFilter(arrayIn,sigmas,device);
     catch errMsg
         warning(errMsg.message);
-        arrayOut = HSP.Local.HighPassFilter(arrayIn,sigmas,device);
+        arrayOut = HIP.Local.HighPassFilter(arrayIn,sigmas,device);
     end
 end

src/MATLAB/+HSP/Info.m → src/MATLAB/+HIP/Info.m

 % Info - Get information on all available mex commands.
-%    commandInfo = HSP.Info()
+%    commandInfo = HIP.Info()
 %    Returns commandInfo structure array containing information on all mex commands.
 %       commandInfo.command - Command string
 %       commandInfo.outArgs - Cell array of output arguments
@@ -8,9 +8,9 @@
 
 function commandInfo = Info()
     try
-        commandInfo = HSP.Cuda.Info();
+        commandInfo = HIP.Cuda.Info();
     catch errMsg
         warning(errMsg.message);
-        commandInfo = HSP.Local.Info();
+        commandInfo = HIP.Local.Info();
     end
 end

src/MATLAB/+HSP/LoG.m → src/MATLAB/+HIP/LoG.m

 % LoG - Apply a Lapplacian of Gaussian filter with the given sigmas.
-%    arrayOut = HSP.LoG(arrayIn,sigmas,[device])
+%    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.
@@ -15,9 +15,9 @@
 
 function arrayOut = LoG(arrayIn,sigmas,device)
     try
-        arrayOut = HSP.Cuda.LoG(arrayIn,sigmas,device);
+        arrayOut = HIP.Cuda.LoG(arrayIn,sigmas,device);
     catch errMsg
         warning(errMsg.message);
-        arrayOut = HSP.Local.LoG(arrayIn,sigmas,device);
+        arrayOut = HIP.Local.LoG(arrayIn,sigmas,device);
     end
 end

src/MATLAB/+HSP/MaxFilter.m → src/MATLAB/+HIP/MaxFilter.m

 % MaxFilter - This will set each pixel/voxel to the max value of the neighborhood defined by the given kernel.
-%    arrayOut = HSP.MaxFilter(arrayIn,kernel,[numIterations],[device])
+%    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.
@@ -20,9 +20,9 @@
 
 function arrayOut = MaxFilter(arrayIn,kernel,numIterations,device)
     try
-        arrayOut = HSP.Cuda.MaxFilter(arrayIn,kernel,numIterations,device);
+        arrayOut = HIP.Cuda.MaxFilter(arrayIn,kernel,numIterations,device);
     catch errMsg
         warning(errMsg.message);
-        arrayOut = HSP.Local.MaxFilter(arrayIn,kernel,numIterations,device);
+        arrayOut = HIP.Local.MaxFilter(arrayIn,kernel,numIterations,device);
     end
 end

src/MATLAB/+HSP/MeanFilter.m → src/MATLAB/+HIP/MeanFilter.m

 % MeanFilter - This will take the mean of the given neighborhood.
-%    arrayOut = HSP.MeanFilter(arrayIn,kernel,[numIterations],[device])
+%    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.
@@ -20,9 +20,9 @@
 
 function arrayOut = MeanFilter(arrayIn,kernel,numIterations,device)
     try
-        arrayOut = HSP.Cuda.MeanFilter(arrayIn,kernel,numIterations,device);
+        arrayOut = HIP.Cuda.MeanFilter(arrayIn,kernel,numIterations,device);
     catch errMsg
         warning(errMsg.message);
-        arrayOut = HSP.Local.MeanFilter(arrayIn,kernel,numIterations,device);
+        arrayOut = HIP.Local.MeanFilter(arrayIn,kernel,numIterations,device);
     end
 end