GradientType

Author: mlavik1

Assets/Editor/ImportSettingsEditorWindow.cs

@@ -43,6 +43,14 @@ private void OnGUI()
             PlayerPrefs.SetInt("ClampHounsfield", clampHounsfield ? 1 : 0);
             EditorGUILayout.EndHorizontal();
 
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField("Default gradient computation method");
+            GradientType gradientType = GradientType.CentralDifference;
+            Enum.TryParse(PlayerPrefs.GetString("DefaultGradientType"), out gradientType);
+            gradientType = (GradientType)EditorGUILayout.EnumPopup(gradientType, "");
+            PlayerPrefs.SetString("DefaultGradientType", gradientType.ToString());
+            EditorGUILayout.EndHorizontal();
+
             EditorGUILayout.Space();
             EditorGUILayout.Space();
 

Assets/Editor/VolumeRenderedObjectCustomInspector.cs

@@ -112,6 +112,14 @@ public override void OnInspectorGUI()
                 else
                     volrendObj.SetLightingEnabled(false);
 
+                GradientType oldGradientType = volrendObj.GetGradientType();
+                GradientType newGradientType = (GradientType)EditorGUILayout.EnumPopup("Gradient", oldGradientType);
+
+                if (newGradientType != oldGradientType)
+                {
+                    volrendObj.SetGradientTypeAsync(newGradientType, new ProgressHandler(this));
+                }
+
                 if (volrendObj.GetLightingEnabled() || volrendObj.GetRenderMode() == RenderMode.IsosurfaceRendering)
                 {
                     LightSource oldLightSource = volrendObj.GetLightSource();

Assets/Scripts/Gradients/GradientType.cs

@@ -0,0 +1,21 @@
+using System;
+using UnityEngine;
+
+namespace UnityVolumeRendering
+{
+    public enum GradientType
+    {
+        CentralDifference,
+        Sobel
+    }
+
+    public class GradientTypeUtils
+    {
+        public static GradientType GetDefaultGradientType()
+        {
+            GradientType gradientType = GradientType.CentralDifference;
+            Enum.TryParse(PlayerPrefs.GetString("DefaultGradientType"), out gradientType);
+            return gradientType;
+        }
+    }
+}

Assets/Scripts/Gradients/SobelGradientComputator.cs

@@ -32,56 +32,26 @@ private float Convolve(int x, int y, int z, float[,,] matrix)
             return result;
         }
 
-        private static readonly float[,,] kernelx = {
+        private static readonly float[,,] kernelx = new float[,,]
         {
-            {-1, 0, 1},
-            {-2, 0, 2},
-            {-1, 0, 1}
-        },
-        {
-            {-2, 0, 2},
-            {-4, 0, 4},
-            {-2, 0, 2}
-        },
-        {
-            {-1, 0, 1},
-            {-2, 0, 2},
-            {-1, 0, 1}
-        }};
+            { { -1, 0, 1 }, { -2, 0, 2 }, { -1, 0, 1 } },
+            { { -2, 0, 2 }, { -4, 0, 4 }, { -2, 0, 2 } },
+            { { -1, 0, 1 }, { -2, 0, 2 }, { -1, 0, 1 } }
+        };
 
-        private static readonly float[,,] kernely = {
-        {
-            {-1, -2, -1},
-            {0, 0, 0},
-            {1, 2, 1}
-        },
-        {
-            {-2, -4, -2},
-            {0, 0, 0},
-            {2, 4, 2}
-        },
+        private static readonly float[,,] kernely = new float[,,]
         {
-            {-1, -2, -1},
-            {0, 0, 0},
-            {1, 2, 1}
-        }};
+            { { -1, -2, -1 }, { 0, 0, 0 }, { 1, 2, 1 } },
+            { { -2, -4, -2 }, { 0, 0, 0 }, { 2, 4, 2 } },
+            { { -1, -2, -1 }, { 0, 0, 0 }, { 1, 2, 1 } }
+        };
 
-        private static readonly float[,,] kernelz = {
+        private static readonly float[,,] kernelz = new float[,,]
         {
-            {-1, -2, -1},
-            {-2, -4, -2},
-            {-1, -2, -1}
-        },
-        {
-            {0, 0, 0},
-            {0, 0, 0},
-            {0, 0, 0}
-        },
-        {
-            {1, 2, 1},
-            {2, 4, 2},
-            {1, 2, 1}
-        }};
+            { { -1, -2, -1 }, { -2, -4, -2 }, { -1, -2, -1 } },
+            { {  0,  0,  0 }, {  0,  0,  0 }, {  0,  0,  0 } },
+            { {  1,  2,  1 }, {  2,  4,  2 }, {  1,  2,  1 } }
+        };
 
         public override Vector3 ComputeGradient(int x, int y, int z, float minValue, float maxRange)
         {
@@ -97,7 +67,9 @@ public override Vector3 ComputeGradient(int x, int y, int z, float minValue, flo
 
             Vector3 gradient = new Vector3(dx, dy, dz);
 
-            return new Vector3(gradient.x / maxRange, gradient.y / maxRange, gradient.z / maxRange);
+            float divident = maxRange * 3;
+
+            return new Vector3(gradient.x / divident, gradient.y / divident, gradient.z / divident);
         }
     }
 }

