trunk/visLU/FlowData.cs

Go to the documentation of this file.

#region Using Statements
using System;
using System.Text.RegularExpressions;
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 Microsoft.Xna.Framework.Graphics.PackedVector;
using visLU2.Effects;
#endregion


namespace visLU2
{
    class FlowData: DrawableGameComponent
    {
        private Game game;
        private GraphicsDevice device;
        private SpriteBatch spriteBatch;
        private FlowShader shader;

        private string griFileName;
        private List<string> datFileNames;

        #region flow data header
        //header information
        string headerName;
        int sizeX, sizeY, sizeZ; //==SX, SY, SZ in the file header definition
        int channelNumber; // == NF 
        int timestepNumber; // == NT
        float timestepDuration; // == DT
        #endregion

        #region flow data geometry
        //min and max vertex values in this geometry data, size = max - min
        Vector2 boundaryMin;
        Vector2 boundaryMax;
        Vector2 boundaryLength;
        //save all vertices in the grid
        Vector2[] gridData;
        Vector2[] normalizedGridData;

        //if the x and y axes have to be swaped
        bool isFlipped = false;
        bool bigEndian = false;
        #endregion

        #region flow data channels
        //all channels data, 
        //each element in the array represents all channels in a single time step(the next time step)
        // == channelData[i] storage channels from a single .dat file
        FlowChannel[] channelData; 
        #endregion

        #region vertex buffer
        Camera camera;
        BasicEffect basicEffect;
        BasicEffect basicEffect2;
        Matrix world;

        VertexDeclaration vertexDeclr; //custom vertex declaration
        VertexBuffer vertexBuffer; //stores mesh vertices 
        IndexBuffer indexBuffer; //and mesh indices
        
        GridVertices[] meshVertices; //mesh vertices in custom format
        int[] meshIndices; //mesh indices
        #endregion

        #region other variables
        int currTimeStep = 0;
        public List<TransferControlPoint> colorControlPoints;
        private Texture2D transferTexture;
        bool initialControPoints = true;

        Texture2D arrow;
        ArrowPlot arrowPlot;
        RenderTarget2D arrowTarget;
        Texture2D arrowsTexture;
        DepthStencilBuffer stencilArrow;
        VertexBuffer vertexBuffer_arrow; //stores mesh vertices 
        IndexBuffer indexBuffer_arrow; //and mesh indices
        int[] arrowIndices;
        VertexPositionTexture[] verticeArray_arrows;
        float stepsizeX = 0.8f;
        float stepsizeY = 0.8f;
        float minMagnitude;
        float maxMagnitude;
        DepthStencilBuffer stencilData;
        #endregion

        #region streamline variables
        private float dt = 0.1f;//TODO: move to Streamlines
        Streamlines streamlines_euler;
        Streamlines streamlines_rungeKutta;
        int startSeedPointSearchAtIndex = 0;
        CartesianGrid cGrid;
        #endregion

        #region Properties
        public Camera Camera
        {
            set { camera = value; }
            get { return camera; }
        }

        public Vector2 BoundaryLength
        {
            get { return boundaryLength; }
        }
        public Vector2 BoundaryMin
        {
            get { return boundaryMin; }
        }
        public Vector2 BoundaryMax
        {
            get { return boundaryMax; }
        }
        #endregion

        #region Constructor
        public FlowData(string rootFileName, bool relativePath, Game game)
            : base(game)
        {

            this.game = game;
            colorControlPoints = new List<TransferControlPoint>();

            if (relativePath)
            {

                string a = "" + Directory.GetParent((string)Directory.GetCurrentDirectory());
                string b = "" + Directory.GetParent(a);
                string c = "" + Directory.GetParent(b);

                //get .gri file
                griFileName = c + "\\" + rootFileName;
            }
            else 
            {
                griFileName = rootFileName;
            }

            if (string.IsNullOrEmpty(griFileName))
            {
                throw new ArgumentNullException(griFileName);
            }

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

            //get all add .dat files
            datFileNames = new List<string>();
            DirectoryInfo currDir = Directory.GetParent(griFileName);
            string filename = griFileName.Substring((griFileName.LastIndexOf("\\") + 1));
            filename = filename.Substring(0,(filename.Length - 4));
            FileInfo[] datFileNamesTmp = currDir.GetFiles("*.dat");
           

            foreach (FileInfo datFileNextTmp in datFileNamesTmp)
            {
                //string [] extractName = datFileNextTmp.Name.Split('.');
                if (datFileNextTmp.Name.Split('.')[0].Equals(filename))
                {
                    datFileNames.Add(currDir + "\\" + datFileNextTmp.Name);
                }
            }

            if (datFileNames.Count() == 0)
            {
                throw new ArgumentException(".dat files are missing");
            }

            datFileNames.Sort();

        }
        #endregion

        #region Initialize





        public override void Initialize()
        {
            spriteBatch = Game.Services.GetService(typeof(SpriteBatch)) as SpriteBatch;
            if (spriteBatch == null)
                throw new InvalidOperationException("SpriteBatch Service not found");

            device = Game.GraphicsDevice;

            base.Initialize();
        }
        #endregion

        #region LoadContent



        protected override void LoadContent()
        {

            loadDatafromFile();
            //createUniformGrid();

            #region initialize control points and channels
            //init gui information
            if (GameProperties.Instance.channelControlPoints.Count() > 0) GameProperties.Instance.channelControlPoints.Clear();
            if (GameProperties.Instance.channelNames.Count() > 0) GameProperties.Instance.channelNames.Clear();
            switch (GameProperties.Instance.dataFilename.Substring(GameProperties.Instance.dataFilename.LastIndexOf("\\") + 1))
            {
                case "c_block.gri":
                    GameProperties.Instance.channelNames.Add(GameProperties.Instance.blockDataChannels[0]);
                    GameProperties.Instance.channelNames.Add(GameProperties.Instance.blockDataChannels[1]);
                    GameProperties.Instance.channelNames.Add(GameProperties.Instance.blockDataChannels[2]);
                    break;
                case "hurricane_p_tc_singletime48.gri":
                    GameProperties.Instance.channelNames.Add(GameProperties.Instance.hurricaneDataChannels[0]);
                    GameProperties.Instance.channelNames.Add(GameProperties.Instance.hurricaneDataChannels[1]);
                    GameProperties.Instance.channelNames.Add(GameProperties.Instance.hurricaneDataChannels[2]);
                    break;
                case "hurricane_p_tc_singletime10.gri":
                    GameProperties.Instance.channelNames.Add(GameProperties.Instance.hurricaneDataChannels[0]);
                    GameProperties.Instance.channelNames.Add(GameProperties.Instance.hurricaneDataChannels[1]);
                    GameProperties.Instance.channelNames.Add(GameProperties.Instance.hurricaneDataChannels[2]);
                    break;
                default:
                    GameProperties.Instance.channelNames.Add("Channel 1");
                    GameProperties.Instance.channelNames.Add("Channel 2");
                    GameProperties.Instance.channelNames.Add("Channel 3");
                    break;
            }
            GameProperties.Instance.currentChannelIdx = 0;

            //set initial control points for the arrow plot
            if (GameProperties.Instance.arrowControlPoints.Count() > 0) GameProperties.Instance.arrowControlPoints.Clear();
            GameProperties.Instance.arrowControlPoints.Add(new TransferControlPoint(255, 255, 130, 0));
            GameProperties.Instance.arrowControlPoints.Add(new TransferControlPoint(200, 0, 0, 130));
            GameProperties.Instance.arrowControlPoints.Add(new TransferControlPoint(130, 255, 255, 256));
            GameProperties.Instance.arrowColorArray = new Color[256];

            //set initial control points and 
            //init color array for each channel
            if (GameProperties.Instance.colorArray.Count() > 0) GameProperties.Instance.colorArray.Clear();
            for (int i = 0; i < GameProperties.Instance.channelNames.Count(); i++)
            {
                List<TransferControlPoint> cpList = new List<TransferControlPoint>();
                cpList.Add(new TransferControlPoint(255, 255, 130, 0));
                cpList.Add(new TransferControlPoint(200, 0, 0, 130));
                cpList.Add(new TransferControlPoint(130, 255, 255, 256));
                GameProperties.Instance.channelControlPoints.Add(cpList);
                GameProperties.Instance.colorArray.Add(new Color[256]);
            }
            initialControPoints = true;
            #endregion

            #region initialize vertex buffer
            //load vertex declaration for custom vertex format GridVertices
            vertexDeclr = new VertexDeclaration(GraphicsDevice, GridVertices.VertexElements);

            basicEffect = new BasicEffect(GraphicsDevice, null);
            basicEffect2 = new BasicEffect(GraphicsDevice, null);
            //basicEffect.VertexColorEnabled = true;
            Effect flowEffect = Game.Content.Load<Effect>("Effects\\flowShader");
            shader = new FlowShader(Game, GraphicsDevice, flowEffect);
            world = Matrix.Identity;
            #region depricated (scale to window width or height)
            /*float scaleValue = Math.Max(boundaryLength.X, boundaryLength.Y);

            //float scaleHeight = GameProperties.Instance.XNADrawSurfaceHeight / scaleValue;
            //float scaleWidth = GameProperties.Instance.XNADrawSurfaceWidth / scaleValue;

            Console.WriteLine("scaleValue=" + scaleValue);
            scaleValue = (GameProperties.Instance.XNADrawSurfaceHeight/65.0f) / scaleValue;
            Console.WriteLine("boundaryMax.X="+boundaryMax.X+ " boundaryMax.Y=" + boundaryMax.Y +
                " scaleValue=" + scaleValue + " window=" +
                GameProperties.Instance.XNADrawSurfaceHeight);*/
            #endregion

            generateGridMesh();
            #endregion

            initalizeArrowPlot();

            initalizeStreamlines();
          
            base.LoadContent();
        }

        #region initialize Streamlines
        private void initalizeStreamlines()
        {
            // create Cartesian Grid for stream line sample points:
            
            //stepsizeX = boundaryLength.X / GameProperties.Instance.apStepsize;
            //stepsizeY = boundaryLength.Y / GameProperties.Instance.apStepsize;

            GameProperties.Instance.maxLineLength = (int)MathHelper.Max(boundaryLength.X, boundaryLength.Y);
            GameProperties.Instance.maxDsep = (int)(MathHelper.Max(boundaryLength.X, boundaryLength.Y));
            GameProperties.Instance.Dt = 0.01f;
            GameProperties.Instance.Dsep = GameProperties.Instance.maxDsep * 0.1f;
            GameProperties.Instance.Dtest = GameProperties.Instance.Dsep * 0.15f;
            GameProperties.Instance.lineWidth = GameProperties.Instance.Dtest * 0.5f;
              
        }



