optimise

Author: mlavik1

Assets/Scripts/Gradients/SobelGradientComputator.cs

@@ -9,29 +9,6 @@ public SobelGradientComputator(VolumeDataset dataset) : base(dataset)
         {
         }
 
-        private float GetData(int x, int y, int z)
-        {
-            return data[x + y * dimX + z * (dimX * dimY)];
-        }
-
-        private float Convolve(int x, int y, int z, float[,,] matrix)
-        {
-            float result = 0;
-            for (int iz = 0; iz <= 2; iz++)
-            {
-                for (int iy = 0; iy <= 2; iy++)
-                {
-                    for (int ix = 0; ix <= 2; ix++)
-                    {
-                        float matrixValue = matrix[iz, iy, ix];
-                        float dataValue = GetData(x + ix - 1, y + iy - 1, z + iz - 1);
-                        result += matrixValue * dataValue;
-                    }
-                }
-            }
-            return result;
-        }
-
         private static readonly float[,,] kernelx = new float[,,]
         {
             { { -1, 0, 1 }, { -2, 0, 2 }, { -1, 0, 1 } },
@@ -53,6 +30,30 @@ private float Convolve(int x, int y, int z, float[,,] matrix)
             { {  1,  2,  1 }, {  2,  4,  2 }, {  1,  2,  1 } }
         };
 
+        private float GetData(int x, int y, int z)
+        {
+            return data[x + y * dimX + z * (dimX * dimY)];
+        }
+
+        private Vector3 ConvolveWithKernels(int x, int y, int z)
+        {
+            Vector3 result = Vector3.zero;
+            for (int iz = 0; iz <= 2; iz++)
+            {
+                for (int iy = 0; iy <= 2; iy++)
+                {
+                    for (int ix = 0; ix <= 2; ix++)
+                    {
+                        float dataValue = GetData(x + ix - 1, y + iy - 1, z + iz - 1);
+                        result.x += kernelx[iz, iy, ix] * dataValue;
+                        result.y += kernely[iz, iy, ix] * dataValue;
+                        result.z += kernelz[iz, iy, ix] * dataValue;
+                    }
+                }
+            }
+            return result;
+        }
+
         public override Vector3 ComputeGradient(int x, int y, int z, float minValue, float maxRange)
         {
             // TODO
@@ -61,13 +62,9 @@ public override Vector3 ComputeGradient(int x, int y, int z, float minValue, flo
                 return Vector3.zero;
             }
 
-            float dx = Convolve(x, y, z, kernelx);
-            float dy = Convolve(x, y, z, kernely);
-            float dz = Convolve(x, y, z, kernelz);
-
-            Vector3 gradient = new Vector3(dx, dy, dz);
+            Vector3 gradient = ConvolveWithKernels(x, y, z);
 
-            float divident = maxRange;
+            float divident = maxRange * 12;
 
             return new Vector3(gradient.x / divident, gradient.y / divident, gradient.z / divident);
         }