Data.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;
using visLU.Effects;
using Microsoft.Xna.Framework.Graphics.PackedVector;

namespace visLU
{
    class Data : DrawableGameComponent
    {
        //: change Byte order with NetworkToHostOrder(Int16) if needed
        private RenderTarget2D frontTarget;
        private RenderTarget2D backTarget;
        private RenderTarget2D screenShotTarget;
        private ResolveTexture2D backBuffer_resolved;
        private Vector3 stepSize;
        private Vector4 scaleFactor;
        private int iterations;
        private float scaleSteps = 1.0f; //the size of the step to take. 
                                        //Lower means shorter steps. 0.5f or 1.0f are good values.
        public float slice = 0.5f;

        //for transfer function
        private List<TransferControlPoint> colorControlPoints;
        private List<TransferControlPoint> alphaControlPoints;
        private Texture2D transferTexture;
        private Texture2D transferTextureAlpha;

        private List<float> densityValues;
        private float[] densityArray;
        private float[] distinctDensityValuesArray;
        private int[] countDensityValuesArray;

        private Vector3[] gradients;

        private Matrix worldMatrix;

        
        //declare variables for header information
        ushort sizeX, sizeY, sizeZ;

        private UInt16[][][] data;

        public VolumeShader shader;

        private String fileName;

        private Texture3D volumeData;
        private Texture2D frontFaces;

        private Model cube;

        //private BasicEffect basicEffect; //for debug
        int texturesSaved = 0;
        GraphicsDevice device;


        //view modes
        private Camera camera;
        private int currentView = 0; //3d view mode

        #region Properties
        public Camera Camera
        {
            set { camera = value; }
        }
        public int CurrentCamera
        {
            set { currentView = value; }
        }
        #endregion
        #region Constructor





        public Data(string _fileName, Game game) : base(game)
        {
            worldMatrix = Matrix.Identity;
            //game.Content.RootDirectory = "Content";
            string a = "" + Directory.GetParent((string) Directory.GetCurrentDirectory());
            string b = "" + Directory.GetParent(a);
            string c = "" + Directory.GetParent(b);

            this.fileName = c + "\\"+_fileName;

            if (string.IsNullOrEmpty(fileName))
                        {
                                throw new ArgumentNullException(fileName);
                        }
                        
                        if (!File.Exists(fileName))
                        {
                Console.WriteLine(fileName);
                                throw new ArgumentException("file not found: "+ fileName);
                        }

        }
        #endregion

        #region Initialize()
        //-----------------------------------INITIALIZE()-------------------------------------------

        public override void Initialize()
        {
           base.Initialize();
           this.LoadContent();
        }
        //__________________________________________________________________________________________
        #endregion

        #region LoadContent