        #region SeedPoints
        private Vector2 findNewSeedPoint(Streamlines streamelines)
        {
            Vector2 seedPoint;
            bool accept = false;
            // start at first streamline where there are still seed points possible
            for (int k = startSeedPointSearchAtIndex; k < streamelines.StreamlineList.Count; k++)
            {
                Streamline line = streamelines.StreamlineList[k];
                #region search for seed point next to line
                for (int i = line.StartSeedPointSearchAtIndex; i < line.Points.Count-1; i++)
                {
                    Vector2 currentPosition = line.Points[i];
                    Vector2 direction = line.Points[i + 1] - currentPosition;
                    Vector2 normal = new Vector2(direction.Y, -direction.X);
                    normal.Normalize();

                    // - X
                    seedPoint = currentPosition + (normal * streamelines.Dsep);
                    accept = acceptSeedPoint(streamelines, line, seedPoint);
                    if (accept)
                    {
                        line.setStartSeedPointSearchAtIndex(i);
                        streamelines.StreamlineList[k] = line;
                        return seedPoint;
                    }

                    // - Y
                    seedPoint = currentPosition - (normal * streamelines.Dsep);
                    accept = acceptSeedPoint(streamelines, line, seedPoint);
                    if (accept)
                    {
                        line.setStartSeedPointSearchAtIndex(i);
                        streamelines.StreamlineList[k] = line; 
                        return seedPoint;
                    }
                }
                #endregion
                startSeedPointSearchAtIndex++;
            }
            return new Vector2(-1000.0f, -1000.0f); // no more seed points possible!
        }

        private bool acceptSeedPoint(Streamlines streamlines, Streamline line, Vector2 position)
        {
            // seed point leaves flow domain
            if ((position.X > gridData[gridData.Length - 1].X) || (position.Y > gridData[0].Y)
                || (position.X < gridData[0].X) || (position.Y < gridData[gridData.Length - 1].Y))
            {
                return false;
            }

            // seed point is fixed point (v=0)
            Vector3 velocity = getInterpolatedVector(position.X, position.Y);
            if ((velocity.X == 0.0f) || (velocity.Y == 0.0f))
            {
                return false;
            }

            // dist. to neighboring streamline ≤ DSep
            //check all previous lines
            for (int i = 0; i < streamlines.StreamlineList.Count; i++)
            {
                //compare to every point of every line
                for (int j = 0; j < streamlines.StreamlineList[i].Points.Count; j++)
                {
                    float dist = Vector2.Distance(position, streamlines.StreamlineList[i].Points[j]);
                    if (dist < streamlines.Dtest)
                    {
                        return false;
                    }
                }
            }

            return true;
        }
        #endregion SeedPoints

        private Boolean streamlineStop(int index, Vector2 position, Streamline line)
        {
            // streamline leaves flow domain
            if ((position.X > gridData[gridData.Length - 1].X) || (position.Y > gridData[0].Y)
                || (position.X < gridData[0].X) || (position.Y < gridData[gridData.Length - 1].Y))
            {
                return true;
            }

            // after a certain amount of maximal steps
            if (line.Points.Count*dt > streamlines_euler.MaxLength)
            {
                return true;
            }

            // streamline runs into fixed point (v=0)
            Vector3 velocity = getInterpolatedVector(position.X, position.Y);
            if ((velocity.X == 0.0f)||(velocity.Y == 0.0f))
            {
                return true;
            }

            // dist. to neighboring streamline ≤ dtest
            List<SamplePoint> pointsToCheck = cGrid.getPointsToCheck(position);
            //compare to every point in surrounding cells!
            for (int i = 0; i < pointsToCheck.Count; i++)
            {

                float dist = Vector2.Distance(position, pointsToCheck[i].Position);
                if (pointsToCheck[i].StreamLineIndex == index)
                {
                    
                    //streamlines.StreamlineList[index].Points
                    if (dist < dt*0.75f)
                    {
                        return true;
                    }
                    continue;
                    /*// streamline gets too near to itself
                    int countNearestPoints = (int)(streamlines.Dtest / dt) * 2;
                    float dist = Vector2.Distance(line.Points[i], position);
                    if ((i < countNearestPoints) && (dist < streamlines.Dtest))
                    {
                        return true;
                    }
                    if ((i >= countNearestPoints) && (dist < 2 * dt))
                    {
                        return true;
                    }*/
                    
                }
                //float dist = Vector2.Distance(position, pointsToCheck[i].Position);
                if (dist < streamlines_euler.Dtest)
                {
                    return true;
                }
            }

            return false;
        }

        private float calculateTickness(Vector2 position)
        {
            float tickness = 1.0f;

            float dist = 10000; //get distance to the closest streamline

            List<SamplePoint> pointsToCheck = cGrid.getPointsToCheck(position);
            //compare to every point in surrounding cells!
            for (int i = 0; i < pointsToCheck.Count; i++)
            {
                float dist1 = Vector2.Distance(position, pointsToCheck[i].Position);
                dist = Math.Min(dist, dist1);
            }

            if (dist < GameProperties.Instance.Dsep)
            {
                tickness = (dist - GameProperties.Instance.Dtest) / (GameProperties.Instance.Dsep - GameProperties.Instance.Dtest);
            }
            else
            {
                tickness = 1.0f;
            }

            return tickness;
        }
        #endregion

       


        private void loadDatafromFile()
        {
            //bigEndian = !BitConverter.IsLittleEndian;
            //reverse byte order if bigEndian = true

            #region read .gri

            Stream file = new FileStream(griFileName, FileMode.Open);
            BinaryReader reader = new BinaryReader(file);

            #region read header
            byte[] headerBuffer = new byte[40];
            reader.Read(headerBuffer, 0, 40);

            string header = System.Text.ASCIIEncoding.ASCII.GetString(headerBuffer);
     
            Regex stringSeq = new Regex("[a-zA-Z0-9]+");
            Regex positiveInt = new Regex("0*[1-9][0-9]*");
            Regex positiveFloat = new Regex("[0-9]+[.][0-9]*");
            Regex emptySpace = new Regex(" ");

            int pos = 0;

            try
            {
                Match match_strName = stringSeq.Match(header, pos);
                if (match_strName.Success)
                {
                    headerName = match_strName.ToString();
                    pos += match_strName.Length;
                }

                if (emptySpace.Match(header, pos).Success) { pos++; }


                Match match_strX = positiveInt.Match(header, pos);
                if (match_strX.Success)
                {
                    sizeX = int.Parse(match_strX.ToString());
                    pos += match_strX.Length;
                }

                if (emptySpace.Match(header, pos).Success) { pos++; }

                Match match_strY = positiveInt.Match(header, pos);
                if (match_strY.Success)
                {
                    sizeY = int.Parse(match_strY.ToString());
                    pos += match_strY.Length;
                }

                if (emptySpace.Match(header, pos).Success) { pos++; }

                Match match_strZ = positiveInt.Match(header, pos);
                if (match_strZ.Success)
                {
                    sizeZ = int.Parse(match_strZ.ToString());
                    pos += match_strZ.Length;
                }

                if (emptySpace.Match(header, pos).Success) { pos++; }

                Match match_strNumber1 = positiveInt.Match(header, pos);
                if (match_strNumber1.Success)
                {
                    channelNumber = int.Parse(match_strNumber1.ToString());
                    pos += match_strNumber1.Length;
                }

                if (emptySpace.Match(header, pos).Success) { pos++; }

                Match match_strNumber2 = positiveInt.Match(header, pos);
                if (match_strNumber2.Success)
                {
                    timestepNumber = int.Parse(match_strNumber2.ToString());
                    pos += match_strNumber2.Length;
                }

                if (emptySpace.Match(header, pos).Success) { pos++; }

                Match match_strDur = positiveFloat.Match(header, pos);
                if (match_strDur.Success)
                {
                    timestepDuration = float.Parse(match_strDur.ToString());
                    pos += match_strDur.Length;
                }

            }catch(Exception e)
            
            {
                Console.WriteLine("Some header information is missing");
            }

            #endregion

            #region read geometry data
            gridData = new Vector2[sizeX * sizeY];
            int nextPos = 0;
            try
            {

                for (int y = 0; y < sizeY; y++)
                {
                    for (int x = 0; x < sizeX; x++)
                    {
                  
                        gridData[nextPos].X = BitConverter.ToSingle(reader.ReadBytes(4), 0);
                        gridData[nextPos].Y = BitConverter.ToSingle(reader.ReadBytes(4), 0);
                        float Z_unused = BitConverter.ToSingle(reader.ReadBytes(4), 0);

                        nextPos++;

                    }
                }

            }
            catch (EndOfStreamException e)
            {
                Console.WriteLine(e.Message);
            }
            finally
            {
                reader.Close();
                file.Close();
            }

            #endregion
             
            reader.Close();
            file.Close();
            #endregion

            #region initialize dimensions
            int firstIdx = 0;
            int lastIdx = (sizeX * sizeY) - 1;
            boundaryMin = gridData[firstIdx];
            boundaryMax = gridData[lastIdx];
            boundaryLength = boundaryMax - boundaryMin;


            //if X and Y are swapped... meaning that going in a row the y value increases and x stays the same
            if (gridData[sizeX - 1].Y > (boundaryMin.Y + boundaryMax.Y) * 0.5)
            {
                isFlipped = true;
                for (int i = 0; i < gridData.Length; i++)
                {
                    float x = gridData[i].X;
                    float y = gridData[i].Y;
                    gridData[i].X = y;
                    gridData[i].Y = x;
                }
            }
            else isFlipped = false;

            #endregion

            #region read .dat
            channelData = new FlowChannel[datFileNames.Count];
            channelNumber += 1; //store velocity magnitude as channel too

            for (int i = 0; i < datFileNames.Count; i++)
            {
                channelData[i] = new FlowChannel(sizeX, sizeY, channelNumber, i);
            }

            for(int i = 0; i < datFileNames.Count; i++)
            {
                Stream datFile = new FileStream(datFileNames[i], FileMode.Open);
                BinaryReader datReader = new BinaryReader(datFile);

                Vector3 minVelocity = new Vector3();
                Vector3 maxVelocity = new Vector3();
                float[] minChannel = new float[channelNumber];
                float[] maxChannel = new float[channelNumber];
                bool firstLoop = true;
                bool firstInnerLoop = true;
                int nextPos1 = 0;
                for (int y = 0; y < sizeY; y++)
                    {
                        for (int x = 0; x < sizeX; x++)
                        {

                            Vector3 velocity = new Vector3();
                            if (isFlipped)
                            {
                                velocity.Y = BitConverter.ToSingle(datReader.ReadBytes(4), 0);
                                velocity.X = BitConverter.ToSingle(datReader.ReadBytes(4), 0);
                            }
                            else 
                            {
                                velocity.X = BitConverter.ToSingle(datReader.ReadBytes(4), 0);
                                velocity.Y = BitConverter.ToSingle(datReader.ReadBytes(4), 0);
                            }
                            velocity.Z = BitConverter.ToSingle(datReader.ReadBytes(4), 0);

                            channelData[i].Velocity.VelocityValues[nextPos1] = velocity;

                            if (!firstLoop)
                            {
                                minVelocity = Vector3.Min(minVelocity, velocity);
                                maxVelocity = Vector3.Max(maxVelocity, velocity);
                                minMagnitude = MathHelper.Min(velocity.Length(), minMagnitude);
                                maxMagnitude = MathHelper.Max(velocity.Length(), maxMagnitude);
                            }
                            else 
                            {
                                minVelocity = velocity;
                                maxVelocity = velocity;
                                minMagnitude = MathHelper.Min(velocity.Length(), minMagnitude);
                                maxMagnitude = MathHelper.Max(velocity.Length(), maxMagnitude);
                                firstLoop = false;
                            }

                            for (int j = 0; j < channelNumber; j++)
                            {
                                float channelVal;
                                if (j == 0)
                                {
                                    channelVal = velocity.Length(); //velocity magnitude
                                }
                                else 
                                {
                                    channelVal = BitConverter.ToSingle(datReader.ReadBytes(4), 0);
                                }
                                channelData[i].AddChannels[j].ChannelValues[nextPos1] = channelVal;
                                if (!firstInnerLoop)
                                {
                                    minChannel[j] = Math.Min(minChannel[j], channelVal);
                                    maxChannel[j] = Math.Max(maxChannel[j], channelVal);
                                }
                                else 
                                {
                                    minChannel[j] = channelVal;
                                    maxChannel[j] = channelVal;
                                    firstInnerLoop = false;
                                }
                            }//end channel loop

                            nextPos1++;
                        }

                        
                    }//end current file loop  

              
                channelData[i].setMinVelocity(minVelocity);
                channelData[i].setMaxVelocity(maxVelocity);
                for (int j = 0; j < channelNumber; j++)
                {
                    channelData[i].setChannelMinVal(j,minChannel[j]);
                    channelData[i].setChannelMaxVal(j,maxChannel[j]);
                }
                firstLoop = true;
                firstInnerLoop = true;

                datReader.Close();
                datFile.Close();
            }//end outer loop

            #endregion

            

        }

