Transferfunction.cs

#region Using Statement
using System;
using System.Drawing;
using System.Windows.Forms;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
#endregion

//use XNA defionitions for color and rectangle, System.Drawing for point
using Color = Microsoft.Xna.Framework.Color;
using Rectangle = Microsoft.Xna.Framework.Rectangle;
using Point = System.Drawing.Point;

namespace visLU.Gui
{
    class Transferfunction : VisXnaConrol
    {
        #region Variables

        BasicEffect effect;
        SortedDictionary<int, TransferControlPoint> controlPointValues; // key -> iso value = 0 - 255, color -> 0.0f to 1.0f, alpha -> 0.0f to 1.0f
        SortedDictionary<float, float> densityIsoValues;
        bool enableTransferFunction;

        VertexPositionColor[] densityPoints; //array to draw the density function for the current dataset(draw -> x == isovalue, y == density)
        VertexPositionColor[] controlPoints; //array to connect the control points(->draw)
        
        int scaleX = 255;
        int scaleY= 255;
        int minWidth = 256;
        int minHeight = 150;
        bool drawDensityFunction; //im gui einbinden TODO
        int cpTexWidth = 9; 
        int cpTexHeight = 9;
        

        SpriteBatch spriteBatch;
        ContentManager content;
        Texture2D transparentPattern;
        Texture2D tfBackground;
        Texture2D controlPointTex;
        Color[] tfBackgroundColor;

        //state variables
        bool updateIsoValues; //set true if new dataset has been loaded
        bool getControlPoints; //set true to load initial control points(new dataset was loaded) or xml def
        bool setControlPoints; //set true when new cp was added in the tf control panel

        bool sizeChanged;
        Size defaultSize = new Size(256,256);
        Size lastSize;

        #endregion

        #region Properties
        public bool EnableTransferFunction
        {
            set { enableTransferFunction = value; }
        }
        public bool DensityFunction
        {
            set { drawDensityFunction = value; }
        }

        public bool UpdateIsoValues
        {
            set { updateIsoValues = value; }
        }

        public bool GetControlPoints
        {
            set { getControlPoints = value; }
        }

        public bool SetControlPoints
        {
            set { setControlPoints = value; }
            get { return setControlPoints; }
        }
        #endregion

        protected override void Initialize()
        {

            //this.MinimumSize = new System.Drawing.Size(minWidth, minHeight);
            lastSize = this.Size;
          
            spriteBatch = Services.GetService(typeof(SpriteBatch)) as SpriteBatch;
            content = Services.GetService(typeof(ContentManager)) as ContentManager;

            updateIsoValues = false; //set true if new dataset has been loaded
            getControlPoints = false; //set true to load initial control points(new dataset was loaded) or xml def
            setControlPoints = false; //set true when new cp was added in the tf control panel
            sizeChanged = false;

            controlPointValues = new SortedDictionary<int, TransferControlPoint>();
            getControlPointsData();
            setCpData();
            tfBackgroundColor = new Color[256*256];
            
            densityIsoValues = new SortedDictionary<float, float>();

            enableTransferFunction = GameProperties.Instance.enableTransferFunction;
            drawDensityFunction = (GameProperties.Instance.showDensityValue && GameProperties.Instance.engineState.loadData);
        }

        protected override void LoadContent()
        {
           
            if (spriteBatch == null)
            {
                //throw new InvalidOperationException("SpriteBatch Service not found");
                spriteBatch = new SpriteBatch(GraphicsDevice);
                Services.AddService<SpriteBatch>(spriteBatch);
            }

            if (content == null)
            {
                //throw new InvalidOperationException("Content Manager Service not found.");
                content = new ContentManager(Services, "Content");
                Services.AddService<ContentManager>(content);
            }

            transparentPattern = content.Load<Texture2D>("Texture\\transparent_pattern");
            tfBackground = new Texture2D(GraphicsDevice, 256, 256, false, SurfaceFormat.Color); 
            interpolateColor();
            tfBackground.SetData(tfBackgroundColor);

            controlPointTex = content.Load<Texture2D>("Texture\\circle");
            
            //create effect
            effect = new BasicEffect(GraphicsDevice);
            effect.VertexColorEnabled = true;
        }