        protected override void LoadContent()
        {
            device = Game.GraphicsDevice;
            PresentationParameters param = Game.GraphicsDevice.PresentationParameters;
            SurfaceFormat format = param.BackBufferFormat;
            int width = device.PresentationParameters.BackBufferWidth;
            int height = device.PresentationParameters.BackBufferHeight;

            frontTarget = new RenderTarget2D(device, width, height, 1, format,
                device.DepthStencilBuffer.MultiSampleType,
                device.PresentationParameters.MultiSampleQuality);

            backTarget = new RenderTarget2D(device, width, height, 1, format,
                device.DepthStencilBuffer.MultiSampleType,
                device.PresentationParameters.MultiSampleQuality);

            screenShotTarget = new RenderTarget2D(device, width, height, 1, format,
                device.DepthStencilBuffer.MultiSampleType,
                device.PresentationParameters.MultiSampleQuality);

            //backBuffer_resolved = new ResolveTexture2D(device, width, height, 1, format);

            #region check format
            //check which format is supported
            /*if (isFormatSupported(SurfaceFormat.HalfVector4))
            {
                format = SurfaceFormat.HalfVector4;
            }
            else if (isFormatSupported(SurfaceFormat.Vector4))
            {
                format = SurfaceFormat.Vector4;
            }
            else
            {
                //format = SurfaceFormat.Rgba64;
                format = SurfaceFormat.HalfSingle;
            }*/
            //format = SurfaceFormat.HalfSingle;
            format = SurfaceFormat.Vector4;
            #endregion

            if (Game.GraphicsDevice.GraphicsDeviceCapabilities.TextureCapabilities.RequiresPower2)
            {
                loadDatafromFileExtend();
            }
            else
            {
                loadDatafromFile();
            }
            
            //calculate stepsize
            //has to be the ratio of the largest component
            float max = (float)Math.Max(sizeX, Math.Max(sizeY, sizeZ));
            stepSize = Vector3.One/max;
            Console.WriteLine(stepSize);

            Matrix rotate;
            if(GameProperties.Instance.dataFilename.StartsWith("skewed_head"));
            {
                rotate = Matrix.CreateRotationZ(90.0f);
            }
            worldMatrix = Matrix.CreateTranslation(new Vector3(-(sizeX / max) / 2.0f,
                                                                -(sizeY / max) / 2.0f,
                                                                -(sizeZ / max) / 2.0f)); //rotate;

            //stepSize = new Vector3(1.0f / sizeX, 1.0f / sizeY, 1.0f / sizeZ);
            //stepSize = new Vector3(sizeX/max, sizeY/max, sizeZ/max);

            //calculate number of iterations
            iterations = (int)(max * (1.0f / scaleSteps));

            //calculate scaleFactor
            Vector3 sizeVector = new Vector3(sizeX, sizeY, sizeZ);
            Vector3 scale = Vector3.One / ( (Vector3.One * max)/sizeVector ); 
            scaleFactor = new Vector4(scale.X, scale.Y, scale.Z, 1.0f);


           cube = Game.Content.Load<Model>("Models/box");

           shader = new VolumeShader(Game, device, Game.Content.Load<Effect>("Effects\\volumeShader"));
           shader.SetEffectParameter(volumeData, stepSize * scaleSteps, iterations, 0, scaleFactor, slice); 
           //side = 0 means draw frontfaces

           colorControlPoints = GameProperties.Instance.colorControlPoints;
           alphaControlPoints = GameProperties.Instance.alphaControlPoints;

           //update slice controls
           setSliceRange(sizeX, sizeY, sizeZ);
           base.LoadContent();
        }

        private void loadDatafromFile()
        {
            #region read data
            Stream file = new FileStream(fileName, FileMode.Open);

            BinaryReader reader = new BinaryReader(file);

            //read header
            sizeX = reader.ReadUInt16();
            sizeY = reader.ReadUInt16();
            sizeZ = reader.ReadUInt16();

            //Console.WriteLine("sizeX =" + sizeX + " sizeY =" + sizeY + " sizeZ =" + sizeZ);

            volumeData = new Texture3D(Game.GraphicsDevice, sizeX, sizeY, sizeZ, 0,
                        TextureUsage.Linear, SurfaceFormat.Vector4);

            ushort[] buffer = new ushort[sizeX * sizeY * sizeZ];

            int j = 0;
            while (reader.BaseStream.Position < reader.BaseStream.Length)
            {

                buffer[j] = reader.ReadUInt16();
                j++;
            }
            reader.Close();
            #endregion

            #region scale data
            //scale the scalar values to [0, 1]
            densityValues = new List<float>();
            float maxValue = 1.0f/buffer.Max();
            for (int i = 0; i < buffer.Length; i++)
            {
                densityValues.Add((float)buffer[i] * maxValue);
            }
            #endregion

            GameProperties.Instance.dataOrigin = new Vector3(0.5f, 0.5f, sizeZ / 2.0f);

            #region add gradients to VolumeData
            calculateGradients();
            //filter the gradients with an NxNxN box filter
            //filterNxNxN(3);
            Vector4[] densityVectors = new Vector4[buffer.Length];
            for (int i = 0; i < buffer.Length; i++)
            {
                densityVectors[i] = new Vector4(gradients[i].X, 
                                                    gradients[i].Y, 
                                                    gradients[i].Z,
                                                    densityValues[i]);
            }
            #endregion
            // set data to texture
            densityArray = densityValues.ToArray();
            //volumeData.SetData(densityArray);

            volumeData.SetData<Vector4>(densityVectors);

            #region sort data
            densityValues.Sort();
            sortDensityValues();

            /*for (int i = 480000; i < 489000; i++) // for debug
            {
                Console.WriteLine(densityValues[i]);
            }*/
            #endregion
        }