        #region grid




        private void generateGridMesh()
        {
            int vertCount = sizeX * sizeY;
            int trianglesCount = (sizeX - 1) * (sizeY - 1) * 2;

            //generate indices
            meshIndices = generateMeshIndices(trianglesCount);
            indexBuffer = new IndexBuffer(device, trianglesCount * 3 * sizeof(int), BufferUsage.WriteOnly, IndexElementSize.ThirtyTwoBits);
            indexBuffer.SetData<int>(meshIndices);

            //generate vertices
            //meshVertices = generateTestVertices();
            meshVertices = generateMeshVertices();
            vertexBuffer = new VertexBuffer(GraphicsDevice, vertCount * GridVertices.SizeInBytes, BufferUsage.WriteOnly);
            vertexBuffer.SetData<GridVertices>(meshVertices);

        }

        private int[] generateMeshIndices(int trianglesCount)
        {
            int[] meshIndices = new int[trianglesCount * 3];
            int nextIdx = 0;

            for (int row = 0; row < (sizeY-1); row++)
            {
                for (int col = 0; col < (sizeX-1); col++)
                {
                    int idx = col + row * sizeX;

                    meshIndices[nextIdx++] = idx;
                    meshIndices[nextIdx++] = idx + 1;
                    meshIndices[nextIdx++] = idx + sizeX + 1;
                    meshIndices[nextIdx++] = idx + sizeX + 1;
                    meshIndices[nextIdx++] = idx + sizeX;
                    meshIndices[nextIdx++] = idx;

                }
            }
            return meshIndices;

        }

        private GridVertices[] generateMeshVertices()
        {
            GridVertices[] meshVert = new GridVertices[sizeX * sizeY];
            for (int i = 0; i < sizeX * sizeY; i++)
            {
                //convert to xna vertex coord system
                gridData[i].Y = boundaryMin.Y + boundaryLength.Y - gridData[i].Y;
                //gridData[i].Y = gridData[i].Y * (-1.0f);
                meshVert[i].Position = gridData[i];
                meshVert[i].Velocity = channelData[currTimeStep].Velocity.VelocityValues[i];
                meshVert[i].AddChannels = new Vector3(
                    channelData[currTimeStep].AddChannels[0].NormValues[i], //velocity magnitude
                    channelData[currTimeStep].AddChannels[1].NormValues[i],
                    channelData[currTimeStep].AddChannels[2].NormValues[i]);
            }

            //meshVert = generateTextureCoord(meshVert);  
            //meshVert = generateNormals(meshIndices, meshVert);
            return meshVert;

        }

        private GridVertices[] generateTestVertices()
        {
            GridVertices[] meshVert = new GridVertices[sizeX * sizeY];

            int nextVert = 0;
            for (float row = 0; row <= sizeY; row +=3)
            {
                for (float col = 0; col <=sizeX; col += 2.0f)
                {
                    
                    meshVert[nextVert].Position = new Vector2(col, row);
                    //meshVert[i].Velocity = channelData[currTimeStep].Velocity.VelocityValues[i];
                    //meshVert[i].AddChannels = new Vector2(channelData[currTimeStep].AddChannels[0].ChannelValues[i], channelData[currTimeStep].AddChannels[1].ChannelValues[i]);
         
                    nextVert++;
                }

            }
            return meshVert;
        }
        #endregion

        #region arrow plot

        private void initalizeArrowPlot()
        {
            arrow = game.Content.Load<Texture2D>("Sprites\\arrow1");
            arrowPlot = new ArrowPlot(sizeX, sizeY);
            
            device.PresentationParameters.MultiSampleType = device.DepthStencilBuffer.MultiSampleType;

            PresentationParameters pp = device.PresentationParameters;
            //pp.BackBufferWidth = (int)(boundaryLength.X*50.0f);
            //pp.BackBufferHeight = (int)(boundaryLength.Y * 50.0f);

            // define Stencil Buffer for Arrows
            stencilArrow = new DepthStencilBuffer(device, (int)(boundaryLength.X * 50.0f), (int)(boundaryLength.Y * 50.0f),
                device.DepthStencilBuffer.Format, device.DepthStencilBuffer.MultiSampleType,
                device.PresentationParameters.MultiSampleQuality);

            arrowTarget = new RenderTarget2D(device, (int)(boundaryLength.X * 50.0f),
                (int)(boundaryLength.Y * 50.0f), 1, device.DisplayMode.Format,
                device.DepthStencilBuffer.MultiSampleType,
                device.PresentationParameters.MultiSampleQuality);

            //vertex buffer
            VertexPositionTexture v1 = new VertexPositionTexture(
                new Vector3(gridData[0], 0.0f), new Vector2(0.0f, 0.0f));
            VertexPositionTexture v2 = new VertexPositionTexture(
                new Vector3(gridData[sizeX-1], 0.0f), new Vector2(1.0f, 0.0f));
            VertexPositionTexture v3 = new VertexPositionTexture(
                new Vector3(gridData[sizeX*(sizeY-1)], 0.0f), new Vector2(0.0f, 1.0f));
            VertexPositionTexture v4 = new VertexPositionTexture(
                new Vector3(gridData[gridData.Length - 1], 0.0f), new Vector2(1.0f, 1.0f));
            verticeArray_arrows = new VertexPositionTexture[] { v1, v2, v3, v4 };
            vertexBuffer_arrow = new VertexBuffer(GraphicsDevice, 4 * VertexPositionTexture.SizeInBytes, BufferUsage.WriteOnly);
            vertexBuffer_arrow.SetData<VertexPositionTexture>(verticeArray_arrows);

            Console.WriteLine("min=" + boundaryMin + " max=" + BoundaryMax);

            //index buffer
            //generate indices
            arrowIndices = new int[] { 0, 1, 2, 2, 3, 1 };
            indexBuffer_arrow = new IndexBuffer(device, 2 * 3 * sizeof(int), BufferUsage.WriteOnly, IndexElementSize.ThirtyTwoBits);
            indexBuffer.SetData<int>(arrowIndices);


            //updateArrowPlot();

        }