Assets/Scripts/VolumeData/VolumeDataset.cs

@@ -113,7 +113,7 @@ public Texture3D GetGradientTexture()
         {
             if (gradientTexture == null)
             {
-                gradientTexture = AsyncHelper.RunSync<Texture3D>(() => CreateGradientTextureInternalAsync(NullProgressHandler.instance));
+                gradientTexture = AsyncHelper.RunSync<Texture3D>(() => CreateGradientTextureInternalAsync(GradientTypeUtils.GetDefaultGradientType(), NullProgressHandler.instance));
                 return gradientTexture;
             }
             else
@@ -122,6 +122,29 @@ public Texture3D GetGradientTexture()
             }
         }
 
+        public async Task<Texture3D> RegenerateGradientTextureAsync(GradientType gradientType, IProgressHandler progressHandler = null)
+        {
+            await createGradientTextureLock.WaitAsync();
+            try
+            {
+                if (progressHandler == null)
+                    progressHandler = new NullProgressHandler();
+                try
+                {
+                    gradientTexture = await CreateGradientTextureInternalAsync(gradientType, progressHandler != null ? progressHandler : NullProgressHandler.instance);
+                }
+                catch (System.Exception exception)
+                {
+                    Debug.LogException(exception);
+                }
+            }
+            finally
+            {
+                createGradientTextureLock.Release();
+            }
+            return gradientTexture;
+        }
+
         /// <summary>
         /// Gets the gradient texture, containing the gradient values (direction of change) of the dataset.
         /// Will create the gradient texture if it does not exist, without blocking the main thread.
@@ -132,23 +155,7 @@ public async Task<Texture3D> GetGradientTextureAsync(IProgressHandler progressHa
         {
             if (gradientTexture == null)
             {
-                await createGradientTextureLock.WaitAsync();
-                try
-                {
-                    if (progressHandler == null)
-                        progressHandler = new NullProgressHandler();
-                        try {
-                            gradientTexture = await CreateGradientTextureInternalAsync(progressHandler != null ? progressHandler : NullProgressHandler.instance);
-                        }
-                        catch(System.Exception exception)
-                        {
-                            Debug.LogException(exception);
-                        }
-                }
-                finally
-                {
-                    createGradientTextureLock.Release();
-                }
+                gradientTexture = await RegenerateGradientTextureAsync(GradientTypeUtils.GetDefaultGradientType(), progressHandler);
             }
             return gradientTexture;
         }
@@ -338,7 +345,7 @@ await Task.Run(() => {
             return texture;
         }
 
-        private async Task<Texture3D> CreateGradientTextureInternalAsync(IProgressHandler progressHandler)
+        private async Task<Texture3D> CreateGradientTextureInternalAsync(GradientType gradientType, IProgressHandler progressHandler)
         {
             Debug.Log("Async gradient generation. Hold on.");
 
@@ -370,7 +377,7 @@ await Task.Run(() => {
                 Texture3D textureTmp = new Texture3D(dimX, dimY, dimZ, texformat, false);
                 textureTmp.wrapMode = TextureWrapMode.Clamp;
 
-                GradientComputator gradientComputator = new SobelGradientComputator(this);
+                GradientComputator gradientComputator = gradientType == GradientType.Sobel ? new SobelGradientComputator(this) : new CentralDifferenceGradientComputator(this);
 
                 for (int x = 0; x < dimX; x++)
                 {
@@ -398,7 +405,7 @@ await Task.Run(() => {
 
             progressHandler.StartStage(0.6f, "Creating gradient texture");
             await Task.Run(() => {
-                GradientComputator gradientComputator = new SobelGradientComputator(this);
+                GradientComputator gradientComputator = gradientType == GradientType.Sobel ? new SobelGradientComputator(this) : new CentralDifferenceGradientComputator(this);
 
                 for (int z = 0; z < dimZ; z++)
                 {

Assets/Scripts/VolumeObject/VolumeRenderedObject.cs

@@ -77,6 +77,9 @@ public class VolumeRenderedObject : MonoBehaviour
         [SerializeField, HideInInspector]
         private float samplingRateMultiplier = 1.0f;
 
+        [SerializeField, HideInInspector]
+        private GradientType gradientType = GradientType.CentralDifference;
+
         private CrossSectionManager crossSectionManager;
 
         private SemaphoreSlim updateMatLock = new SemaphoreSlim(1, 1);
@@ -373,6 +376,26 @@ public void SetLightSource(LightSource source)
             }
         }
 
+        public GradientType GetGradientType()
+        {
+            return this.gradientType;
+        }
+
+        public void SetGradientType(GradientType gradientType)
+        {
+             _ = SetGradientTypeAsync(gradientType);
+        }
+
+        public async Task SetGradientTypeAsync(GradientType gradientType, IProgressHandler progressHandler = null)
+        {
+            if (gradientType != this.gradientType)
+            {
+                this.gradientType = gradientType;
+                await dataset.RegenerateGradientTextureAsync(gradientType, progressHandler);
+                await UpdateMaterialPropertiesAsync();
+            }
+        }
+
         public void SetGradientLightingThreshold(Vector2 threshold)
         {
             if (gradientLightingThreshold != threshold)