        //: DEBUG THIS
        private void sortDensityValues()
        {
 
            List<float> distinctDensityValues = new List<float>();
            List<int> countDensityValues = new List<int>();

            #region debug
            /*int countAll = densityValues.Count();
            int testCountAll = 0;
            int totalValues = 0;*/
            #endregion

            for (int i = 0; i < densityValues.Count(); i++)
            {
                int value1 = (int)(densityValues[i] * 255);
                int count = 1;

                while (i < (densityValues.Count() - 1))
                {
                    int value2 = (int)(densityValues[i + 1] * 255);
                    if ((value1 == value2))
                    {
                        count++;
                        i++;
                    }
                    else
                    {
                        break;
                    }

                }

                #region debug
                /*testCountAll += count;
                totalValues++;
                Console.WriteLine("value" + i + " = " + value1 + "   x" + count);*/
                #endregion

                distinctDensityValues.Add(value1);
                countDensityValues.Add(count);

            }
            distinctDensityValuesArray = distinctDensityValues.ToArray();
            countDensityValuesArray = countDensityValues.ToArray();

            GameProperties.Instance.distinctDensityValues = distinctDensityValuesArray;
            GameProperties.Instance.countDensityValues = countDensityValuesArray;

        }

        #endregion






        public override void Update(GameTime gameTime)
        {
            /*#region move camera
            currentMouseState = Mouse.GetState();
            if (currentMouseState.LeftButton == ButtonState.Pressed)
            {
                float fX, fY;
                fX = MathHelper.ToRadians(currentMouseState.X - lastMouseState.X);
                fY = MathHelper.ToRadians(currentMouseState.Y - lastMouseState.Y);

                 *= Matrix.CreateRotationX(fX) * Matrix.CreateRotationY(-fY);

            }
            #endregion
            lastMouseState = currentMouseState;*/

            Game.GraphicsDevice.RenderState.AlphaBlendEnable = false;
            shader.CurrentTechnique = shader.Techniques["RenderPosition"];
            shader.SetEffectParameter(worldMatrix*camera.ViewProjection, worldMatrix);
            shader.SetEffectParameter(camera.CameraPosition);

            //Console.WriteLine("1 DRAWING FRONTFACES");
            Game.GraphicsDevice.SetRenderTarget(0, frontTarget);
            Game.GraphicsDevice.Clear(Color.Black);
            GraphicsDevice.RenderState.CullMode = CullMode.CullCounterClockwiseFace;

            DrawVolume(gameTime, 0);

            Game.GraphicsDevice.SetRenderTarget(0, null);

            //Console.WriteLine("2 DRAWING BACKFACES");
            Game.GraphicsDevice.SetRenderTarget(0, backTarget);
            Game.GraphicsDevice.Clear(Color.Black);
            GraphicsDevice.RenderState.CullMode = CullMode.CullClockwiseFace;

            DrawVolume(gameTime, 1);

            Game.GraphicsDevice.SetRenderTarget(0, null);
            Game.GraphicsDevice.Clear(Color.Black);
            shader.FrontFacesTexture = frontTarget.GetTexture();
            shader.BackFacesTexture = backTarget.GetTexture();

            #region debug
            /*if (texturesSaved<4) //only for debug
            {
                shader.FrontFacesTexture.Save("frontFaces"+currentView+".jpg", ImageFileFormat.Jpg);
                shader.BackFacesTexture.Save("backFaces" + currentView + ".jpg", ImageFileFormat.Jpg);
                texturesSaved ++;
            }*/
            #endregion

            setControlpoints();

            base.Update(gameTime);
        }
        public override void Draw(GameTime gameTime)
        {
            if (currentView == 1)
            {
                slice = GameProperties.Instance.ySliceValue;
                shader.CurrentTechnique = shader.Techniques["RenderSlice"];
            } 
            else if (currentView == 2)
            {
                slice = GameProperties.Instance.xSliceValue;
                shader.CurrentTechnique = shader.Techniques["RenderSlice"];
            }
            else if (currentView == 3)
            {
                slice = GameProperties.Instance.zSliceValue;
                shader.CurrentTechnique = shader.Techniques["RenderSlice"];
            }
            else
            {
                //shader.CurrentTechnique = shader.Techniques["RenderSlice"];
                if (GameProperties.Instance.maximumIntensityProjection == true)
                {
                    shader.CurrentTechnique = shader.Techniques["MaximumIntensity"];
                }
                else
                {
                    shader.CurrentTechnique = shader.Techniques["RayCastSimple"];
                }
            }
            //shader[currentView].CurrentTechnique = shader[currentView].Techniques["RayCastSimple"];//: technique abfrage

            //Console.WriteLine("3 DRAWING VOLUME------------------------------------------------------------");
            
            //Console.WriteLine("DRAW VOLUME for cam=" + currentView);

            Game.GraphicsDevice.RenderState.AlphaBlendEnable = false;
            //shader.CurrentTechnique = shader.Techniques["RayCastSimple"];
            //shader.CurrentTechnique = shader.Techniques["RenderPosition"];
            //shader.CurrentTechnique = shader.Techniques["RenderSlice"];

            #region depricated : do we need it!?
            /*if (currentView == 0) 
            {
                Game.GraphicsDevice.RenderState.AlphaBlendEnable = true;
                Game.GraphicsDevice.RenderState.SourceBlend = Blend.SourceAlpha;
                Game.GraphicsDevice.RenderState.DestinationBlend = Blend.InverseSourceAlpha;
            }*/
            #endregion

            #region save screenshot
            if (GameProperties.Instance.saveView)
            {
                if (string.IsNullOrEmpty(GameProperties.Instance.saveFilename))
                {
                    throw new ArgumentNullException(GameProperties.Instance.saveFilename);
                }
                Game.GraphicsDevice.SetRenderTarget(0, screenShotTarget);
                Game.GraphicsDevice.Clear(Color.Black);
                GraphicsDevice.RenderState.CullMode = CullMode.CullClockwiseFace;

                DrawVolume(gameTime, currentView);

                Game.GraphicsDevice.SetRenderTarget(0, null);
                Texture2D saveTex = screenShotTarget.GetTexture();
                saveTex.Save(GameProperties.Instance.saveFilename, ImageFileFormat.Jpg);
                //device.ResolveBackBuffer(backBuffer_resolved);
                //backBuffer_resolved.Save(GameProperties.Instance.saveFilename, ImageFileFormat.Jpg);
                GameProperties.Instance.saveView = false;
            }
            #endregion

            //GraphicsDevice.RenderState.CullMode = CullMode.CullCounterClockwiseFace;
            GraphicsDevice.RenderState.CullMode = CullMode.None;

            //DrawVolume(gameTime, 2); for SimpleRaycast
            DrawVolume(gameTime, currentView);
            //DrawCoordinateSystem(gameTime); //for debug

        }