        private void updateArrowPlot()
        {
            
            #region generate plot attributes
            //generate plot positions
            
            stepsizeX = boundaryLength.X / GameProperties.Instance.apStepsize;
            stepsizeY = boundaryLength.Y / GameProperties.Instance.apStepsize;

            float magnitudeRange = maxMagnitude - minMagnitude;

            arrowPlot.clear();

            for (float y = gridData[gridData.Length - 1].Y + (stepsizeY / 2.0f);
                y < gridData[0].Y; y += stepsizeY)
            {
                for (float x = gridData[0].X + (stepsizeX / 2.0f);
                    x < gridData[gridData.Length - 1].X; x += stepsizeX)
                {

                    #region interpolate velocity and calculate magnitude
                    Vector3 interpolatedVelocity = getInterpolatedVector(x, y);

                    //calculate angle between interpolatedVelocity and x- (or y-) axis
                    Vector2 vec1 = new Vector2(interpolatedVelocity.X, interpolatedVelocity.Y);
                    //Console.WriteLine("ohne normalisieren: " + vec1);
                    vec1.Normalize();
                    float rotAngle = (float)Math.Acos((double)Vector2.Dot(vec1, new Vector2(1.0f, 0.0f)));
                    if (interpolatedVelocity.Y < 0)
                    {
                        rotAngle = MathHelper.ToRadians(360) - rotAngle;
                    }
                    //calculate magnitude of interpolatedVelocity
                    float defaultMagnitude = 1.0f;
                    //float magnitude = defaultMagnitude;
                    float magnitude = interpolatedVelocity.Length() / (maxMagnitude);
                    magnitude /= 3.0f;
                    #endregion

                    #region color and alpha
                    Color color;
                    if (GameProperties.Instance.enableArrowTransferFunction)
                    {
                        //get color from transferfunction in respect to magnitude
                        color = GameProperties.Instance.arrowColorArray[(int)(magnitude * 255)];
                        //color = Color.White;
                    }
                    else
                    {
                        //get default color
                        color = Color.White;
                    }

                    //set alpha 
                    float alpha = MathHelper.Lerp((color.A / 255), GameProperties.Instance.apAlpha, 1.0f);
                    color.A = (byte)(alpha * 255);
                    #endregion

                    #region scale arrow in respect to magnitude
                    if (GameProperties.Instance.scaleArrowLength)
                    {
                        arrowPlot.Scale.Add(magnitude);
                    }
                    else
                    {
                        arrowPlot.Scale.Add(0.25f);
                    }
                    #endregion

                    //save data
                    //arrowPlot.Position.Add(new Vector2(x, y));
                    arrowPlot.Position.Add(new Vector2(x, boundaryLength.Y - y));
                    //arrowPlot.Position.Add(new Vector2(x, y));
                    //arrowPlot.Position.Add(new Vector2(transX + x, transY + y));
                    arrowPlot.Orientation.Add(rotAngle);
                    arrowPlot.Magnitude.Add(magnitude);
                    arrowPlot.Color.Add(color);

                }
            }
            #endregion

            CreateArrowTexture();
        }

        private void updateStreameLines()
        {
            //reset
            if (GameProperties.Instance.enableRungeKutta)
            {
                streamlines_rungeKutta.resetStreamlines();
                //int maxLength = (int)MathHelper.Max(boundaryLength.X, boundaryLength.Y);
                streamlines_rungeKutta = new Streamlines(GameProperties.Instance.Dsep, GameProperties.Instance.Dtest,
                    (int)GameProperties.Instance.lineLength);
            }
            else
            {
                streamlines_euler.resetStreamlines();
                //int maxLength = (int)MathHelper.Max(boundaryLength.X, boundaryLength.Y);
                streamlines_euler = new Streamlines(GameProperties.Instance.Dsep, GameProperties.Instance.Dtest,
                    (int)GameProperties.Instance.lineLength);
            }
            
            startSeedPointSearchAtIndex = 0;
            cGrid = null;
            
            cGrid = new CartesianGrid(GameProperties.Instance.Dsep,
                gridData[gridData.Length - 1].X - gridData[0].X,
                gridData[0].Y - gridData[gridData.Length - 1].Y);
            

            if (!GameProperties.Instance.enableRungeKutta)
            {
                #region euler integration 1st order

                Vector2 stepsize = new Vector2(stepsizeX, stepsizeY);

                int streamLineIndex = 0;
                // start position of first streamline:
                Vector2 currentPosition = new Vector2(gridData[0].X + (float)(stepsizeX * 0.5),
                    gridData[gridData.Length - 1].Y + (stepsizeY * 0.5f));
                Vector2 currentPosition_backward = currentPosition;
                bool finished = false; // finished when no more seedpoints possible            
                while (!finished)
                {
                    Streamline currentLine = new Streamline(currentPosition);
                    bool forwardIntegration = true;
                    bool backwardIntegration = true;
                    while ((currentPosition.X < gridData[gridData.Length - 1].X)
                        && (currentPosition.Y < gridData[0].Y))
                    {
                        #region forward integration
                        if (forwardIntegration)
                        {
                            Vector3 interpolatedVelocity = getInterpolatedVector(currentPosition.X, currentPosition.Y);
                            Vector2 velocity = new Vector2(interpolatedVelocity.X, -interpolatedVelocity.Y);
                            //Vector2 velocity = new Vector2(-interpolatedVelocity.Y,interpolatedVelocity.X);//hurricane
                            velocity.Normalize();
                            currentPosition = currentPosition + dt * velocity;
                            if (streamlineStop(streamLineIndex, currentPosition, currentLine))
                            {
                                forwardIntegration = false;
                            }
                        }
                        #endregion

                        #region backward integration
                        if (backwardIntegration)
                        {
                            Vector3 interpolatedVelocity = getInterpolatedVector(currentPosition_backward.X, currentPosition_backward.Y);
                            Vector2 velocity = new Vector2(interpolatedVelocity.X, -interpolatedVelocity.Y);
                            //Vector2 velocity = new Vector2(-interpolatedVelocity.Y,interpolatedVelocity.X);//hurricane
                            velocity.Normalize();
                            currentPosition_backward = currentPosition_backward - dt * velocity;
                            if (streamlineStop(streamLineIndex, currentPosition_backward, currentLine))
                            {
                                backwardIntegration = false;
                            }
                        }
                        #endregion
                        if ((forwardIntegration == false) && (backwardIntegration == false))
                        {
                            break;
                        }

                        if (forwardIntegration)
                        {
                            currentLine.Points.Add(currentPosition);
                            cGrid.AddPoint(new SamplePoint(currentPosition, streamLineIndex, currentLine.Points.Count - 1));
                        }

                        if (backwardIntegration)
                        {
                            currentLine.Points.Insert(0, currentPosition_backward);
                            cGrid.AddPoint(new SamplePoint(currentPosition_backward, streamLineIndex, currentLine.Points.Count - 1));
                        }
                    }

                    streamlines_euler.StreamlineList.Add(currentLine);
                    streamLineIndex++;
                    currentPosition = findNewSeedPoint(streamlines_euler);
                    currentPosition_backward = currentPosition;
                    //finished = true;//delete this! only for debug TODO
                    if (currentPosition == new Vector2(-1000.0f, -1000.0f))
                    {
                        finished = true;
                        break;
                    }
                }
                Console.WriteLine("streamlines calculated");
                //DrawStreamLines();

                #region calculate tickness coef for tapering
                foreach (Streamline nextStreamline in streamlines_euler.StreamlineList)
                {
                    foreach (Vector2 nextPoint in nextStreamline.Points)
                    {
                        nextStreamline.Tickness.Add(calculateTickness(nextPoint));
                    }
                }
                #endregion
                #endregion
            }
            else
            {
                #region runge-kutta integration 2nd order

                Vector2 stepsize = new Vector2(stepsizeX, stepsizeY);

                int streamLineIndex = 0;
                // start position of first streamline:
                Vector2 currentPosition = new Vector2(gridData[0].X + (float)(stepsizeX * 0.5),
                    gridData[gridData.Length - 1].Y + (stepsizeY * 0.5f));
                Vector2 currentPosition_backward = currentPosition;
                bool finished = false; // finished when no more seedpoints possible            
                while (!finished)
                {
                    Streamline currentLine = new Streamline(currentPosition);
                    bool forwardIntegration = true;
                    bool backwardIntegration = true;
                    while ((currentPosition.X < gridData[gridData.Length - 1].X)
                        && (currentPosition.Y < gridData[0].Y))
                    {
                        #region forward integration
                        if (forwardIntegration)
                        {
                            Vector3 interpolatedVelocity = getInterpolatedVector(currentPosition.X, currentPosition.Y);
                            Vector2 velocity = new Vector2(interpolatedVelocity.X, -interpolatedVelocity.Y);
                            //Vector2 velocity = new Vector2(-interpolatedVelocity.Y,interpolatedVelocity.X);//hurricane
                            velocity.Normalize();

                            // 1.: do half a Euler step
                            Vector2 halfEuler = currentPosition + dt*0.5f * velocity;

                            // 2.: evaluate flow vector there
                            interpolatedVelocity = getInterpolatedVector(halfEuler.X, halfEuler.Y);
                            velocity = new Vector2(interpolatedVelocity.X, -interpolatedVelocity.Y);
                            //Vector2 velocity = new Vector2(-interpolatedVelocity.Y,interpolatedVelocity.X);//hurricane
                            if (velocity.Length() <= 0)
                            {
                                forwardIntegration = false;
                                continue;
                            }
                            else
                            {
                                velocity.Normalize();
                            }                            

                            // 3.: use it in the origin
                            currentPosition = currentPosition + dt * velocity;

                            if (streamlineStop(streamLineIndex, currentPosition, currentLine))
                            {
                                forwardIntegration = false;
                            }
                        }
                        #endregion

                        #region backward integration
                        if (backwardIntegration)
                        {
                            Vector3 interpolatedVelocity = getInterpolatedVector(currentPosition_backward.X, currentPosition_backward.Y);
                            Vector2 velocity = new Vector2(interpolatedVelocity.X, -interpolatedVelocity.Y);
                            //Vector2 velocity = new Vector2(-interpolatedVelocity.Y,interpolatedVelocity.X);//hurricane
                            velocity.Normalize();

                            // 1.: do half a Euler step
                            Vector2 halfEuler = currentPosition_backward - dt * 0.5f * velocity;

                            // 2.: evaluate flow vector there
                            interpolatedVelocity = getInterpolatedVector(halfEuler.X, halfEuler.Y);
                            velocity = new Vector2(interpolatedVelocity.X, -interpolatedVelocity.Y);
                            //Vector2 velocity = new Vector2(-interpolatedVelocity.Y,interpolatedVelocity.X);//hurricane
                            if (velocity.Length() <= 0)
                            {
                                backwardIntegration = false;
                                continue;
                            }
                            velocity.Normalize();

                            // 3.: use it in the origin
                            currentPosition_backward = currentPosition_backward - dt * velocity;

                            if (streamlineStop(streamLineIndex, currentPosition_backward, currentLine))
                            {
                                backwardIntegration = false;
                            }
                        }
                        #endregion

                        if ((forwardIntegration == false) && (backwardIntegration == false))
                        {
                            break;
                        }

                        if (forwardIntegration)
                        {
                            currentLine.Points.Add(currentPosition);
                            cGrid.AddPoint(new SamplePoint(currentPosition, streamLineIndex, currentLine.Points.Count - 1));
                        }

                        if (backwardIntegration)
                        {
                            currentLine.Points.Insert(0, currentPosition_backward);
                            cGrid.AddPoint(new SamplePoint(currentPosition_backward, streamLineIndex, currentLine.Points.Count - 1));
                        }
                    }

                    streamlines_rungeKutta.StreamlineList.Add(currentLine);
                    streamLineIndex++;
                    currentPosition = findNewSeedPoint(streamlines_rungeKutta);
                    currentPosition_backward = currentPosition;
                    //finished = true;//delete this! only for debug TODO
                    if (currentPosition == new Vector2(-1000.0f, -1000.0f))
                    {
                        finished = true;
                        break;
                    }
                }
                Console.WriteLine("streamlines calculated");
                //DrawStreamLines();

                #region calculate tickness coef for tapering
                foreach (Streamline nextStreamline in streamlines_rungeKutta.StreamlineList)
                {
                    foreach (Vector2 nextPoint in nextStreamline.Points)
                    {
                        nextStreamline.Tickness.Add(calculateTickness(nextPoint));
                    }
                }
                #endregion

                #endregion
            }


        }

