Name changed to Hydra Image Processor (HIP)

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

 % MedianFilter - This will calculate the median for each neighborhood defined by the kernel.
-%    arrayOut = HSP.MedianFilter(arrayIn,kernel,[numIterations],[device])
+%    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.
@@ -20,9 +20,9 @@
 
 function arrayOut = MedianFilter(arrayIn,kernel,numIterations,device)
     try
-        arrayOut = HSP.Cuda.MedianFilter(arrayIn,kernel,numIterations,device);
+        arrayOut = HIP.Cuda.MedianFilter(arrayIn,kernel,numIterations,device);
     catch errMsg
         warning(errMsg.message);
-        arrayOut = HSP.Local.MedianFilter(arrayIn,kernel,numIterations,device);
+        arrayOut = HIP.Local.MedianFilter(arrayIn,kernel,numIterations,device);
     end
 end

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

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

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

 % MinMax - This returns the global min and max values.
-%    [minOut,maxOut] = HSP.MinMax(arrayIn,[device])
+%    [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.
@@ -13,9 +13,9 @@
 
 function [minOut,maxOut] = MinMax(arrayIn,device)
     try
-        [minOut,maxOut] = HSP.Cuda.MinMax(arrayIn,device);
+        [minOut,maxOut] = HIP.Cuda.MinMax(arrayIn,device);
     catch errMsg
         warning(errMsg.message);
-        [minOut,maxOut] = HSP.Local.MinMax(arrayIn,device);
+        [minOut,maxOut] = HIP.Local.MinMax(arrayIn,device);
     end
 end

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

 % MultiplySum - Multiplies the kernel with the neighboring values and sums these new values.
-%    arrayOut = HSP.MultiplySum(arrayIn,kernel,[numIterations],[device])
+%    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.
@@ -20,9 +20,9 @@
 
 function arrayOut = MultiplySum(arrayIn,kernel,numIterations,device)
     try
-        arrayOut = HSP.Cuda.MultiplySum(arrayIn,kernel,numIterations,device);
+        arrayOut = HIP.Cuda.MultiplySum(arrayIn,kernel,numIterations,device);
     catch errMsg
         warning(errMsg.message);
-        arrayOut = HSP.Local.MultiplySum(arrayIn,kernel,numIterations,device);
+        arrayOut = HIP.Local.MultiplySum(arrayIn,kernel,numIterations,device);
     end
 end

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

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

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

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

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

 % Sum - This sums up the entire array in.
-%    valueOut = HSP.Sum(arrayIn,[device])
+%    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.
@@ -12,9 +12,9 @@
 
 function valueOut = Sum(arrayIn,device)
     try
-        valueOut = HSP.Cuda.Sum(arrayIn,device);
+        valueOut = HIP.Cuda.Sum(arrayIn,device);
     catch errMsg
         warning(errMsg.message);
-        valueOut = HSP.Local.Sum(arrayIn,device);
+        valueOut = HIP.Local.Sum(arrayIn,device);
     end
 end

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

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

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

 % WienerFilter - A Wiener filter aims to denoise an image in a linear fashion.
-%    arrayOut = HSP.WienerFilter(arrayIn,[kernel],[noiseVariance],[device])
+%    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.
@@ -20,9 +20,9 @@
 
 function arrayOut = WienerFilter(arrayIn,kernel,noiseVariance,device)
     try
-        arrayOut = HSP.Cuda.WienerFilter(arrayIn,kernel,noiseVariance,device);
+        arrayOut = HIP.Cuda.WienerFilter(arrayIn,kernel,noiseVariance,device);
     catch errMsg
         warning(errMsg.message);
-        arrayOut = HSP.Local.WienerFilter(arrayIn,kernel,noiseVariance,device);
+        arrayOut = HIP.Local.WienerFilter(arrayIn,kernel,noiseVariance,device);
     end
 end

src/MATLAB/+Performance/AddConstant.m

 function [cTime,mTime,kernelName] = AddConstant(im,additive)
     kernelName = 'AddConstant';
     cT = tic;
-    imC = HSP.AddConstant(im,additive);
+    imC = HIP.AddConstant(im,additive);
     cTime = toc(cT);
 
     mT = tic;
-    imM = HSP.AddConstant(im,additive,true);
+    imM = HIP.AddConstant(im,additive,true);
     mTime = toc(mT);
 end

src/MATLAB/+Performance/AddImageWith.m

 function [cTime,mTime,kernelName] = AddImageWith(im)
     kernelName = 'AddImageWith';
     cT = tic;
-    imC = HSP.AddImageWith(im,im,2);
+    imC = HIP.AddImageWith(im,im,2);
     cTime = toc(cT);
 
     mT = tic;
-    imM = HSP.AddImageWith(im,im,2,true);
+    imM = HIP.AddImageWith(im,im,2,true);
     mTime = toc(mT);
 end

src/MATLAB/+Performance/Closure.m

@@ -2,16 +2,16 @@ function [cTime,mTime,kernelName,c2Time] = Closure(im,kernel,numDevices)
     kernelName = 'Closure';
     
     cT = tic;
-    imC = HSP.Closure(im,kernel,[],1);
+    imC = HIP.Closure(im,kernel,[],1);
     cTime = toc(cT);
 
     mT = tic;
-    imM = HSP.Local.Closure(im,kernel,[],[],true);
+    imM = HIP.Local.Closure(im,kernel,[],[],true);
     mTime = toc(mT);
     
     if (numDevices>1)
         c2T = tic;
-        imC = HSP.Closure(im,kernel,[],[]);
+        imC = HIP.Closure(im,kernel,[],[]);
         c2Time = toc(c2T);
     else
         c2Time = inf;

src/MATLAB/+Performance/ClosureGraph.m

@@ -10,7 +10,7 @@ function times = ClosureGraph(sizes_rc,sizeItter,types,typeItter,numTrials,numDe
     kernel = ones(5,5,3);
     m = memory;
     cpu_memAvail = m.MemAvailableAllArrays/4;
-    m = HSP.Cuda.DeviceStats;
+    m = HIP.Cuda.DeviceStats;
     gpu_memAvail = max(m.totalMem);
     
     for i = sizeItter

src/MATLAB/+Performance/EntropyFilter.m

 function [cTime,mTime,kernelName] = EntropyFilter(im,nhood)
     kernelName = 'EntropyFilter';
     cT = tic;
-    imC = HSP.EntropyFilter(im,ones(nhood));
+    imC = HIP.EntropyFilter(im,ones(nhood));
     cTime = toc(cT);
 
     mT = tic;
-    imM = HSP.EntropyFilter(im,ones(nhood),true);
+    imM = HIP.EntropyFilter(im,ones(nhood),true);
     mTime = toc(mT);
 end

src/MATLAB/+Performance/GaussianFilter.m

@@ -2,16 +2,16 @@ function [cTime,mTime,kernelName,c2Time] = GaussianFilter(im,sigma,numDevices)
     kernelName = 'GaussianFilter';
     
     cT = tic;
-    imC = HSP.Gaussian(im,sigma,[],1);
+    imC = HIP.Gaussian(im,sigma,[],1);
     cTime = toc(cT);
 
     mT = tic;
-    imM = HSP.Local.Gaussian(im,sigma,[],[],true);
+    imM = HIP.Local.Gaussian(im,sigma,[],[],true);
     mTime = toc(mT);
     
     if (numDevices>1)
         c2T = tic;
-        imC = HSP.Gaussian(im,sigma,[],[]);
+        imC = HIP.Gaussian(im,sigma,[],[]);
         c2Time = toc(c2T);
     else
         c2Time = inf;

src/MATLAB/+Performance/GaussianFilterGraph.m

@@ -10,7 +10,7 @@ function times = GaussianFilterGraph(sizes_rc,sizeItter,types,typeItter,numTrial
 
     m = memory;
     cpu_memAvail = m.MemAvailableAllArrays/4;
-    m = HSP.Cuda.DeviceStats;
+    m = HIP.Cuda.DeviceStats;
     gpu_memAvail = max(m.totalMem);
     
     for i = sizeItter

src/MATLAB/+Performance/HighPassFilter.m

@@ -2,16 +2,16 @@ function [cTime,mTime,kernelName,c2Time] = HighPassFilter(im,gauss,numDevices)
     kernelName = 'Contrast Enhancement';
     
     cT = tic;
-    imC = HSP.HighPassFilter(im,gauss,1);
+    imC = HIP.HighPassFilter(im,gauss,1);
     cTime = toc(cT);
 
     mT = tic;
-    imM = HSP.Local.HighPassFilter(im,gauss,[],true);
+    imM = HIP.Local.HighPassFilter(im,gauss,[],true);
     mTime = toc(mT);
 
     if (numDevices>1)
         c2T = tic;
-        imC = HSP.HighPassFilter(im,gauss,[]);
+        imC = HIP.HighPassFilter(im,gauss,[]);
         c2Time = toc(c2T);
     else
         c2Time = inf;

src/MATLAB/+Performance/HighPassFilterGraph.m

@@ -10,7 +10,7 @@ function times = HighPassFilterGraph(sizes_rc,sizeItter,types,typeItter,numTrial
     
     m = memory;
     cpu_memAvail = m.MemAvailableAllArrays/4;
-    m = HSP.Cuda.DeviceStats;
+    m = HIP.Cuda.DeviceStats;
     gpu_memAvail = max(m.totalMem);
     
     for i = sizeItter

src/MATLAB/+Performance/MaxFilter.m

@@ -2,18 +2,18 @@ function [cTime,mTime,kernelName,c2Time] = MaxFilter(im,kernel,numDevices)
     kernelName = 'MaxFilter';
     
     cT = tic;
-    imC = HSP.MaxFilter(im,kernel,[],1);
+    imC = HIP.MaxFilter(im,kernel,[],1);
     cTime = toc(cT);
     clear imC
 
     mT = tic;
-    imM = HSP.Local.MaxFilter(im,kernel,[],[],true);
+    imM = HIP.Local.MaxFilter(im,kernel,[],[],true);
     mTime = toc(mT);
     clear imM
     
     if (numDevices>1)
         c2T = tic;
-        imC = HSP.MaxFilter(im,kernel,[],[]);
+        imC = HIP.MaxFilter(im,kernel,[],[]);
         c2Time = toc(c2T);
     else
         c2Time = inf;

src/MATLAB/+Performance/MaxFilterGraph.m

@@ -10,7 +10,7 @@ function times = MaxFilterGraph(sizes_rc,sizeItter,types,typeItter,numTrials,num
     kernel = ones(5,5,3);
     m = memory;
     cpu_memAvail = m.MemAvailableAllArrays/4;
-    m = HSP.Cuda.DeviceStats;
+    m = HIP.Cuda.DeviceStats;
     gpu_memAvail = max(m.totalMem);
     
     for i = sizeItter