        private void DrawVolume(GameTime gameTime, int side)
        {
            #region draw cube
            //Matrix[] transformations = new Matrix[cube.Bones.Count];
            //cube.CopyAbsoluteBoneTransformsTo(transformations);

            foreach (ModelMesh mesh in cube.Meshes)
            {
                foreach (ModelMeshPart mmp in mesh.MeshParts)
                {
                    mmp.Effect = shader;
                    shader.SetEffectParameter(volumeData, stepSize * scaleSteps, iterations, side, scaleFactor, slice);
                    shader.SetEffectParameter(camera.CameraPosition);
                };

                //shader[currentView].Begin();
                mesh.Draw();
                //shader[currentView].End();
            }
            #endregion
        }

        private void DrawCoordinateSystem(GameTime gameTime)
        {
            //Console.WriteLine("DRAWING COORDINATE SYSTEM");
            #region coordinate system
            //Camera camera = (Camera)Game.Services.GetService(typeof(Camera));
            BasicEffect basicEffect = new BasicEffect(device, null);
            device.RenderState.DepthBufferEnable = false;
            device.VertexDeclaration = new VertexDeclaration(device, VertexPositionColor.VertexElements);

            basicEffect.LightingEnabled = false;
            basicEffect.TextureEnabled = false;
            basicEffect.VertexColorEnabled = true;
            basicEffect.World = Matrix.Identity;
            basicEffect.Projection = camera.Projection;
            basicEffect.View = camera.View;

            basicEffect.Begin();
            foreach (EffectPass pass in basicEffect.CurrentTechnique.Passes)
            {
                pass.Begin();
                VertexPositionColor[] pointList = { 
                                      //Z axis
                                      new VertexPositionColor(new Vector3(0.0f, 0.0f, 0.0f), Color.DarkBlue),
                                      new VertexPositionColor(new Vector3(0.0f, 0.0f, -3000.0f), Color.DarkBlue),
                                      new VertexPositionColor(new Vector3(0.0f, 0.0f, 0.0f), Color.Blue), 
                                      new VertexPositionColor(new Vector3(0.0f, 0.0f, 3000.0f), Color.Blue),
                                      //Y axis
                                      new VertexPositionColor(new Vector3(0.0f, 0.0f, 0.0f), Color.DarkGreen),
                                      new VertexPositionColor(new Vector3(0.0f, -3000.0f, 0.0f), Color.DarkGreen),
                                      new VertexPositionColor(new Vector3(0.0f, 0.0f, 0.0f), Color.Green),
                                      new VertexPositionColor(new Vector3(0.0f, 3000.0f, 0.0f), Color.Green),
                                      //X axis
                                      new VertexPositionColor(new Vector3(0.0f, 0.0f, 0.0f), Color.DarkRed),
                                      new VertexPositionColor(new Vector3(-3000.0f, 0.0f, 0.0f), Color.DarkRed),
                                      new VertexPositionColor(new Vector3(0.0f, 0.0f, 0.0f), Color.Red),
                                      new VertexPositionColor(new Vector3(3000.0f, 0.0f, 0.0f), Color.Red),
                                      //X
                                      new VertexPositionColor(new Vector3(10.0f + 2.5f, 5.0f, 0.0f), Color.DarkRed),
                                      new VertexPositionColor(new Vector3(10.0f + 1.25f, 1.25f, 0.0f), Color.DarkRed),
                                      new VertexPositionColor(new Vector3(10.0f + 1.25f, 5.0f, 0.0f), Color.DarkRed),
                                      new VertexPositionColor(new Vector3(10.0f + 2.5f, 1.25f, 0.0f), Color.DarkRed),
                                      //Y
                                      new VertexPositionColor(new Vector3(1.875f, 10.0f + 3.125f, 0.0f), Color.DarkGreen),
                                      new VertexPositionColor(new Vector3(1.875f, 10.0f + 1.125f, 0.0f), Color.DarkGreen),
                                      new VertexPositionColor(new Vector3(1.875f, 10.0f + 3.125f, 0.0f), Color.DarkGreen),
                                      new VertexPositionColor(new Vector3(2.5f, 10.0f + 5.0f, 0.0f), Color.DarkGreen),
                                      new VertexPositionColor(new Vector3(1.875f, 10.0f + 3.125f, 0.0f), Color.DarkGreen),
                                      new VertexPositionColor(new Vector3(1.125f, 10 + 5.0f, 0.0f), Color.DarkGreen),
                                      //Z
                                       new VertexPositionColor(new Vector3(0.0f, 5.0f, 10.0f + 2.5f), Color.DarkBlue),
                                      new VertexPositionColor(new Vector3(0.0f, 5.0f, 10.0f + 1.25f), Color.DarkBlue),
                                      new VertexPositionColor(new Vector3(0.0f, 1.25f, 10.0f + 2.5f), Color.DarkBlue),
                                      new VertexPositionColor(new Vector3(0.0f, 1.25f, 10.0f + 1.25f), Color.DarkBlue),
                                      new VertexPositionColor(new Vector3(0.0f, 1.25f, 10.0f + 2.5f), Color.DarkBlue),
                                      new VertexPositionColor(new Vector3(0.0f, 5.0f, 10.0f + 1.25f), Color.DarkBlue)
                                     
                                      };
                short[] lineListIndices = new short[28] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27 };
                Game.GraphicsDevice.DrawUserIndexedPrimitives<VertexPositionColor>(
                    PrimitiveType.LineList,
                    pointList,
                    0,  // vertex buffer offset to add to each element of the index buffer
                    28,  // number of vertices in pointList
                    lineListIndices,  // the index buffer
                    0,  // first index element to read
                    14   // number of primitives to draw
                );
                pass.End();
            }
            basicEffect.End();
            device.RenderState.DepthBufferEnable = true;
            #endregion
        }
        
