Пример #1
0
        private static ThreadGroup StartCPU(DataType type, HeadsetModel headset, ElectrodePattern pattern, ElectrodeLayout layout, string path)
        {
            // declare colour matrix and electrodes (if needed)
            var matrix     = new Color[headset.GetWidth(), headset.GetHeight()];
            var electrodes = type == DataType.Phosphene ? pattern.GetElectrodePositions(layout)
                                                                                                                : default;

            // setup threadGroup
            var threadGroup = new ThreadGroup();

            threadGroup.OnAllThreadsFinished += () =>
            {
                EditorCallback.InvokeOnMainThread(() =>
                {
                    var asset = headset.CreateTexture();
                    asset.SetPixels(matrix.Flatten(false, true, true));
                    asset.Apply();
                    SaveAsset(asset, path);
                });
            };

            // generate the texture asynchronously
            threadGroup.ProcessArray(headset.GetWidth(), (i) =>
            {
                var n = headset.GetHeight();
                for (int j = 0; j < n; j++)
                {
                    switch (type)
                    {
                    case DataType.Phosphene:
                        matrix[i, j] = PhospheneMatrix.CalculatePoint(i, j, headset, electrodes).ToColour();
                        matrix[i, j] = AddRandomSeeds(matrix[i, j]);
                        break;

                    case DataType.Axon:
                        matrix[i, j] = AxonMatrix.CalculatePoint(i, j, headset).Colour;
                        break;
                    }
                }
            });

            // provide caller with threadGroup for completion statistics
            return(threadGroup);
        }
Пример #2
0
        public static Texture2D CreateTexture(this HeadsetModel headset)
        {
            var texture = new Texture2D(headset.GetWidth(), headset.GetHeight(), TextureFormat.RGBAFloat, false, true)
            {
                anisoLevel = 0,
                filterMode = FilterMode.Point
            };

            return(texture);
        }
Пример #3
0
        /// <summary>
        /// Pixel (i, j) -> Visual Angle (um)
        /// </summary>
        public static Vector2 PixelToRetina(int i, int j, HeadsetModel headset)
        {
            var horizontalDiameter = headset.GetRetinalDiameter(Axis.Horizontal);
            var verticalDiameter   = headset.GetRetinalDiameter(Axis.Vertical);

            var x = ((float)i / headset.GetWidth() - .5f) * horizontalDiameter;
            var y = ((float)j / headset.GetHeight() - .5f) * verticalDiameter;

            return(new Vector2(x, y));
        }
Пример #4
0
        /// <summary>
        /// Retinal position (um) -> Pixel (i, j)
        /// </summary>
        public static Vector2 RetinaToPixel(Vector2 retina, HeadsetModel headset)
        {
            var horizontalDiameter = headset.GetRetinalDiameter(Axis.Horizontal);
            var verticalDiameter   = headset.GetRetinalDiameter(Axis.Vertical);

            var x = (retina.x / horizontalDiameter + .5f) * headset.GetWidth();
            var y = (retina.y / verticalDiameter + .5f) * headset.GetHeight();

            return(new Vector2(x, y));
        }
Пример #5
0
        void OnGUI()
        {
            UnityGUI.Header("Coordinates");
            headset = UnityGUI.Enum("Headset", headset);

            UnityGUI.Space();

            UnityGUI.BeginHorizontal();
            UnityGUI.Label(" ", "X", UnityGUI.BoldLabel);
            UnityGUI.Label("Y", UnityGUI.BoldLabel);
            UnityGUI.EndHorizontal();

            UnityGUI.BeginHorizontal();
            UnityGUI.Label("Resolution", headset.GetWidth().ToString());
            UnityGUI.Label(headset.GetHeight().ToString());
            UnityGUI.EndHorizontal();

            UnityGUI.BeginHorizontal();
            UnityGUI.Label("Field of View", ((int)headset.GetFieldOfView(Axis.Horizontal)).ToString());
            UnityGUI.Label(((int)headset.GetFieldOfView(Axis.Vertical)).ToString());
            UnityGUI.EndHorizontal();

            UnityGUI.BeginHorizontal();
            UnityGUI.Label("Diameter (um)", ((int)headset.GetRetinalDiameter(Axis.Horizontal)).ToString());
            UnityGUI.Label(((int)headset.GetRetinalDiameter(Axis.Vertical)).ToString());
            UnityGUI.EndHorizontal();

            UnityGUI.Space();

            Draw("Pixel", ref pixel);
            Draw("Visual Angle", ref angle);
            Draw("Retina (um)", ref retina);
            Draw("Polar", ref polar);

            UnityGUI.Separator();
            UnityGUI.Header("Electrode Count");

            UnityGUI.BeginChangeCheck();
            pattern     = UnityGUI.Enum("Pattern", pattern);
            layout      = UnityGUI.Enum("Layout", layout);
            fieldOfView = UnityGUI.Float("Field of View", fieldOfView);
            var changed = UnityGUI.EndChangeCheck();

            if (changed)
            {
                numElectrodes = pattern.GetElectrodePositions(layout, fieldOfView).Length;
            }

            UnityGUI.Space();
            UnityGUI.Label("Electode Count", numElectrodes.ToString());
        }