        private Vector3 getInterpolatedVector(float x, float y)
        {
            //indices
            int leftXIndex = 0;
            int rightXIndex = 0;
            int upYIndex = 0;
            int downYIndex = 0;

            //find y-neighbours
            for (int i = 0; i < sizeY * sizeX; i += sizeX)
            {
                if (y > gridData[i].Y)
                {
                    //Console.WriteLine("index y=" + i);
                    upYIndex = i - sizeX;
                    downYIndex = i;
                    break;
                }
            }
            //find x-neighbours
            for (int i = 0; i < sizeX; i++)
            {
                if (x < gridData[i].X)
                {
                    //Console.WriteLine("index x=" + i);
                    leftXIndex = i - 1;
                    rightXIndex = i;
                    break;
                }
            }
            
            #region depricated (find neighbour indices)
            /*if (isFlipped == true)
            {
                #region flipped version
                //find y-neighbours
                for (int i = 0; i < sizeY; i++)
                {
                    if (gridData[i].Y < y)
                    {
                        //Console.WriteLine("index y=" + i);
                        upYIndex = i - 1;
                        downYIndex = i;
                        break;
                    }
                }
                //find x-neighbours
                for (int i = 0; i < sizeX * sizeY; i += sizeY)
                {
                    if (gridData[i].X > x)
                    {
                        //Console.WriteLine("index x=" + i);
                        leftXIndex = i - sizeY;
                        rightXIndex = i;
                        break;
                    }
                }
                #endregion
            }
            else
            {
                #region non flipped version
                //find y-neighbours
                for (int i = 0; i < sizeY * sizeX; i+= sizeX)
                {
                    if (gridData[i].Y < y)
                    {
                        //Console.WriteLine("index y=" + i);
                        upYIndex = i - sizeX;
                        downYIndex = i;
                        break;
                    }
                }
                //find x-neighbours
                for (int i = 0; i < sizeX; i ++)
                {
                    if (gridData[i].X > x)
                    {
                        //Console.WriteLine("index x=" + i);
                        leftXIndex = i - 1;
                        rightXIndex = i;
                        break;
                    }
                }
            #endregion
            }*/
            #endregion
            
            #region get PositionVectors
            if ((upYIndex + leftXIndex > gridData.Length)
                || (upYIndex + rightXIndex > gridData.Length)
                || (downYIndex + leftXIndex > gridData.Length)
                || (downYIndex + rightXIndex > gridData.Length)
                || (upYIndex + leftXIndex < 0)
                || (upYIndex + rightXIndex < 0)
                || (downYIndex + leftXIndex < 0)
                || (downYIndex + rightXIndex < 0))
            {
                return new Vector3(0.0f);
            }

            Vector2 leftUp = gridData[upYIndex + leftXIndex];
            Vector2 rightUp = gridData[upYIndex + rightXIndex];
            Vector2 leftDown = gridData[downYIndex + leftXIndex];
            Vector2 rightDown = gridData[downYIndex + rightXIndex];
            #endregion

            #region calculate Distances
            float leftDist = Math.Abs(leftUp.X - x);
            float rightDist = Math.Abs(rightUp.X - x);
            float upDist = Math.Abs(leftUp.Y - y);
            float downDist = Math.Abs(leftDown.Y - y);
            float width = leftDist + rightDist;
            float height = upDist + downDist;
            #endregion

            #region get Velocity Vectors
            Vector3 leftUp_velocity = channelData[0].Velocity.VelocityValues[upYIndex + leftXIndex];
            Vector3 rightUp_velocity = channelData[0].Velocity.VelocityValues[upYIndex + rightXIndex];
            Vector3 leftDown_velocity = channelData[0].Velocity.VelocityValues[downYIndex + leftXIndex];
            Vector3 rightDown_velocity = channelData[0].Velocity.VelocityValues[downYIndex + rightXIndex];
            #endregion

            #region interpolate
            //don't interpolate positions, we want the interpolated Velocity!
            Vector3 interpolatedXUp = Vector3.Lerp(leftUp_velocity, rightUp_velocity, rightDist / width);
            Vector3 interpolatedXDown = Vector3.Lerp(leftDown_velocity, rightDown_velocity, rightDist / width);
            Vector3 interpolated = Vector3.Lerp(interpolatedXUp, interpolatedXDown, downDist / height);
            #endregion

            /*Console.WriteLine("lu=" + leftUp_velocity);
            Console.WriteLine("ru=" + rightUp_velocity);
            Console.WriteLine("ld=" + leftDown_velocity);
            Console.WriteLine("rd=" + rightDown_velocity);*/

            //Console.WriteLine(isFlipped);
            //Console.WriteLine("interpolated=" + interpolated);
            return interpolated;
        }

     

        #endregion
        #endregion

        #region Update
        public override void Update(GameTime gameTime)
        {
            updateArrowPlotControlPoints();
            #region update arrow plot
            if (GameProperties.Instance.enableArrowPlot &&
                (GameProperties.Instance.activeTab.Equals(ActiveTab.ArrowTab) || GameProperties.Instance.activeTab.Equals(ActiveTab.Default)))
            {
                //updateArrowPlotControlPoints();
                updateArrowPlot();
            }
            #endregion


            #region update channels
            if (GameProperties.Instance.enableChannels &&
                (GameProperties.Instance.activeTab.Equals(ActiveTab.ChannelsTab) || GameProperties.Instance.activeTab.Equals(ActiveTab.Default)))
            {
                setControlpoints();
            }
            #endregion


            #region update streamlines
            if (GameProperties.Instance.enableStreamlines &&
                (GameProperties.Instance.activeTab.Equals(ActiveTab.StreamlinesTab) || GameProperties.Instance.activeTab.Equals(ActiveTab.Default)))
            {
                updateStreameLines(); // not if integration-mode changes!
            }
            #endregion

            base.Update(gameTime);
        }
        #endregion

        #region Draw
        public override void Draw(GameTime gameTime)
        {

            DrawData(GameProperties.Instance.currentChannelIdx); // tell which channel to draw: 0, 1, or 2
            
            if (GameProperties.Instance.enableStreamlines)
            {
                Console.WriteLine("1 draw streamlines");
                DrawStreamLines(); }

            if (GameProperties.Instance.enableArrowPlot)
            { 
                device.RenderState.AlphaBlendEnable = true;
                device.RenderState.SourceBlend = Blend.BlendFactor;
                device.RenderState.DestinationBlend = Blend.SourceAlpha;
            
                DrawArrowTexture();

                device.RenderState.AlphaBlendEnable = false;
                device.RenderState.SourceBlend = Blend.One;
                device.RenderState.DestinationBlend = Blend.Zero;
            }

            // debug:
            //DrawGrid();

            base.Draw(gameTime);
        }

        #region Draw Arrow Texture
        private void DrawArrowTexture()
        {
            device.RenderState.FillMode = FillMode.Solid;

            GraphicsDevice.RenderState.DepthBufferEnable = false;
            GraphicsDevice.RenderState.DepthBufferWriteEnable = false;

            //device.RenderState.CullMode = CullMode.None;//delete this!

            GraphicsDevice.VertexDeclaration = new VertexDeclaration(GraphicsDevice, VertexPositionTexture.VertexElements);
            basicEffect2.World = world;
            basicEffect2.View = camera.View;
            basicEffect2.Projection = camera.Projection;
            basicEffect2.TextureEnabled = true;
            basicEffect2.Texture = arrowsTexture;
            basicEffect2.EnableDefaultLighting();

            GraphicsDevice.Indices = indexBuffer_arrow;
            GraphicsDevice.Vertices[0].SetSource(vertexBuffer_arrow, 0, VertexPositionTexture.SizeInBytes);

            int vertCount = 4;
            int trianglesCount = 2;


            #region Draw
            basicEffect2.Begin();
            foreach (EffectPass pass in basicEffect2.CurrentTechnique.Passes)
            {
                pass.Begin();

                GraphicsDevice.DrawUserIndexedPrimitives<VertexPositionTexture>(
                        PrimitiveType.TriangleList, verticeArray_arrows, 0, vertCount, arrowIndices, 0, 2);
                // Draw the mesh
                //GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, vertCount, 0, trianglesCount);

                pass.End();
            }
            basicEffect2.End();
            #endregion

            GraphicsDevice.RenderState.DepthBufferEnable = true;
            GraphicsDevice.RenderState.DepthBufferWriteEnable = true;
        }
        #endregion Draw Arrow Texture - end


        #region DrawData
        private void DrawData(int channelNr)
        {
            device.RenderState.FillMode = FillMode.Solid;

            GraphicsDevice.VertexDeclaration = vertexDeclr;
            shader.SetEffectParameter(world * camera.ViewProjection, world, channelNr);

            GraphicsDevice.Indices = indexBuffer;
            GraphicsDevice.Vertices[0].SetSource(vertexBuffer, 0, GridVertices.SizeInBytes);

            int vertCount = sizeX * sizeY;
            int trianglesCount = (sizeX - 1) * (sizeY - 1) * 2;

            shader.CurrentTechnique = shader.Techniques["Technique1"];

            #region Draw
            shader.Begin();
            foreach (EffectPass pass in shader.CurrentTechnique.Passes)
            {
                pass.Begin();

                // Draw the mesh
                GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, vertCount, 0, trianglesCount);

                pass.End();
            }
            shader.End();

            #endregion

            /*if (GameProperties.Instance.enableStreamlines)
            {
                updateStreameLines();
            }*/

        }
        #endregion