        #region transfer function




        private void setControlpoints()
        {
            colorControlPoints = GameProperties.Instance.colorControlPoints;
            alphaControlPoints = GameProperties.Instance.alphaControlPoints;
            
            #region debug
            //int idx = colorControlPoints.Count() - 1;
            //Console.WriteLine("data control point:" + colorControlPoints[1].color.ToString() + "; " + alphaControlPoints[1].color.W);
            #endregion

            float amount = 0.0f;
            Color[] colorArray = new Color[256];
            float[] alphaArray = new float[256];

            #region interpolate between ControlPoints

            // sort ControlPoints by isoValue
            colorControlPoints.Sort(delegate(TransferControlPoint p1,
                TransferControlPoint p2) { return p1.isoValue.CompareTo(p2.isoValue); });
            alphaControlPoints.Sort(delegate(TransferControlPoint p1,
                TransferControlPoint p2) { return p1.isoValue.CompareTo(p2.isoValue); });

            Console.WriteLine(alphaControlPoints[1].color.W);
            /*for (int i = 0; i < colorControlPoints.Count; i++)
            {
                Console.WriteLine("P" + i + " =" + colorControlPoints[i].isoValue);
            }*/

            // before first ControlPoint: fill with black and alpha 0.0f
            for (int i = 0; i < colorControlPoints[0].isoValue; i++)
            {
                colorArray[i] = Color.Black;
                alphaArray[i] = 0.0f;
            }

            for (int j = 0; j < colorControlPoints.Count-1; j++)
            {               
                for (int i = colorControlPoints[j].isoValue; i < colorControlPoints[j+1].isoValue; i++)
                {
                    amount = (((float)i - colorControlPoints[j].isoValue) /
                        (colorControlPoints[j+1].isoValue - colorControlPoints[j].isoValue));
                    colorArray[i] = Color.Lerp(new Color(colorControlPoints[j].color * 255),
                    new Color(colorControlPoints[j+1].color * 255), amount);
                    
                    //interpolate alpha
                    alphaArray[i] = alphaControlPoints[j].color.W * (1.0f - amount) + 
                        alphaControlPoints[j + 1].color.W * amount;
                }
            }

            // after last ControlPoint: fill with black and alpha
            for (int i = colorControlPoints[colorControlPoints.Count-1].isoValue+1; i < 256; i++)
            {
                colorArray[i] = Color.Black;
                alphaArray[i] = 0.0f;
            }

            GameProperties.Instance.colorArray = colorArray;
            GameProperties.Instance.alphaArray = alphaArray;
            GameProperties.Instance.updateColorBar = true;

            #endregion

            #region write to textures
            //write to a textures
            transferTexture = new Texture2D(Game.GraphicsDevice, 256, 1, 1, TextureUsage.Linear, SurfaceFormat.Color);
            transferTextureAlpha = new Texture2D(Game.GraphicsDevice, 256, 1, 1, TextureUsage.Linear, SurfaceFormat.Color);
            

            Byte4[] transferValues = new Byte4[256];
            Byte4[] alphaValues = new Byte4[256];
            for (int i = 0; i < 256; i++)
            {
                //Vector4 color = new Vector4(colorArray[i].R,colorArray[i].G,colorArray[i].B,colorArray[i].A);
                Vector4 color = new Vector4(colorArray[i].R, colorArray[i].G, colorArray[i].B, alphaArray[i]);
                color *= 255.0f;
                //store bgra, but why?
                transferValues[i] = new Byte4(color.Z, color.Y, color.X, color.W);
                Vector4 alpha = new Vector4(alphaArray[i]*255.0f);
                //Console.WriteLine(alpha);
                if ((i < 5) || (i > 250))
                {
                    alpha = new Vector4(255.0f, 0.0f, 0.0f, 1.0f);
                }
                alphaValues[i] = new Byte4(alpha.Z, alpha.Y, alpha.X, alpha.W);
            }

            transferTexture.SetData(transferValues);
            transferTextureAlpha.SetData(alphaValues);
            //transferTextureAlpha.Save("alpha.jpg", ImageFileFormat.Jpg);
            //transferTexture.Save("transfer.jpg", ImageFileFormat.Jpg);
            /*try
            {
                transferTexture.Save("transfer.jpg", ImageFileFormat.Jpg);
            }
            catch (Exception e)
            {
                Console.WriteLine("******************************************************************");
                Console.WriteLine(e);
            } */
            #endregion

            shader.TransferTexture = this.transferTexture; // TODO: only set if values changed!
            shader.TransferTextureAlpha = this.transferTextureAlpha; // TODO: only set if values changed!

            /*alphaControlPoints[0] = new TransferControlPoint(0.02f, 0);
            alphaControlPoints[1] = new TransferControlPoint(0.02f, 128);
            alphaControlPoints[2] = new TransferControlPoint(0.02f, 256);*/

        }