        protected override void Update()
        {
            Console.WriteLine("Transferfunction Update Call");

            if (!enableTransferFunction) return;

            #region update iso values
            //if new dataset has been loaded -> update the density function 
            if (updateIsoValues)
            {        
                updateIsoValuesData();
                setDensityPoints();
                updateIsoValues = false;
            }
            
            #endregion

            #region update control points
            //update if
            //1. new dataset has been loaded -> initial points
            //2. xml definition has been loaded -> read new control points from the game properties
            if (getControlPoints)
            {
                getControlPointsData();
                setCpData();
                interpolateColor();
                tfBackground.SetData(tfBackgroundColor); //do i need to do this???
                getControlPoints = false;
            }

            //3. new cp has been added
            if (setControlPoints)
            {
                setCpData();
                interpolateColor();
                tfBackground.SetData(tfBackgroundColor); //do i need to do this???
                setControlPoints = false;  
            }
            #endregion

            #region control size changed
            //scale if size has been changed
            //scale after all updates are done
            if (sizeChanged)
            {
                if (!getControlPoints && !setControlPoints)
                {
                    setCpData();
                }
                if (drawDensityFunction)
                    setDensityPoints();

                sizeChanged = false;
            }
            #endregion
            
        }

        protected override void Draw()
        {
            Console.WriteLine("Transferfunction Draw Call");

            if (!enableTransferFunction)
            {
                GraphicsDevice.Clear(Color.CornflowerBlue);
                #region draw transparent pattern texture as background
                spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.NonPremultiplied);
                spriteBatch.Draw(transparentPattern, new Rectangle(0, 0, Width, Height), Color.White);
                spriteBatch.End();
                #endregion
                return;
            }

            GraphicsDevice.Clear(Color.CornflowerBlue);
            effect.World = Matrix.Identity;
            effect.View = Matrix.CreateLookAt(new Vector3(0.0f, 0.0f, 1.0f), Vector3.Zero, Vector3.Up);
            effect.Projection = Matrix.CreateOrthographicOffCenter(0, (float)GraphicsDevice.Viewport.Width, (float)GraphicsDevice.Viewport.Height, 0, 1.0f, 1000.0f);
        

            #region draw background 
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.NonPremultiplied);
            spriteBatch.Draw(transparentPattern, new Rectangle(0, 0, Width, Height), Color.White);
            spriteBatch.Draw(tfBackground, new Rectangle(0, 0, Width, Height), Color.White);
            spriteBatch.End();
            #endregion


            #region draw density function
            if (drawDensityFunction)
            {
                GraphicsDevice.RasterizerState = RasterizerState.CullNone;
                effect.CurrentTechnique.Passes[0].Apply();
                GraphicsDevice.DrawUserPrimitives(PrimitiveType.LineStrip,
                                                  densityPoints, 0, (densityPoints.Count()-1));
            }
            #endregion
            
            //draw control points
            #region draw control points