        #region Create Arrow Texture
        private void CreateArrowTexture()
        {
            stencilData = device.DepthStencilBuffer;

            device.SetRenderTarget(0, arrowTarget);
            // save Stencil Buffer for Scene
            //stencil_scene = device.DepthStencilBuffer;

            // assign Stencil Buffer for Arrows
            device.DepthStencilBuffer = stencilArrow;

            #region draw to texture
            spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Immediate, SaveStateMode.SaveState);
            
            for (int i = 0; i < arrowPlot.Position.Count; i++)
            {
                //transform positions to screen space
                Vector2 pos = arrowPlot.Position[i] - boundaryMin;
                pos *= 50.0f;

                spriteBatch.Draw(arrow, new Vector2(pos.X, pos.Y), null, arrowPlot.Color[i],
                   arrowPlot.Orientation[i], Vector2.Zero, arrowPlot.Scale[i],
                   SpriteEffects.None, 0);

            }

            spriteBatch.End();
            #endregion draw to texture - end

            device.SetRenderTarget(0, null);
            device.DepthStencilBuffer = stencilData;
            arrowsTexture = arrowTarget.GetTexture();

            //debug:
            //arrowsTexture.Save("arrowsTexture.bmp", ImageFileFormat.Bmp);

            #region depricated
            /*GraphicsDevice.RenderState.DepthBufferEnable = false;
            GraphicsDevice.RenderState.DepthBufferWriteEnable = false;
            spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Immediate, SaveStateMode.SaveState);
 
            float height = GameProperties.Instance.XNADrawSurfaceHeight;
            float width = GameProperties.Instance.XNADrawSurfaceWidth;
            float scaleValue = Math.Max(boundaryLength.X, boundaryLength.Y);
            float scaleValue_height = (height / scaleValue);
            float scaleValue_width = (width / scaleValue);
            Vector2 translateToCenter = new Vector2( (width/2.0f)-(boundaryLength.X/2.0f)*scaleValue_width, 
                (height/2.0f)-(boundaryLength.Y/2.0f)*scaleValue_height);

           for(int i = 0; i < arrowPlot.Position.Count; i++)
           {
               //transform positions to screen space
               Vector4 pos = new Vector4(arrowPlot.Position[i], 1.0f, 1.0f);
               //TODO: move to center (x,y)
               pos.X *= scaleValue_width;
               pos.Y *= scaleValue_height;
               pos.X += translateToCenter.X;// -arrow.Width * arrowPlot.Magnitude[i] / 2.0f;
               pos.Y += translateToCenter.Y;// -arrow.Height * arrowPlot.Magnitude[i] / 2.0f;
               //pos = Vector4.Transform(pos, worldViewProjection);
               /*spriteBatch.Draw(arrow, new Vector2(pos.X, pos.Y), null, arrowPlot.Color[i], 
                   arrowPlot.Orientation[i], Vector2.Zero, arrowPlot.Magnitude[i], 
                   SpriteEffects.None, 0);*/
            /* spriteBatch.Draw(arrow, new Vector2(pos.X, pos.Y), null, arrowPlot.Color[i],
                arrowPlot.Orientation[i], Vector2.Zero, arrowPlot.Scale[i],
                SpriteEffects.None, 0);

          }

          spriteBatch.End();
          GraphicsDevice.RenderState.DepthBufferEnable = true;
          GraphicsDevice.RenderState.DepthBufferWriteEnable = true;*/
            #endregion depricated - end
        }
        
        #endregion

        #region Draw Streamlines
        private void DrawStreamLines()
        {
            Console.WriteLine("Drawing streamlines");
            #region initialize draw
            device.RenderState.FillMode = FillMode.WireFrame;
            GraphicsDevice.VertexDeclaration = new VertexDeclaration(GraphicsDevice, VertexPositionColor.VertexElements);
            basicEffect.World = world;
            //basicEffect.World = Matrix.Identity;
            basicEffect.View = camera.View;
            basicEffect.Projection = camera.Projection;
            #endregion

            
            GraphicsDevice.RenderState.DepthBufferEnable = false;
            GraphicsDevice.RenderState.DepthBufferWriteEnable = false;

            //foreach(Streamline nextLine in streamlines.StreamlineList)


            List<Streamline> linesToDraw = new List<Streamline>();

            if (GameProperties.Instance.enableRungeKutta)

            {
                if (streamlines_rungeKutta.StreamlineList == null) 
                {
                    // if this is the first time drawing and the Streamline-List is still empty
                    updateStreameLines();
                }
                linesToDraw = streamlines_rungeKutta.StreamlineList;
            }
            else
            {
                if (streamlines_euler.StreamlineList == null)
                {
                    // if this is the first time drawing and the Streamline-List is still empty
                    updateStreameLines();
                }
                linesToDraw = streamlines_euler.StreamlineList;
            }

            
            #region draw with line width or normal

            if (GameProperties.Instance.lineWidth <= 0.1f) //draw normal
            {
                foreach (Streamline nextLine in linesToDraw)
                {

                    int vertCount = nextLine.Points.Count();

                    if (vertCount > 1)
                    {

                        #region initialize vertex and index buffer
                        VertexPositionColor[] streamlineVert = new VertexPositionColor[vertCount];

                        //linestrip
                        short[] streamlineIdx = new short[vertCount];
                        for (int i = 0; i < vertCount; i++)
                        {
                            streamlineVert[i] = new VertexPositionColor(new Vector3(nextLine.Points[i].X, nextLine.Points[i].Y, 0.0f), Color.White);
                            streamlineIdx[i] = (short)i;
                        }
                        #endregion


                        #region draw
                        basicEffect.Begin();

                        foreach (EffectPass pass in basicEffect.CurrentTechnique.Passes)
                        {
                            pass.Begin();

                            // Draw stripline
                            GraphicsDevice.DrawUserIndexedPrimitives<VertexPositionColor>(
                                PrimitiveType.LineStrip, streamlineVert, 0, vertCount, streamlineIdx, 0, (vertCount - 1));

                            pass.End();
                        }

                        basicEffect.End();
                        #endregion
                    }

                }//end foreach
            }
            else //apply line width
            {
                foreach (Streamline nextLine in linesToDraw)
                {
                    int vertCount = nextLine.Points.Count();

                    if (vertCount > 1)
                    {
                        device.RenderState.FillMode = FillMode.Solid;

                        #region initialize vertex and index buffer
                        VertexPositionColor[] streamlineVert = calculateTriangleStrip(nextLine.Points, nextLine.Tickness);

                        vertCount = streamlineVert.Length;

                        //triangle strip
                        short[] streamlineIdx = new short[vertCount];

                        for (int i = 0; i < vertCount; i++)
                        {
                            streamlineIdx[i] = (short)i;
                        }
                        #endregion


                        #region draw
                        basicEffect.Begin();

                        foreach (EffectPass pass in basicEffect.CurrentTechnique.Passes)
                        {
                            pass.Begin();

                            GraphicsDevice.DrawUserIndexedPrimitives<VertexPositionColor>(
                        PrimitiveType.TriangleStrip, streamlineVert, 0, vertCount, streamlineIdx, 0, (vertCount - 2));

                            pass.End();
                        }

                        basicEffect.End();
                        #endregion
                    }

                }//end foreach
 
            }

            #endregion

            

            GraphicsDevice.RenderState.DepthBufferEnable = true;
            GraphicsDevice.RenderState.DepthBufferWriteEnable = true;
        }

        /*private void DrawStreamLines1()
        {
            Console.WriteLine("Drawing streamlines");
            #region initialize draw
            device.RenderState.FillMode = FillMode.WireFrame;
            GraphicsDevice.VertexDeclaration = new VertexDeclaration(GraphicsDevice, VertexPositionColor.VertexElements);
            basicEffect.World = world;
            //basicEffect.World = Matrix.Identity;
            basicEffect.View = camera.View;
            basicEffect.Projection = camera.Projection;
            #endregion


            GraphicsDevice.RenderState.DepthBufferEnable = false;
            GraphicsDevice.RenderState.DepthBufferWriteEnable = false;

            //foreach(Streamline nextLine in streamlines.StreamlineList)


            List<Streamline> linesToDraw = new List<Streamline>();

            if (GameProperties.Instance.enableRungeKutta)
            {
                if (streamlines_rungeKutta.StreamlineList == null)
                {
                    // if this is the first time drawing and the Streamline-List is still empty
                    updateStreameLines();
                }
                linesToDraw = streamlines_rungeKutta.StreamlineList;
            }
            else
            {
                if (streamlines_euler.StreamlineList == null)
                {
                    // if this is the first time drawing and the Streamline-List is still empty
                    updateStreameLines();
                }
                linesToDraw = streamlines_euler.StreamlineList;
            }


            #region draw with line width or normal

            if (GameProperties.Instance.lineWidth <= 0.1f) //draw normal
            {
                foreach (Streamline nextLine in linesToDraw)
                {

                    int vertCount = nextLine.Points.Count();

                    if (vertCount > 1)
                    {

                        #region initialize vertex and index buffer
                        VertexPositionColor[] streamlineVert = new VertexPositionColor[vertCount];

                        //linestrip
                        short[] streamlineIdx = new short[vertCount];
                        for (int i = 0; i < vertCount; i++)
                        {
                            streamlineVert[i] = new VertexPositionColor(new Vector3(nextLine.Points[i].X, nextLine.Points[i].Y, 0.0f), Color.White);
                            streamlineIdx[i] = (short)i;
                        }
                        #endregion


                        #region draw
                        basicEffect.Begin();

                        foreach (EffectPass pass in basicEffect.CurrentTechnique.Passes)
                        {
                            pass.Begin();

                            // Draw stripline
                            GraphicsDevice.DrawUserIndexedPrimitives<VertexPositionColor>(
                                PrimitiveType.LineStrip, streamlineVert, 0, vertCount, streamlineIdx, 0, (vertCount - 1));

                            pass.End();
                        }

                        basicEffect.End();
                        #endregion
                    }

                }//end foreach
            }
            else //apply line width
            {
                foreach (Streamline nextLine in linesToDraw)
                {
                    int vertCount = nextLine.Points.Count();

                    if (vertCount > 1)
                    {
                        device.RenderState.FillMode = FillMode.Solid;

                        #region initialize vertex and index buffer
                        VertexPositionColor[] streamlineVert = calculateTriangleStrip(nextLine.Points, nextLine.Tickness);

                        vertCount = streamlineVert.Length;

                        //triangle strip
                        short[] streamlineIdx = new short[vertCount];

                        for (int i = 0; i < vertCount; i++)
                        {
                            streamlineIdx[i] = (short)i;
                        }
                        #endregion


                        #region draw
                        basicEffect.Begin();

                        foreach (EffectPass pass in basicEffect.CurrentTechnique.Passes)
                        {
                            pass.Begin();

                            GraphicsDevice.DrawUserIndexedPrimitives<VertexPositionColor>(
                        PrimitiveType.TriangleStrip, streamlineVert, 0, vertCount, streamlineIdx, 0, (vertCount - 2));

                            pass.End();
                        }

                        basicEffect.End();
                        #endregion
                    }

                }//end foreach

            }

            #endregion



            GraphicsDevice.RenderState.DepthBufferEnable = true;
            GraphicsDevice.RenderState.DepthBufferWriteEnable = true;
        }*/
        #endregion

        #region debug
        private void DrawStreamLinesTapering()
        {
            //test
            //calculateTriangleStrip(new Vector2(10, 20), new Vector2(10, 5));


            //calculateTriangleStrip(new Vector2(10, 5), new Vector2(10, 20));

            //calculateTriangleStrip(new Vector2(10, 20), new Vector2(20, 20));
            //calculateTriangleStrip(new Vector2(20, 20), new Vector2(10, 20));

            //calculateTriangleStrip(new Vector2(10, 5), new Vector2(30, 30));
            //calculateTriangleStrip(new Vector2(10, 5), new Vector2(0, 30));

            Console.WriteLine("Drawing streamlines");
            #region initialize draw
            device.RenderState.FillMode = FillMode.WireFrame;
            //device.RenderState.FillMode = FillMode.Solid;
            GraphicsDevice.VertexDeclaration = new VertexDeclaration(GraphicsDevice, VertexPositionColor.VertexElements);
            basicEffect.World = world;
            //basicEffect.World = Matrix.Identity;
            basicEffect.View = camera.View;
            basicEffect.Projection = camera.Projection;
            #endregion


            GraphicsDevice.RenderState.DepthBufferEnable = false;
            GraphicsDevice.RenderState.DepthBufferWriteEnable = false;

            #region initialize vertex and index buffer

            //test array
            Vector2[] points = new Vector2[4];

            points[0] = new Vector2(10, 20);
            points[1] = new Vector2(10, 5);
            points[2] = new Vector2(10, -5);
            points[3] = new Vector2(10, -9);

            VertexPositionColor[] streamlineVert = calculateTriangleStrip(points.ToList<Vector2>(), new List<float>());

            int vertCount = streamlineVert.Length;

            //triangle strip
            short[] streamlineIdx = new short[vertCount];
                
            for (int i = 0; i < vertCount; i++)
            {
                    //streamlineVert[i].Color = Color.White;
                    streamlineIdx[i] = (short)i;
            }
            #endregion

            #region draw
            basicEffect.Begin();

                foreach (EffectPass pass in basicEffect.CurrentTechnique.Passes)
                {
                    pass.Begin();

                    // Draw line
                    //GraphicsDevice.DrawUserIndexedPrimitives<VertexPositionColor>(
                    //  PrimitiveType.LineList, streamlineVert, 0, vertCount, streamlineIdx, 0, (vertCount - 1));

                    // Draw stripline
                    GraphicsDevice.DrawUserIndexedPrimitives<VertexPositionColor>(
                        PrimitiveType.TriangleStrip, streamlineVert, 0, vertCount, streamlineIdx, 0, (vertCount - 2));

                    pass.End();
                }

                basicEffect.End();
                #endregion

            
          

            GraphicsDevice.RenderState.DepthBufferEnable = true;
            GraphicsDevice.RenderState.DepthBufferWriteEnable = true;
        }
       

        private VertexPositionColor[] calculateTriangleStrip(Vector2 point1, Vector2 point2)
        {
            //float lineWidth = GameProperties.Instance.lineWidth;//to do relative to dtest
            float lineWidth = 6.0f;
            float distance = lineWidth * 0.5f;
            int countVert = 4;

            //calculate triangle strip
            VertexPositionColor[] vertices = new VertexPositionColor[4];
            //short[] indices = new short[countVert];

            //float angle = calculateAngle(point1, point2);
            Vector2 direction = point2 - point1;
            Vector2 normal = new Vector2(direction.Y, -direction.X);
            normal.Normalize();

            Vector2 point1_left = point1 + (normal * distance);
            Vector2 point1_right = point1 - (normal * distance);
            Vector2 point2_left = point2 + (normal * distance);
            Vector2 point2_right = point2 - (normal * distance);

            vertices[0].Position = new Vector3(point2_left.X, point2_left.Y, 0.0f);
            vertices[1].Position = new Vector3(point1_left.X, point1_left.Y, 0.0f);
            vertices[2].Position = new Vector3(point2_right.X, point2_right.Y, 0.0f);
            vertices[3].Position = new Vector3(point1_right.X, point1_right.Y, 0.0f);


            /*for (int i = 0; i < countVert; i++)
            {
                indices[i] = (short)i;
            }*/

            return vertices;
        }
        #endregion

        #region line width and tapering 
        private VertexPositionColor[] calculateTriangleStrip(List<Vector2> pointList, List<float> ticknessList)
        {
            float distance = GameProperties.Instance.lineWidth * 0.5f;
            if (GameProperties.Instance.enableTapering) distance = (GameProperties.Instance.lineWidth * 2) * 0.5f;
            
            float thick1 = 1.0f;
            float thick2 = 1.0f;

            //calculate triangle strip
            List<VertexPositionColor> vertices = new List<VertexPositionColor>();

            for (int i = 0; i < pointList.Count() - 1; i++)
            {
                Vector2 point1 = pointList[i];
                Vector2 point2 = pointList[i + 1];
                Vector2 direction = point2 - point1;
                Vector2 normal = new Vector2(direction.Y, -direction.X);
                normal.Normalize();

                if (GameProperties.Instance.enableTapering)
                {
                    thick1 = ticknessList[i];
                    thick2 = ticknessList[i + 1];
                }

                Vector2 point1_left = point1 + (normal * distance * thick1);
                Vector2 point1_right = point1 - (normal * distance * thick1);
                Vector2 point2_left = point2 + (normal * distance * thick2);
                Vector2 point2_right = point2 - (normal * distance * thick2);

                vertices.Add(new VertexPositionColor(new Vector3(point2_left.X, point2_left.Y, 0.0f), Color.White));
                vertices.Add(new VertexPositionColor(new Vector3(point1_left.X, point1_left.Y, 0.0f), Color.White));
                vertices.Add(new VertexPositionColor(new Vector3(point2_right.X, point2_right.Y, 0.0f), Color.White));
                vertices.Add(new VertexPositionColor(new Vector3(point1_right.X, point1_right.Y, 0.0f), Color.White));
 
            }
          
            return vertices.ToArray();
        }

        private float calculateAngle(Vector2 point1, Vector2 point2)
        {
            float x = point2.X - point1.X;
            float y = point2.Y - point1.Y;

            float angle = MathHelper.ToDegrees((float)Math.Atan2(y, x));
  
            return angle;
        }
        #endregion


        #region debug: draw grid
        private void DrawGrid()
        {
            device.RenderState.FillMode = FillMode.WireFrame;

            GraphicsDevice.VertexDeclaration = vertexDeclr;
            basicEffect.World = world;
            basicEffect.View = camera.View;
            basicEffect.Projection = camera.Projection;

            GraphicsDevice.Indices = indexBuffer;
            GraphicsDevice.Vertices[0].SetSource(vertexBuffer, 0, GridVertices.SizeInBytes);

            int vertCount = sizeX * sizeY;
            int trianglesCount = (sizeX - 1) * (sizeY - 1) * 2;

            basicEffect.Begin();

            foreach (EffectPass pass in basicEffect.CurrentTechnique.Passes)
            {
                pass.Begin();

                // Draw the mesh
                GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, vertCount, 0, trianglesCount);

                pass.End();
            }

            basicEffect.End();
        }
        #endregion

        #endregion

        #region transfer function




        private void setControlpoints()
        {
            colorControlPoints = GameProperties.Instance.channelControlPoints[GameProperties.Instance.currentChannelIdx];
       
            float amount = 0.0f;
            Color[] colorArray = new Color[256];

            #region interpolate between ControlPoints

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

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

            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));
                    Vector4 value = Vector4.Lerp(colorControlPoints[j].color,
                        colorControlPoints[j + 1].color, amount);
                    Color newColor = new Color();
                    newColor.R = (byte)value.X;
                    newColor.G = (byte)value.Y;
                    newColor.B = (byte)value.Z;
                    //newColor.A = (byte)(255.0f);
                    newColor.A = (byte)(value.W * 255.0f); 
                    colorArray[i] = newColor;

                }
            }

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

            //for gui
            if (initialControPoints)
            {
                for (int j = 0; j < GameProperties.Instance.channelControlPoints.Count(); j++)
                {
                    GameProperties.Instance.colorArray[j] = colorArray;
                }
                initialControPoints = false;
                GameProperties.Instance.updateChannelColor = true;
            }
            else 
            {
                GameProperties.Instance.colorArray[GameProperties.Instance.currentChannelIdx] = colorArray;
                GameProperties.Instance.updateChannelColor = true;
            }
            #endregion

            #region write to textures
            //write to a textures
            //transferTexture = new Texture2D(Game.GraphicsDevice, 256, 1, 1, TextureUsage.Linear, SurfaceFormat.Color);
            transferTexture = new Texture2D(Game.GraphicsDevice, colorArray.Length, 1, 1, TextureUsage.Linear, SurfaceFormat.Color);
           
            Byte4[] transferValues = new Byte4[256];
            //Vector4[] transferValues = new Vector4[colorArray.Length];
            for (int i = 0; i < 256; i++)
            {
                Vector4 color = new Vector4(colorArray[i].R, colorArray[i].G, colorArray[i].B, colorArray[i].A);
                //color *= 255.0f;
                //store bgra, but why?
                //transferValues[i] = new Vector4(color.Z, color.Y, color.X, color.W);
                transferValues[i] = new Byte4(color.Z, color.Y, color.X, color.W);
            }
            //transferTexture.SetData<Vector4>(transferValues);
            transferTexture.SetData<Byte4>(transferValues);
            //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!

        }

        private void updateArrowPlotControlPoints()
        {

            List<TransferControlPoint> colorControlPoints = GameProperties.Instance.arrowControlPoints;

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

            #region interpolate between ControlPoints

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

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

            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));
                    Vector4 value = Vector4.Lerp(colorControlPoints[j].color,
                        colorControlPoints[j + 1].color, amount);
                    Color newColor = new Color();
                    newColor.R = (byte)value.X;
                    newColor.G = (byte)value.Y;
                    newColor.B = (byte)value.Z;
                    //newColor.A = (byte)(255.0f);
                    newColor.A = (byte)(value.W * 255.0f);
                    colorArray[i] = newColor;

                }
            }

            // after last ControlPoint: fill with black
            for (int i = colorControlPoints[colorControlPoints.Count - 1].isoValue + 1; i < 256; i++)
            {
                colorArray[i] = Color.Black;
            }
            GameProperties.Instance.arrowColorArray = colorArray;
            GameProperties.Instance.updateArrowColor = true;
            #endregion
        }
        #endregion

        #region Other Methods




        private void createUniformGrid()
        {
            normalizedGridData = new Vector2[sizeX * sizeY];
            //scale values
            for (int i = 0; i < sizeX * sizeY; i++)
            {
                normalizedGridData[i] = Vector2.Divide((gridData[i] - boundaryMin), boundaryLength);
            }
        }

        private GridVertices[] GenerateTextureCoord(GridVertices[] meshVert)
        {
            float tu = 0;
            float tv = 0;
            float tuDerivative = 1.0f / (sizeX - 1);
            float tvDerivative = 1.0f / (sizeY - 1);

            int nextVert = 0;
            for (float row = 0; row <= sizeY; row++)
            {
                tu = 0.0f;
                for (float col = 0; col <= sizeX; col++)
                {
                    //meshVert[nextVert].TextureCoordinate = new Vector2(tu, tv); //todo add def to the custom vertex format
                    tu += tuDerivative;
                    nextVert++;
                }
                tv += tvDerivative;
            }

            return meshVert;
        }

       /* private GridVertices[] generateNormals(int[] meshIndices, GridVertices[] meshVert)
        {
            for (int i = 0; i < meshIndices.Length; i += 3)
            {
                //get vertices for each triangle 
                Vector2 vert1 = meshVert[meshIndices[i]].Position;
                Vector2 vert2 = meshVert[meshIndices[i + 1]].Position;
                Vector2 vert3 = meshVert[meshIndices[i + 2]].Position;
                //calculate a normal vector for that triangle
                Vector2 norm = Vector3.Cross(vert3 - vert1, vert2 - vert1);
                norm.Normalize();
                //calculate mean //todo: if we use it add definition in the custom vertex def, and make vertices 3d
                meshVert[meshIndices[i]].Normal += norm;
                meshVert[meshIndices[i + 1]].Normal += norm;
                meshVert[meshIndices[i + 2]].Normal += norm;
            }

            for (int i = 0; i < meshVert.Length; i++)
            {
                meshVert[i].Normal.Normalize();
            }

            return meshVert;
        }*/


        #endregion

        #region Helper Functions
        private void loadDatafromFileExtend()
        {
            #region read .gri

            Stream file = new FileStream(griFileName, FileMode.Open);
            BinaryReader reader = new BinaryReader(file);

            #region read header
            byte[] headerBuffer = new byte[40];
            reader.Read(headerBuffer, 0, 40);

            string header = System.Text.ASCIIEncoding.ASCII.GetString(headerBuffer);
            //string[] header_str = System.Text.ASCIIEncoding.ASCII.GetString(headerBuffer).Split(' ');
            //char[] headerChars = System.Text.ASCIIEncoding.ASCII.GetChars(headerBuffer);

            Regex stringSeq = new Regex("[a-zA-Z0-9]+");
            Regex positiveInt = new Regex("0*[1-9][0-9]*");
            Regex positiveFloat = new Regex("[0-9]+[.][0-9]*");
            Regex emptySpace = new Regex(" ");

            int pos = 0;

            try
            {
                Match match_strName = stringSeq.Match(header, pos);
                if (match_strName.Success)
                {
                    headerName = match_strName.ToString();
                    pos += match_strName.Length;
                }

                if (emptySpace.Match(header, pos).Success) { pos++; }


                Match match_strX = positiveInt.Match(header, pos);
                if (match_strX.Success)
                {
                    sizeX = int.Parse(match_strX.ToString());
                    pos += match_strX.Length;
                }

                if (emptySpace.Match(header, pos).Success) { pos++; }

                Match match_strY = positiveInt.Match(header, pos);
                if (match_strY.Success)
                {
                    sizeY = int.Parse(match_strY.ToString());
                    pos += match_strY.Length;
                }

                if (emptySpace.Match(header, pos).Success) { pos++; }

                Match match_strZ = positiveInt.Match(header, pos);
                if (match_strZ.Success)
                {
                    sizeZ = int.Parse(match_strZ.ToString());
                    pos += match_strZ.Length;
                }

                if (emptySpace.Match(header, pos).Success) { pos++; }

                Match match_strNumber1 = positiveInt.Match(header, pos);
                if (match_strNumber1.Success)
                {
                    channelNumber = int.Parse(match_strNumber1.ToString());
                    pos += match_strNumber1.Length;
                }

                if (emptySpace.Match(header, pos).Success) { pos++; }

                Match match_strNumber2 = positiveInt.Match(header, pos);
                if (match_strNumber2.Success)
                {
                    timestepNumber = int.Parse(match_strNumber2.ToString());
                    pos += match_strNumber2.Length;
                }

                if (emptySpace.Match(header, pos).Success) { pos++; }

                Match match_strDur = positiveFloat.Match(header, pos);
                if (match_strDur.Success)
                {
                    timestepDuration = float.Parse(match_strDur.ToString());
                    pos += match_strDur.Length;
                }

            }
            catch (Exception e)
            {
                Console.WriteLine("Some header information is missing");
            }

            #endregion

            #region read geometry data

            int sizeXOld = sizeX;
            int sizeYOld = sizeY;
            int sizeZOld = sizeZ;

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

            gridData = new Vector2[sizeX * sizeY];
            int nextPos = 0;
            try
            {

                for (int y = 0; y < sizeY; y++)
                {
                    for (int x = 0; x < sizeX; x++)
                    {
                        if (x >= sizeXOld || y >= sizeYOld)
                        {
                            gridData[nextPos].X = 0.0f;
                            gridData[nextPos].Y = 0.0f;

                        }
                        else
                        {

                            float xVal = BitConverter.ToSingle(reader.ReadBytes(4), 0);
                            float yVal = BitConverter.ToSingle(reader.ReadBytes(4), 0);
                            float Z_unused = BitConverter.ToSingle(reader.ReadBytes(4), 0);

                            gridData[nextPos].X = xVal;
                            gridData[nextPos].Y = yVal;

                            nextPos++;
                        }

                    }
                }

            }
            catch (EndOfStreamException e)
            {
                Console.WriteLine(e.Message);
            }
            finally
            {
                reader.Close();
                file.Close();
            }

            #endregion

            reader.Close();
            file.Close();

            #endregion

            #region read .dat
            channelData = new FlowChannel[datFileNames.Count];

            for (int i = 0; i < channelNumber; i++)
            {
                channelData[i] = new FlowChannel(sizeX, sizeY, channelNumber, i);
            }

            for (int i = 0; i < datFileNames.Count; i++)
            {
                Stream datFile = new FileStream(datFileNames[i], FileMode.Open);
                BinaryReader datReader = new BinaryReader(datFile);

                int nextPos1 = 0;
                for (int y = 0; y < sizeYOld; y++)
                {
                    for (int x = 0; x < sizeXOld; x++)
                    {

                        Vector3 gridPos = new Vector3();
                        gridPos.X = BitConverter.ToSingle(datReader.ReadBytes(4), 0);
                        gridPos.Y = BitConverter.ToSingle(datReader.ReadBytes(4), 0);
                        gridPos.Z = BitConverter.ToSingle(datReader.ReadBytes(4), 0);

                        channelData[i].Velocity.VelocityValues[nextPos1] = gridPos;

                        for (int j = 0; j < channelNumber; j++)
                        {
                            channelData[i].AddChannels[j].ChannelValues[nextPos1] = BitConverter.ToSingle(datReader.ReadBytes(4), 0);
                        }
                    }
                }
                datReader.Close();
                datFile.Close();
            }

            #endregion

            #region initialize dimensions
            int firstIdx = 0;
            int lastIdx = (sizeXOld * sizeYOld) - 1;
            boundaryMin = gridData[firstIdx];
            boundaryMax = gridData[lastIdx];
            boundaryLength = boundaryMax - boundaryMin;

            //if this work!?
            //if X and Y are swapped... meaning that going in a row the y value increases and x stays the same
            if (gridData[sizeX - 1].Y > (boundaryMin.Y + boundaryMax.Y) * 0.5)
            {
                //this flag will fix that, anywhere where it's neccerasy... watch it :)
                isFlipped = true;
                Console.WriteLine("Flipped Y and X dimensions.");
            }
            else isFlipped = false;

            #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;
            }
        }
        #endregion

        #region depricated
        /*private void createUniformGrid()
        {
            GraphicsDevice device = Game.GraphicsDevice;
            PresentationParameters param = Game.GraphicsDevice.PresentationParameters;
            SurfaceFormat format = param.BackBufferFormat;
            int width = device.PresentationParameters.BackBufferWidth;
            int height = device.PresentationParameters.BackBufferHeight;*/

        //VertexDeclaration vert = new VertexDeclaration(device, channel1Vertices); 
        /*renderTarget = new RenderTarget2D(device, width, height, 1, format,
            device.DepthStencilBuffer.MultiSampleType,
            device.PresentationParameters.MultiSampleQuality);*/

        /*Vector2 boundaryMin = gridData[0, 0];
        Vector2 boundaryMax = gridData[sizeX-1, sizeY-1];

        Vector2 boundaryLength = boundaryMax - boundaryMin;
        Vector2 scale = new Vector2(1.0f,1.0f)/boundaryLength;

        scaleValues(scale);
        generateMesh();

        grid = new Texture2D(device, width, height);
        grid.SetData<VertexPositionColor>(channel1Vertices);

    }*/

        #endregion
    }
}