        #endregion

        #region Gradients

        private float getSampleAt(int x, int y, int z)
        {
            x = (int)MathHelper.Clamp(x, 0, sizeX - 1);
            y = (int)MathHelper.Clamp(y, 0, sizeY - 1);
            z = (int)MathHelper.Clamp(z, 0, sizeZ - 1);

            //y*width -> move rows down
            //z* (width*height) -> move planes into the volume
            int arrayIndex = x + y * sizeX + z * sizeX * sizeY;
            /*if ((arrayIndex < 0) || (arrayIndex >= densityValues.Count))
            {
                return 0.0f;
            }*/
            //Console.WriteLine(arrayIndex);
            return densityValues[arrayIndex];

            //return (float)mScalars[x + (y * mWidth) + (z * mWidth * mHeight)].ToVector4().W;
        }

        private void calculateGradients()
        {
            /*use Central difference in x-, y- & z-direction (in voxel):
             *                           ( f(x+1) - f(x-1) )
             * gradient f(x,y,z) = 1/2 * | f(y+1) - f(y-1) |
             *                           ( f(z+1) - f(z-1) ) 
             * */

            int sampleSize = GameProperties.Instance.gradientSampleSize;

            gradients = new Vector3[sizeX * sizeY * sizeZ];

            Vector3 normal = Vector3.Zero;

            int i = 0;
            for (int z = 0; z < sizeZ; z++)
            {
                for (int y = 0; y < sizeY; y++)
                {
                    for (int x = 0; x < sizeX; x++)
                    {
                        Vector3 gradient = new Vector3(
                            getSampleAt(x + sampleSize, y, z) - getSampleAt(x - sampleSize, y, z),
                            getSampleAt(x, y + sampleSize, z) - getSampleAt(x, y - sampleSize, z),
                            getSampleAt(x, y, z + sampleSize) - getSampleAt(x, y, z - sampleSize));

                        // does not matter how long gradient is => normalize (instead of * 1/2)
                        //gradients[i] = Vector3.Normalize(gradient);
                        gradients[i] = gradient;
                       i++;
                    }
                }
            }
        }