            //connect the control points
            GraphicsDevice.RasterizerState = RasterizerState.CullNone;
            effect.CurrentTechnique.Passes[0].Apply();
            GraphicsDevice.DrawUserPrimitives(PrimitiveType.LineStrip,
                                              controlPoints, 0, (controlPoints.Count() - 1));

            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.NonPremultiplied);
            foreach (KeyValuePair<int,TransferControlPoint> p in controlPointValues)
            {

                float scaleX_ = ((float)(this.Width - 1) / (float)scaleX);
                float scaleY_ = ((float)(this.Height - 1) / (float)scaleY);
                //int x = (int)((p.Value.isoValue - (int)(cpTexWidth * 0.5f))*scaleX_);
                //int y = (int)((150 - (int)(cpTexHeight * 0.5f))*scaleY_);
                int x = (int)(p.Value.isoValue * scaleX_ - (int)(cpTexWidth * 0.5f)); 
                int y = (int)((this.Height - 1 - p.Value.color.W * 255.0f * scaleY_) - (int)(cpTexHeight * 0.5f));
                Color color = new Color(p.Value.color);
                //draw with control point color and conect the control points
                spriteBatch.Draw(controlPointTex, new Rectangle(x, y, cpTexHeight, cpTexWidth), color);
            }
            spriteBatch.End();
            #endregion
        }

        #region Help Functions 

        private void getControlPointsData()
        {

            //load control points from a xml file defintion
            if (GameProperties.Instance.colorControlPoints != null && GameProperties.Instance.colorControlPoints.Count() > 0)
            {
                controlPointValues.Clear();
                for (int i = 0; i < GameProperties.Instance.colorControlPoints.Count(); i++)
                {
                    int cpValue = GameProperties.Instance.colorControlPoints[i].isoValue;
                    TransferControlPoint cpNext = GameProperties.Instance.colorControlPoints[i];
                    cpNext.color.W = GameProperties.Instance.alphaControlPoints[i].color.W;
                    controlPointValues.Add(cpValue, cpNext);
                }

            }
            else //get default control points from the game properties instance, when new dataset was loaded
            {
                if (controlPointValues.Count > 0) controlPointValues.Clear();
                //initial control points-> need this for the texture if no control points are set!

                #region old version -> delete after test
                /*controlPointValues.Add(0, new TransferControlPoint(0.0f, 0.0f, 0.0f, 0));//bottom left
                controlPointValues.Add(255, new TransferControlPoint(0.0f, 0.0f, 0.0f, 255));//bottom right

                #region test
                controlPointValues.Add(50, new TransferControlPoint(1.0f, 0.0f, 0.0f, 50));
                controlPointValues.Add(150, new TransferControlPoint(0.0f, 1.0f, 0.0f, 150));
                controlPointValues.Add(250, new TransferControlPoint(0.0f, 0.0f, 1.0f, 250));
                #endregion

                //set points in the game properties -> better way to do this or some gut default points
                foreach (KeyValuePair<int, TransferControlPoint> cp in controlPointValues)
                {
                    
                    GameProperties.Instance.colorControlPoints.Add(new TransferControlPoint(cp.Value.color.X, cp.Value.color.Y, cp.Value.color.Z, cp.Value.isoValue));
                    GameProperties.Instance.alphaControlPoints.Add(new TransferControlPoint(cp.Value.color.W, cp.Value.isoValue));
                }*/
                #endregion

            }
        }

     

        void setCpData()
        {
            if (controlPointValues == null || controlPointValues.Count == 0) return;

            controlPoints = new VertexPositionColor[controlPointValues.Count];
            float scaleX_ = ((float)(this.Width - 1) / (float)scaleX);
            float scaleY_ = ((float)(this.Height - 1) / (float)scaleY);
            int i = 0;
            foreach (KeyValuePair<int, TransferControlPoint> cp in controlPointValues)
            {
                //(int) alpha * 255 ?
                Color color = new Color(cp.Value.color);
                color.A = 255;
                controlPoints[i] = new VertexPositionColor(
                                   new Vector3((cp.Value.isoValue * scaleX_), (this.Height - 1) - ((cp.Value.color.W * 255.0f) * scaleY_), 0),
                                   color);
                i++;
            }
            //OLD STUFF -> DELETE
            /*for (int i = 0; i < controlPointValues.Count; i++)
            {
                    controlPoints[i] = new VertexPositionColor(
                    new Vector3((controlPointValues[i].isoValue * scaleX_), ((this.Height - 1 - controlPointValues[i].color.W)* scaleY_), 0), 
                    new Color(controlPointValues[i].color));
            }*/
        }

        void interpolateColor()
        {
          
            #region current version

            List<TransferControlPoint> cpList;

            if (GameProperties.Instance.colorControlPoints != null && GameProperties.Instance.colorControlPoints.Count > 0)
            {
                cpList = new List<TransferControlPoint>(GameProperties.Instance.colorControlPoints);
                //cpList = GameProperties.Instance.colorControlPoints;
            }
            else 
            {
                cpList = new List<TransferControlPoint>();
                foreach(KeyValuePair<int, TransferControlPoint> cp in controlPointValues)
                {
                    
                    cpList.Add(cp.Value);
                }
               
            }
            
            cpList.Sort(delegate(TransferControlPoint p1,
               TransferControlPoint p2) { return p1.isoValue.CompareTo(p2.isoValue); });

            float amount = 0.0f;
            

            for (int k = 0; k < 256; k++)
            {
                byte alpha = (byte)(255 - k); //alpha for each row

                for (int i = 0; i < cpList[0].isoValue; i++)
                {
                    tfBackgroundColor[i + 256 * k] = Color.Black;
                    tfBackgroundColor[i + 256 * k].A = alpha;

                }

                for (int j = 0; j < cpList.Count - 1; j++)
                {
                    for (int i = cpList[j].isoValue; i <= cpList[j + 1].isoValue; i++)
                    {
                        amount = (((float)i - cpList[j].isoValue) /
                            (cpList[j + 1].isoValue - cpList[j].isoValue));
                        tfBackgroundColor[i + 256 * k] = Color.Lerp(new Color(cpList[j].color),
                        new Color(cpList[j + 1].color), amount);
                        tfBackgroundColor[i + 256 * k].A = alpha;
                    }
                }

                // after last ControlPoint: fill with black and alpha
                for (int i = cpList[cpList.Count - 1].isoValue + 1; i < 256; i++)
                {
                    tfBackgroundColor[i + 256 * k] = Color.Black;
                    tfBackgroundColor[i + 256 * k].A = alpha;
                }

            }//end for k
            #endregion

            #region old version 2

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

            // 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));
                    colorArray[i] = Color.Lerp(new Color(colorControlPoints[j].color),
                    new Color(colorControlPoints[j + 1].color), amount);
                }
            }

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

            //init texture to draw background
            for (int i = 0; i < 256; i++)
            {
                for (int j = 0; j < colorArray.Count(); j++)
                {
                    byte alpha = (byte)(255-i);
                    tfBackgroundColor[j + 256 * i] = colorArray[j];
                    tfBackgroundColor[j + 256 * i].A = alpha;
              
                }

            }*/

            #endregion

        }

        

        private void updateIsoValuesData()
        {
            if (GameProperties.Instance.distinctDensityValues != null && GameProperties.Instance.distinctDensityValues.Length > 0)
            {
                densityIsoValues.Clear(); ; //key->iso value, value -> log densitiy 
                //float maxDensity = (float)Math.Log10(GameProperties.Instance.countDensityValues.Max() - GameProperties.Instance.countDensityValues.Min()); //TODO debug density scale
                float maxDensity = (float)Math.Log10(GameProperties.Instance.countDensityValues.Max() - GameProperties.Instance.countDensityValues.Min());
                for (int i = 0; i < GameProperties.Instance.distinctDensityValues.Length; i++)
                {
                    densityIsoValues.Add(GameProperties.Instance.distinctDensityValues[i], (float)Math.Log10(GameProperties.Instance.countDensityValues[i])/maxDensity);
                }
            }

        }

        void setDensityPoints()
        {
            if (densityIsoValues == null || densityIsoValues.Count == 0) return;
            densityPoints = new VertexPositionColor[densityIsoValues.Count];
            int i = 0;
            float scaleX_ = ((float)(this.Width - 1) / (float)scaleX);
            float scaleY_ = ((float)(this.Height - 1) / (float)scaleY);

            foreach (KeyValuePair<float, float> isoValue in densityIsoValues)
            {
                densityPoints[i] = new VertexPositionColor(new Vector3(isoValue.Key * scaleX_, ((this.Height - 1) - (isoValue.Value*255.0f)*scaleY_), 0), Color.Black);
                i++;
            }
        }

        #endregion

        #region Control Points Helper Functions
        public void setControlPoint(Point position, System.Drawing.Color color)
        {
         
            float r = (float)(color.R / 255.0f);
            float g = (float)(color.G / 255.0f);
            float b = (float)(color.B / 255.0f);
            float a = (float)((255 - position.Y) / 255.0f); //check if color correct 

            int key = getControlPointKey(position);

            if (key == -1) //add new control point
            {
                float scaleX_ = ((float)(this.Width - 1) / (float)scaleX);
                int posX = (int)(position.X / scaleX_);
                GameProperties.Instance.colorControlPoints.Add(new TransferControlPoint(r, g, b, posX));
                GameProperties.Instance.alphaControlPoints.Add(new TransferControlPoint(a, posX));
                TransferControlPoint cpNew = new TransferControlPoint(r, g, b, posX);
                cpNew.color.W = a;
                controlPointValues.Add(position.X, cpNew);

            }
            else //edit color for the current one 
            {
                controlPointValues[key].color.X = r;
                controlPointValues[key].color.Y = g;
                controlPointValues[key].color.Z = b;
                controlPointValues[key].color.W = a;

                for (int i = 0; i < GameProperties.Instance.colorControlPoints.Count(); i++)
                {
                    if (GameProperties.Instance.colorControlPoints[i].isoValue == key
                        && GameProperties.Instance.alphaControlPoints[i].isoValue == key)
                    {
                        GameProperties.Instance.colorControlPoints[i].color.X = r;
                        GameProperties.Instance.colorControlPoints[i].color.Y = g;
                        GameProperties.Instance.colorControlPoints[i].color.Z = b;
                        GameProperties.Instance.alphaControlPoints[i].color.W = a;
                        i = GameProperties.Instance.colorControlPoints.Count();
                    }
                }

                
            }
            //debug
            //Console.WriteLine("color piker value:" + "{" + r + ", " + g + ", " + b + "; " + a );

        }

        public bool changeControlPoint(Point oldPosition, Point newPosition)
        {
            int key = getControlPointKey(oldPosition); //old mouse position
            if (key != -1)
            {
                oldPosition.X = key;

                //normalize position
                float scaleX_ = ((float)(this.Width - 1) / (float)scaleX);
                float scaleY_ = ((float)(this.Height - 1) / (float)scaleY);

                //int oldIsoValue = (int)(oldPosition.X / scaleX_);
                int newIsoValue = (int)((newPosition.X) / scaleX_);
                float newAlphaValue = (float)((this.Height - 1 - newPosition.Y) / scaleY_);
                newAlphaValue /= 255.0f; 
                //Console.WriteLine("new alpha = " + newAlpaValue);

                if (newIsoValue == oldPosition.X)//only alpha changed
                {
                    controlPointValues[newIsoValue].color.W = newAlphaValue;
                }
                else
                {
                    TransferControlPoint cp = controlPointValues[oldPosition.X];
                    cp.isoValue = newIsoValue;
                    cp.color.W = newAlphaValue;
                    controlPointValues.Remove(oldPosition.X);
                    if (controlPointValues.ContainsKey(newIsoValue)) //cp for this iso value already exists so override it
                        controlPointValues[newIsoValue] = cp;
                    else controlPointValues.Add(newIsoValue, cp);

                }

                changeControlPoints();
                return true;
                
            }
            return false;
        }

        public bool removeControlPoint(Point cpPosition)
        {
            int key = getControlPointKey(cpPosition); //old mouse position
            if (key != -1)
            {
                if (controlPointValues.Remove(key))
                {
                    for (int i = 0; i < GameProperties.Instance.colorControlPoints.Count(); i++)
                    {
                        if (GameProperties.Instance.colorControlPoints[i].isoValue == key
                            && GameProperties.Instance.alphaControlPoints[i].isoValue == key)
                        {
                            GameProperties.Instance.colorControlPoints.RemoveAt(i);
                            GameProperties.Instance.alphaControlPoints.RemoveAt(i);
                            break;
                        }
                    }
                    return true;
                }
                
            }

            return false;
        }
        
        void changeControlPoints()
        {
            GameProperties.Instance.colorControlPoints.Clear();
            GameProperties.Instance.alphaControlPoints.Clear();
          
            foreach (KeyValuePair<int, TransferControlPoint> cp in this.controlPointValues)
            {
                GameProperties.Instance.colorControlPoints.Add(new TransferControlPoint(cp.Value.color.X, cp.Value.color.Y, cp.Value.color.Z, cp.Value.isoValue));
                GameProperties.Instance.alphaControlPoints.Add(new TransferControlPoint(cp.Value.color.W, cp.Value.isoValue));
               
            }
 
        }
        int getControlPointKey(Point mousePos)
        {
            //normalize position
            float scaleX_ = ((float)(this.Width - 1) / (float)scaleX);
            float scaleY_ = ((float)(this.Height - 1) / (float)scaleY);

            mousePos.X = (int)(mousePos.X / scaleX_);
            mousePos.Y = (int)((this.Height - 1 - mousePos.Y) / scaleY_);

            if (controlPointValues.ContainsKey(mousePos.X)) return mousePos.X;
            
            else
            {
               
                foreach (int key in controlPointValues.Keys)
                {
                    if (mousePos.X >= (key - (cpTexWidth / 2)) &&
                        mousePos.X <= (key + (cpTexWidth / 2)))
                    {
                        return key;
                    }
                }
            }
           
            return -1;
        }
        #endregion

        #region Control Properties Events
        protected override void OnSizeChanged(EventArgs e)
        {
            //if new size == last size then no update call 
            if (this.Size != lastSize)
            {
                //Console.WriteLine("Size:" + Size);
                lastSize = this.Size;
                sizeChanged = true;
                
            }
            base.OnSizeChanged(e);
           
        }

        /*protected override void OnAutoSizeChanged(EventArgs e)
        {
            //if new size == last size then no update call 
            if (this.Size != lastSize)
            {
                //Console.WriteLine("Size:" + Size);
                lastSize = this.Size;
                sizeChanged = true;

            }
            base.OnAutoSizeChanged(e);

        }*/
        #endregion
    }
}