Пример #6
0
        public static RenderTexture CreateRenderTexture(this HeadsetModel headset)
        {
            var texture = new RenderTexture(headset.GetWidth(), headset.GetHeight(), 0, RenderTextureFormat.ARGBFloat, RenderTextureReadWrite.Linear)
            {
                anisoLevel        = 0,
                antiAliasing      = 1,
                enableRandomWrite = true,
                filterMode        = FilterMode.Point
            };

            texture.Create();

            return(texture);
        }
Пример #7
0
        /*
         * Public methods
         */

        public static AxonPoint[,] CalculateMatrix(HeadsetModel headset)
        {
            var width  = headset.GetWidth();
            var height = headset.GetHeight();

            var matrix = new AxonPoint[width, height];

            for (int i = 0; i < width; i++)
            {
                for (int j = 0; j < height; j++)
                {
                    matrix[i, j] = CalculatePoint(i, j, headset);
                }
            }

            return(matrix);
        }
Пример #8
0
        public static Vector2[,] CalculateMatrix(HeadsetModel headset, Vector2[] electrodes)
        {
            var width  = headset.GetWidth();
            var height = headset.GetHeight();

            var matrix = new Vector2[width, height];

            for (int i = 0; i < width; i++)
            {
                for (int j = 0; j < height; j++)
                {
                    matrix[i, j] = CalculatePoint(i, j, headset, electrodes);
                }
            }

            return(matrix);
        }
Пример #9
0
        /*
         * Private methods
         */

        private static void StartGPU(DataType type, HeadsetModel headset, ElectrodePattern pattern, ElectrodeLayout layout, string path)
        {
            var shader = LoadAsset <ComputeShader>($"{type}");
            var kernel = shader.FindKernel("CSMain");

            var electrodeBuffer = default(ComputeBuffer);

            if (type == DataType.Phosphene)
            {
                var electrodes = pattern.GetElectrodePositions(layout);
                electrodeBuffer = new ComputeBuffer(electrodes.Length, sizeof(float) * 2);
                electrodeBuffer.SetData(electrodes);
                shader.SetBuffer(kernel, "_electrodes", electrodeBuffer);
            }

            var texture = headset.CreateRenderTexture();

            shader.SetTexture(kernel, "_result", texture);
            shader.SetVector("_headset_diameter", headset.GetRetinalDiameter());
            shader.SetVector("_headset_resolution", headset.GetResolution());

            shader.Dispatch(kernel, headset.GetWidth() / 8, headset.GetHeight() / 8, 1);
            electrodeBuffer?.Dispose();

            Texture2D asset = texture.ToTexture2D(TextureFormat.RGBAFloat, true);

            texture.Release();

            asset.anisoLevel = 0;
            asset.filterMode = FilterMode.Point;

            if (type == DataType.Phosphene)
            {
                AddRandomSeeds(asset);
            }

            SaveAsset(asset, path);
        }
Пример #10
0
 public static float GetAspectRatio(this HeadsetModel headset)
 {
     return((float)headset.GetWidth() / headset.GetHeight());
 }
Пример #11
0
 public override void GetDimensions(out int width, out int height)
 {
     width  = headset.GetWidth();
     height = headset.GetHeight();
 }