        #endregion

        #region help functions




        private void loadDatafromFileExtend()
        {
            #region read data
            Stream file = new FileStream(fileName, FileMode.Open);

            BinaryReader reader = new BinaryReader(file);

            //read header
            sizeX = reader.ReadUInt16();
            sizeY = reader.ReadUInt16();
            sizeZ = reader.ReadUInt16();
            ushort sizeXOld = sizeX;
            ushort sizeYOld = sizeY;
            ushort sizeZOld = sizeZ;

            sizeX = calculatePowerOfTwo(sizeX);
            sizeY = calculatePowerOfTwo(sizeY);
            sizeZ = calculatePowerOfTwo(sizeZ);

            

            List<float> scalars = new List<float>();
            //volumeData = new Texture3D(Game.GraphicsDevice, sizeX, sizeY, sizeZ, 0, TextureUsage.Linear, SurfaceFormat.Single);
            volumeData = new Texture3D(Game.GraphicsDevice, sizeX, sizeY, sizeZ, 0,
                        TextureUsage.Linear, SurfaceFormat.Vector4);
            for (int idxZ = 0; idxZ < sizeZ; idxZ++)
            {
                for (int idxY = 0; idxY < sizeY; idxY++)
                {
                    for (int idxX = 0; idxX < sizeX; idxX++)
                    {
                        if (idxX >= sizeXOld || idxY >= sizeYOld || idxZ >= sizeZOld)
                        {
                            scalars.Add(0.0f);
                           
                        }
                        else
                        {
                            ushort value = reader.ReadUInt16();
                            scalars.Add((float)value);
                            
                        }
                    }
                }
            }

            reader.Close();
            #endregion

            #region scale data
            float maxVal = 1.0f / scalars.Max();
            for (int i = 0; i < scalars.Count(); i++)
            {
                scalars[i] = scalars[i] * maxVal;
            }
            #endregion

            #region add gradients to VolumeData
            densityValues = scalars;
            //volumeData.SetData(scalars.ToArray());
            calculateGradients();
            Vector4[] densityVectors = new Vector4[scalars.Count()];
            for (int i = 0; i < scalars.Count(); i++)
            {
                densityVectors[i] = new Vector4(gradients[i].X,
                                                    gradients[i].Y,
                                                    gradients[i].Z,
                                                    densityValues[i]);
            }
            volumeData.SetData<Vector4>(densityVectors);
            #endregion

            #region sort data
            densityValues.Sort();
            sortDensityValues();
            #endregion

        }

        private ushort calculatePowerOfTwo(int value)
        {
            //check if value is power of to
            if (value > 0)
            {
                if ((value & (value - 1)) == 0) return (ushort)value;

                //calculate the next highest power of two
                else
                {
                    value--;
                    for (int i = 1; i < sizeof(int) * 8; i <<= 1)
                    {
                        value = value | value >> 1;
                    }

                    ushort returnValue = (ushort)(value + 1);
                    return returnValue;
                }
            }
            else
            {
                return 1;
            }
        }

        private void setSliceRange(int xRange, int yRange, int zRange)
        {
            GameProperties.Instance.xDataRange = xRange;
            GameProperties.Instance.yDataRange = yRange;
            GameProperties.Instance.zDataRange = zRange;
            GameProperties.Instance.updateGuiForm = true;
        }
        #endregion
    }
}