Gui/MainWindow.cs

Go to the documentation of this file.

#region using statemens
using System;
using System.IO;
using System.Reflection;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using visLU.Gui;
#endregion

namespace visLU.Gui
{
   
    public partial class MainWindow : Form
    {
        #region interactive tranfer function variables
        Pen penGray = new Pen(Color.Gray);
        Pen penLightGray = new Pen(Color.LightSlateGray);
        Pen penBlack = new Pen(Color.Black);
        Pen penBlue = new Pen(Color.Blue);
        Size controlPointSize = new Size(9, 9);
        Size colorBarSize = new Size(1, 30);

        float[] isoValues;
        int[] isoValuesFrequency;
        SortedDictionary<int, TransferControlPoint> controlPoints;
        Color[] colorArray;
       
        int stepsize = 1;

        bool updateIsoValues = true;
        bool updateControlPoints = true;
        bool updateColorArray = true;
        bool tfPanelMouseDown = false;
        Point tfPanelMouseDownPos = new Point();
        #endregion

        #region other variables
        string assemblyLocation = Assembly.GetExecutingAssembly().Location;
        InputManager inputManager;
        #endregion

        public MainWindow()
        {
            InitializeComponent();
            SetStyle(ControlStyles.OptimizedDoubleBuffer |
                        ControlStyles.UserPaint |
                        ControlStyles.AllPaintingInWmPaint, true);

            inputManager = new InputManager();

            //init iso values for transfer function
            updateIsoValues = true;
            updateIsoValuesData();
            //init control points
            controlPoints = new SortedDictionary<int, TransferControlPoint>();
            updateControlPoints = true;
            updateControlPointsData();
            colorArray = new Color[256];
            updateColorArray = true;

        }

        #region XNA drawing area





        public IntPtr getDrawSurface()
        {
            return XNADrawSurface.Handle;
        }

        public void setXNADrawSurfaceDimensions()
        {
            GameProperties.Instance.XNADrawSurfaceWidth = XNADrawSurface.Size.Width;
            GameProperties.Instance.XNADrawSurfaceHeight = XNADrawSurface.Size.Height;
        }

        public int XNADrawWidth()
        {
            return XNADrawSurface.Size.Width;
        }

        public int XNADrawHeight()
        {
            return XNADrawSurface.Size.Height;
        }

        #endregion

        #region update controls






        public void updateSliceControls(int xRange, int yRange, int zRange)
        {
          //x Slice / side view
          Decimal xIncrement =  Decimal.Divide(XSliceNumericUpDown.Maximum, new Decimal(xRange));
          //string xString = xIncrement.ToString();
          //int xDecimalPlaces = xString.Substring(xString.IndexOf(",") + 1).Length;
          int xDecimalPlaces = 8;
          XSliceNumericUpDown.Increment = xIncrement;
          XSliceNumericUpDown.DecimalPlaces = xDecimalPlaces;
          XSliceNumericUpDown.Value = Decimal.Divide(XSliceNumericUpDown.Maximum, new Decimal(2));
          XSlider.Maximum = xRange;
          XSlider.Value = xRange / 2; 
          
          //y Slice / top view
          Decimal yIncrement = Decimal.Divide(YSliceNumericUpDown.Maximum, new Decimal(yRange));
          //string yString = yIncrement.ToString();
          //int yDecimalPlaces = yString.Substring(yString.IndexOf(",") + 1).Length;
          int yDecimalPlaces = 8;
          YSliceNumericUpDown.Increment = yIncrement;
          YSliceNumericUpDown.DecimalPlaces = yDecimalPlaces;
          YSliceNumericUpDown.Value = Decimal.Divide(YSliceNumericUpDown.Maximum, new Decimal(2));
          YSlider.Maximum = yRange;
          YSlider.Value = yRange / 2; 

          //z Slice / front
          Decimal zIncrement = Decimal.Divide(ZSliceNumericUpDown.Maximum, new Decimal(zRange));
          //string zString = zIncrement.ToString();
          //int zDecimalPlaces = zString.Substring(zString.IndexOf(",") + 1).Length;
          int zDecimalPlaces = 8;
          ZSliceNumericUpDown.Increment = zIncrement;
          ZSliceNumericUpDown.DecimalPlaces = zDecimalPlaces;
          ZSliceNumericUpDown.Value = Decimal.Divide(ZSliceNumericUpDown.Maximum, new Decimal(2));
          ZSlider.Maximum = zRange;
          ZSlider.Value = zRange / 2;

          XSliceGroup.Enabled = inputManager.enableSliceGroup(1);
          YSliceGroup.Enabled = inputManager.enableSliceGroup(2);
          ZSliceGroup.Enabled = inputManager.enableSliceGroup(3);
          XSliceGroup.Refresh();
          YSliceGroup.Refresh();
          ZSliceGroup.Refresh();
        }

        public void setSlicingGroups(int slice, Decimal increment, int decimalPlaces, Decimal value)
        {
            switch (slice)
            {
                case 1:
                    XSliceNumericUpDown.Increment = increment;
                    XSliceNumericUpDown.DecimalPlaces = decimalPlaces;
                    XSliceNumericUpDown.Value = value;
                    break;
                case 2:
                    YSliceNumericUpDown.Increment = increment;
                    YSliceNumericUpDown.DecimalPlaces = decimalPlaces;
                    YSliceNumericUpDown.Value = value;
                    break;
                case 3:
                    ZSliceNumericUpDown.Increment = increment;
                    ZSliceNumericUpDown.DecimalPlaces = decimalPlaces;
                    ZSliceNumericUpDown.Value = value;
                    break;
                default:
                    break;

            }

        }

        public void setSlicingGroups(int slice, int maximum, int value)
        {
            switch (slice)
            {
                case 1:
                    XSlider.Maximum = maximum;
                    XSlider.Value = value;
                    break;
                case 2:
                    YSlider.Maximum = maximum;
                    YSlider.Value = value;
                    break;
                case 3:
                    ZSlider.Maximum = maximum;
                    ZSlider.Value = value;
                    break;
                default:
                    break;

            }

        }
        #endregion

        #region event handler

        #region main menu handler

        #region file menu





        private void handleOpenFileMenu(object sender, EventArgs e)
        {
            // Default to the directory which contains our content files.
            //string assemblyLocation = Assembly.GetExecutingAssembly().Location;
            string relativePath = Path.Combine(assemblyLocation, "../../../../Data");
            string contentPath = Path.GetFullPath(relativePath);

            this.openFileDialog.InitialDirectory = contentPath;

            this.openFileDialog.Title = "Load Data Set";

            this.openFileDialog.Filter = "Data Files (*.dat)|*.dat";

            if (this.openFileDialog.ShowDialog() == DialogResult.OK)
            {
                GameProperties.Instance.dataFilename = openFileDialog.FileName.Substring(openFileDialog.FileName.LastIndexOf("\\") + 1);
                inputManager.updateXnaEngineState(true, true, true, true);
                updateIsoValues = true;
                TransferFunctionPanel.Invalidate();
            }
        }

        private void handleSaveFileMenu(object sender, EventArgs e)
        {
            string relativePath = Path.Combine(assemblyLocation, "../../../../Data/Screenshots");
            string contentPath = Path.GetFullPath(relativePath);

            this.saveFileDialog.InitialDirectory = contentPath;

            this.saveFileDialog.Title = "Save Image as";

            this.saveFileDialog.Filter = "JPG Files (*.jpg)|*.jpg";

            if (this.saveFileDialog.ShowDialog() == DialogResult.OK)
            {
                GameProperties.Instance.saveFilename = saveFileDialog.FileName;
                GameProperties.Instance.saveView = true;
                GameProperties.Instance.engineState.drawData = true;
            }
        }

        private void handleExitMenu(object sender, EventArgs e)
        {
            GameProperties.Instance.exitGame = true;

        }

        private void MainWindow_FormClosing(object sender, FormClosingEventArgs e)
        {
            GameProperties.Instance.exitGame = true;
        }
        #endregion

        #region view menu





        private void handleViewMenuOnClick(object sender, EventArgs e)
        {
           // if (inputManager == null)
             //   throw new InvalidOperationException("InputController Service not found.");

            if (sender == this.volViewToolStripMenuItem)
            {
                volViewToolStripMenuItem.Checked = true;
                topViewToolStripMenuItem.Checked = false;
                sideViewToolStripMenuItem.Checked = false;
                frontViewToolStripMenuItem.Checked = false;
                XSliceGroup.Enabled = false;
                YSliceGroup.Enabled = false;
                ZSliceGroup.Enabled = false;
                inputManager.setViewMode(ViewMode.VolView);
            }
            else if (sender == this.topViewToolStripMenuItem)
            {
                volViewToolStripMenuItem.Checked = false;
                topViewToolStripMenuItem.Checked = true;
                sideViewToolStripMenuItem.Checked = false;
                frontViewToolStripMenuItem.Checked = false;
                XSliceGroup.Enabled = false;
                YSliceGroup.Enabled = true;
                ZSliceGroup.Enabled = false;
                inputManager.setViewMode(ViewMode.TopView);
            }
            else if (sender == this.sideViewToolStripMenuItem)
            {
                volViewToolStripMenuItem.Checked = false;
                topViewToolStripMenuItem.Checked = false;
                sideViewToolStripMenuItem.Checked = true;
                frontViewToolStripMenuItem.Checked = false;
                XSliceGroup.Enabled = true;
                YSliceGroup.Enabled = false;
                ZSliceGroup.Enabled = false;
                inputManager.setViewMode(ViewMode.SideView);
            }
            else if (sender == this.frontViewToolStripMenuItem)
            {
                volViewToolStripMenuItem.Checked = false;
                topViewToolStripMenuItem.Checked = false;
                sideViewToolStripMenuItem.Checked = false;
                frontViewToolStripMenuItem.Checked = true;
                XSliceGroup.Enabled = false;
                YSliceGroup.Enabled = false;
                ZSliceGroup.Enabled = true;
                inputManager.setViewMode(ViewMode.FrontView);
            }

            inputManager.updateXnaEngineState(true, false, true, true);
        }

        private void handleZoomMenuOnCLick(object sender, EventArgs e)
        {

            if (sender == this.zoomInToolStripMenuItem) inputManager.setZoom(1);
            if (sender == this.zoomOutToolStripMenuItem) inputManager.setZoom(-1);
            //inputManager.setZoom(e.Delta / SystemInformation.MouseWheelScrollDelta);
            //inputManager.setZoom(e.Delta);
            inputManager.updateXnaEngineState(true, false, true, true);
        }
        #endregion

        #region functions menu
        //slicing
        private void handleSlicingMenu(object sender, EventArgs e)
        {
            SlicingForm slicingDialog = new SlicingForm();
            slicingDialog.MainForm = this;
            slicingDialog.setSlicingGroups(1, XSliceNumericUpDown.Increment, XSliceNumericUpDown.DecimalPlaces, XSliceNumericUpDown.Value);
            slicingDialog.setSlicingGroups(2, YSliceNumericUpDown.Increment, YSliceNumericUpDown.DecimalPlaces, YSliceNumericUpDown.Value);
            slicingDialog.setSlicingGroups(3, ZSliceNumericUpDown.Increment, YSliceNumericUpDown.DecimalPlaces, ZSliceNumericUpDown.Value);
            slicingDialog.setSlicingGroups(1, XSlider.Maximum, XSlider.Value);
            slicingDialog.setSlicingGroups(2, YSlider.Maximum, YSlider.Value);
            slicingDialog.setSlicingGroups(3, ZSlider.Maximum, ZSlider.Value);
            slicingDialog.Show();
        }

       

        //projection functions
        private void handleMaxIntensityProjMenu(object sender, EventArgs e)
        {
            if (maximumIntensityProjectionToolStripMenuItem.Checked)
            {
                maximumIntensityProjectionToolStripMenuItem.Checked = false;
                MaxIntensityProjCheckBox.Checked = false;
            }
            else
            {
                maximumIntensityProjectionToolStripMenuItem.Checked = true;
                MaxIntensityProjCheckBox.Checked = true;
            }
            inputManager.enableMaxIntensityProjection(MaxIntensityProjCheckBox.Checked);

        }
        private void handlePerspProjMenu(object sender, EventArgs e)
        {
            if (perspectiveProjectionToolStripMenuItem.Checked)
            {
                perspectiveProjectionToolStripMenuItem.Checked = false;
                orthogonalProjectionToolStripMenuItem.Checked = true;
                PerspProjRadio.Checked = false;
                OrthProjRadio.Checked = true;
            }
            else
            {
                perspectiveProjectionToolStripMenuItem.Checked = true;
                orthogonalProjectionToolStripMenuItem.Checked = false;
                PerspProjRadio.Checked = true;
                OrthProjRadio.Checked = false;
            }
            inputManager.enablePerspProjection(PerspProjRadio.Checked);
        }

        private void handleOrthProjMenu(object sender, EventArgs e)
        {
            if (orthogonalProjectionToolStripMenuItem.Checked)
            {
                perspectiveProjectionToolStripMenuItem.Checked = true;
                orthogonalProjectionToolStripMenuItem.Checked = false;
                PerspProjRadio.Checked = true;
                OrthProjRadio.Checked = false;
            }
            else
            {
                perspectiveProjectionToolStripMenuItem.Checked = false;
                orthogonalProjectionToolStripMenuItem.Checked = true;
                PerspProjRadio.Checked = false;
                OrthProjRadio.Checked = true;
            }
            inputManager.enablePerspProjection(PerspProjRadio.Checked);
        }

        //Blending
        private void handleBlendModeMenu(object sender, EventArgs e)
        {
            if (sender == frontToBackBlendingToolStripMenuItem)
            {
                if (frontToBackBlendingToolStripMenuItem.Checked)
                {
                    frontToBackBlendingToolStripMenuItem.Checked = false;
                    backToFrontBlendingToolStripMenuItem.Checked = true;
                }
                else
                {
                    frontToBackBlendingToolStripMenuItem.Checked = true;
                    backToFrontBlendingToolStripMenuItem.Checked = false;
                }

            }
            else if (sender == backToFrontBlendingToolStripMenuItem)
            {
                if (backToFrontBlendingToolStripMenuItem.Checked)
                {
                    frontToBackBlendingToolStripMenuItem.Checked = true;
                    backToFrontBlendingToolStripMenuItem.Checked = false;
                }
                else
                {
                    frontToBackBlendingToolStripMenuItem.Checked = false;
                    backToFrontBlendingToolStripMenuItem.Checked = true;
                }
 
            }

            BlendRadioButt1.Checked = frontToBackBlendingToolStripMenuItem.Checked;
            BlendRadioButt2.Checked = backToFrontBlendingToolStripMenuItem.Checked;
            inputManager.enableFrontToBackBlending(frontToBackBlendingToolStripMenuItem.Checked);
        }

        //Shading on/off
        private void handleShadingMenu(object sender, EventArgs e)
        {
            if (shadingToolStripMenuItem.Checked)
            {
                shadingToolStripMenuItem.Checked = false;
            }
            else
            {
                shadingToolStripMenuItem.Checked = true;
            }
            ShadingCheckBox.Checked = shadingToolStripMenuItem.Checked;
            inputManager.enableShading(ShadingCheckBox.Checked);
        }

        //transfer function
        private void handleEnableTransferFunctionMenu(object sender, EventArgs e)
        {
            if (enableTransferfunctionToolStripMenuItem.Checked)
            {
                enableTransferfunctionToolStripMenuItem.Checked = false;
                transferfunctionCheckBox1.Checked = false;
            }
            else enableTransferfunctionToolStripMenuItem.Checked = true;
            transferfunctionCheckBox.Checked = enableTransferfunctionToolStripMenuItem.Checked;
            inputManager.enableTransferFunction(enableTransferfunctionToolStripMenuItem.Checked, transferfunctionCheckBox1.Checked);
            TransferFunctionPanel.Refresh();
        }

        private void handleLoadTransferFunctionMenu(object sender, EventArgs e)
        {
            string relativePath = Path.Combine(assemblyLocation, "../../../../Data/Transferfunction");
            string contentPath = Path.GetFullPath(relativePath);

            this.openFileDialog.InitialDirectory = contentPath;

            this.openFileDialog.Title = "Load Transferfunction";

            this.openFileDialog.Filter = "XML Files (*.xml)|*.xml";

            if (this.openFileDialog.ShowDialog() == DialogResult.OK)
            {
                this.inputManager.loadTransferFunction(openFileDialog.FileName);
                this.inputManager.updateXnaEngineState(false, false, true, true);
                this.updateControlPoints = true;
                TransferFunctionPanel.Refresh();
            }
        }

        private void handleSaveTransferFunctionMenu(object sender, EventArgs e)
        {
            string relativePath = Path.Combine(assemblyLocation, "../../../../Data/Transferfunction");
            string contentPath = Path.GetFullPath(relativePath);

            this.saveFileDialog.InitialDirectory = contentPath;

            this.saveFileDialog.Title = "Save Transferfunction as";

            this.saveFileDialog.Filter = "XML Files (*.xml)|*.xml";

            if (this.saveFileDialog.ShowDialog() == DialogResult.OK)
            {
                this.inputManager.saveTransferFunction(saveFileDialog.FileName);
            }
        }


        private void handleEditTransferFunctionMenu(object sender, EventArgs e)
        {
            TransferfunctionForm transferFunctionDialog = new TransferfunctionForm();
            transferFunctionDialog.Show();
        }



        #endregion

        #region help menu
        //
        #endregion

        #endregion

        #region settings panel (right tab panel)

        #region slices 





        private void handleSliceNumericUpDown(object sender, EventArgs e)
        {
            if (sender == XSliceNumericUpDown)
            {
                XSlider.Value = Decimal.ToInt32(Decimal.Multiply(XSliceNumericUpDown.Value, new Decimal(XSlider.Maximum)));
                inputManager.setSliceValue(1, XSliceNumericUpDown.Value);
                
            }
            else if (sender == YSliceNumericUpDown)
            {
                YSlider.Value = Decimal.ToInt32(Decimal.Multiply(YSliceNumericUpDown.Value, new Decimal(YSlider.Maximum)));
                inputManager.setSliceValue(2, YSliceNumericUpDown.Value);
                
            }
            else if (sender == ZSliceNumericUpDown)
            {
                ZSlider.Value = Decimal.ToInt32(Decimal.Multiply(ZSliceNumericUpDown.Value, new Decimal(ZSlider.Maximum)));
                inputManager.setSliceValue(3, ZSliceNumericUpDown.Value);
                
            }
        }

        private void handleScrollSlider(object sender, EventArgs e)
        {
            if (sender == XSlider)
            {
                Decimal newValue = Decimal.Divide(new Decimal(XSlider.Value), new Decimal(XSlider.Maximum));
                XSliceNumericUpDown.Value = newValue;
                inputManager.setSliceValue(1, newValue);

            }
            else if (sender == YSlider)
            {
                Decimal newValue = Decimal.Divide(new Decimal(YSlider.Value), new Decimal(YSlider.Maximum));
                YSliceNumericUpDown.Value = newValue;
                inputManager.setSliceValue(2, newValue);

            }
            else if (sender == ZSlider)
            {
                Decimal newValue = Decimal.Divide(new Decimal(ZSlider.Value), new Decimal(ZSlider.Maximum));
                ZSliceNumericUpDown.Value = newValue;
                inputManager.setSliceValue(3, newValue);

            }

        }
        #endregion

        #region  transfer function panel





        private void handleTransferFunctionCheckbox1(object sender, EventArgs e)
        {
            if (transferfunctionCheckBox1.Checked)
            {
                enableTransferfunctionToolStripMenuItem.Checked = true;
                transferfunctionCheckBox.Checked = true;
            }
            inputManager.enableTransferFunction(transferfunctionCheckBox.Checked, transferfunctionCheckBox1.Checked);
            TransferFunctionPanel.Refresh();
        }
        private void handleTransferFunctionCheckbox(object sender, EventArgs e)
        {
            if (!transferfunctionCheckBox.Checked) transferfunctionCheckBox1.Checked = false;
            enableTransferfunctionToolStripMenuItem.Checked = transferfunctionCheckBox.Checked;
            inputManager.enableTransferFunction(transferfunctionCheckBox.Checked, transferfunctionCheckBox1.Checked);
            TransferFunctionPanel.Refresh();
        }

        private void TransferFunctionPanel_Paint(object sender, PaintEventArgs e)
        {
            Graphics grobj = e.Graphics;
            //grobj.Clear(System.Drawing.SystemColors.Control);
            grobj.PageUnit = GraphicsUnit.Pixel;
            grobj.PageScale = 1;
            grobj.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;

            if (!transferfunctionCheckBox.Checked) return;

            int width = TransferFunctionPanel.Width;
            int height = TransferFunctionPanel.Height;

            
            //draw rectangle area
            //grobj.DrawRectangle(penGray, new Rectangle(0, 0, width - 1, height - 1));

            //draw histogramm
            if (updateIsoValues)
            {
                updateIsoValuesData();
                generateHistogramm(width, height);
            }

            //draw histogramm
            /*if (updateIsoValues) updateIsoValuesData();
            for (int i = 0; i < isoValues.Length; i++) //: i=1 -> ignore values=0
            {
                for (int j = 0; j < stepsize; j++)
                {
                    Point lowerPoint = new Point((int)((isoValues[i]) * stepsize + j), height);
                    Point upperPoint = new Point((int)((isoValues[i]) * stepsize + j), (int)(height - isoValuesFrequency[i]));
                    #region debug
                    /*if (upperPoint.X >= (255 - 17))
                        {
                            grobj.DrawLine(penBlack, lowerPoint, upperPoint);
                            continue;
                        }

                        if (upperPoint.X > (255))
                        {
                            grobj.DrawLine(penBlack, lowerPoint, upperPoint);
                            continue;
                        }*/
                   /* #endregion
                    grobj.DrawLine(penLightGray, lowerPoint, upperPoint);
                }
            }*/

            //draw control points
            if (updateControlPoints) updateControlPointsData();
            List<Point> pList = new List<Point>();
            Color c1 = XNAToWindowsFormsColor(controlPoints.First().Value.color);
            Point p1 = new Point(controlPoints.First().Key, 255 - c1.A);
            pList.Add(p1);
            p1.X -= controlPointSize.Width / 2;
            p1.Y -= controlPointSize.Height / 2;

            Rectangle rect = new Rectangle(p1, controlPointSize);
            grobj.DrawRectangle(penBlack, rect); //border
            grobj.FillRectangle(new SolidBrush(c1), rect);

            IEnumerable<KeyValuePair<int, TransferControlPoint>> controlPointsTmp = controlPoints.Skip(1);
            foreach (KeyValuePair<int, TransferControlPoint> cp in controlPointsTmp)
            {
                //get first control point
                Color c2 = XNAToWindowsFormsColor(cp.Value.color);
                Point p2 = new Point(cp.Key, 255 - c2.A);
                pList.Add(p2);
                //get second control point if any
                p2.X -= controlPointSize.Width / 2;
                p2.Y -= controlPointSize.Height / 2;
                rect = new Rectangle(p2, controlPointSize);
                grobj.DrawRectangle(penBlack, rect); //border
                grobj.FillRectangle(new SolidBrush(c2), rect);

                p1 = p2;

            }
            grobj.DrawLines(penBlack, pList.ToArray());

            //draw colorbar
            if (updateColorArray && GameProperties.Instance.updateColorBar)
            {
                updateColorArrayData();
                
            }
           Rectangle rect1; Color c3;
            colorBarSize.Width = stepsize; // : draw color bar in correct stepsite too
            {
                for (int i = 0; i < colorArray.Length; i++)
                {
                    rect1 = new Rectangle(new Point(i, height - colorBarSize.Height), colorBarSize);
                    c3 = colorArray[i];
                    grobj.FillRectangle(new SolidBrush(c3), rect1);
                }
            }
            #region depricated
            //draw colorbar
            /*Color c3; Rectangle rect1; int nextX = 0;
            c3 = Color.FromArgb(0, Color.Black);
       
            for (int i = 0; i < width; i++)
            {
                Color c4 = Color.FromArgb(255, Color.White);
                rect1 = new Rectangle(new Point(i, height - colorBarSize.Height), colorBarSize);
              
                Color myColor = XNAToWindowsFormsColor(
                    new Microsoft.Xna.Framework.Vector4(GameProperties.Instance.colorArray[i].R / 255.0f,
                                GameProperties.Instance.colorArray[i].G / 255.0f,
                                GameProperties.Instance.colorArray[i].B / 255.0f,
                                GameProperties.Instance.colorArray[i].A / 255.0f));
                grobj.FillRectangle(new SolidBrush(myColor), rect1
                    );

            }*/

            #endregion
        }

        private void generateHistogramm(int width, int height)
        {
            Bitmap flag = new Bitmap(width, height);
            Graphics flagGraphics = Graphics.FromImage(flag);
          
            //draw histogramm
            for (int i = 0; i < isoValues.Length; i++) 
            {
                for (int j = 0; j < stepsize; j++)
                {
                    Point lowerPoint = new Point((int)((isoValues[i]) * stepsize + j), height);
                    Point upperPoint = new Point((int)((isoValues[i]) * stepsize + j), (int)(height - isoValuesFrequency[i]));
                    flagGraphics.DrawLine(penLightGray, lowerPoint, upperPoint);
                }
            }

            Image image = Image.FromHbitmap(flag.GetHbitmap());
            this.TransferFunctionPanel.BackgroundImage = image;
            this.TransferFunctionPanel.BackgroundImageLayout = ImageLayout.Center;
        }


        private void TransferFunctionPanel_MouseDown(object sender, MouseEventArgs e)
        {
            if (!transferfunctionCheckBox.Checked) return;

            Point newPos = clampToPanelDimensions(e.X, e.Y);

            if (e.Button == MouseButtons.Left) //select control point to move
            {
                tfPanelMouseDown = true;
                tfPanelMouseDownPos = newPos;
            }

            #region create new control point or edit one
            if (e.Button == MouseButtons.Right) //create new control point or edit one
            {
                ColorDialog colorPicker = new ColorDialog();
                colorPicker.Color = XNAToWindowsFormsColor(GameProperties.Instance.colorArray[newPos.X]);
                //colorPicker.FullOpen = true;

                //if user pick new color
                if (colorPicker.ShowDialog() == DialogResult.OK)
                {
                    Color color = colorPicker.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 - newPos.Y) / 255.0f);

                    int key = getControlPointKey(newPos);

                    if (key == -1) //add new control point
                    {
                        //
                       // TransferControlPoint cpNew = new TransferControlPoint(r, g, b, (int)(newPos.X / stepsize));
                        GameProperties.Instance.colorControlPoints.Add(new TransferControlPoint(r, g, b, (int)(newPos.X / stepsize)));
                        GameProperties.Instance.alphaControlPoints.Add(new TransferControlPoint(a, (int)(newPos.X / stepsize)));
                        TransferControlPoint cpNew = new TransferControlPoint(r, g, b, (int)(newPos.X / stepsize));
                        cpNew.color.W = a;
                        controlPoints.Add(newPos.X, cpNew);
                    }
                    else //edit color for the current one 
                    {
                        controlPoints[key].color.X = r;
                        controlPoints[key].color.Y = g;
                        controlPoints[key].color.Z = b;
                        controlPoints[key].color.W = a;

                        int currIsoValue = controlPoints[key].isoValue;

                        for (int i = 0; i < GameProperties.Instance.colorControlPoints.Count(); i++)
                        {
                            if (GameProperties.Instance.colorControlPoints[i].isoValue == currIsoValue
                                && GameProperties.Instance.alphaControlPoints[i].isoValue == currIsoValue)
                            {
                                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 );

                    //refresh xna
                    inputManager.updateXnaEngineState(false, false, true, true);

                    //refresh graphic
                    updateColorArray = true; //update only if color change
                    TransferFunctionPanel.Invalidate();

                }
            }
            #endregion

        }

        private void TransferFunctionPanel_MouseMove(object sender, MouseEventArgs e)
        {
            if (!transferfunctionCheckBox.Checked) return;

            //Console.WriteLine("e.x " + e.X);
            //Console.WriteLine("e.y " + e.Y);
            if (tfPanelMouseDown)
               {
                    
                    int key = getControlPointKey(tfPanelMouseDownPos); //old mouse pos
                    if (key != -1)
                    {
                        tfPanelMouseDownPos.X = key;
                        Point newPos = clampToPanelDimensions(e.X, e.Y); //new mouse pos
   
                        int oldIsoValue = (tfPanelMouseDownPos.X / stepsize);
                        int newIsoValue = (newPos.X / stepsize);
                        float newAlpaValue = (float)((255 - newPos.Y) / 255.0f);
                       
                        //float newAlpaValue = 1.0f - (float)(e.Y / 255.0f);
                        //Console.WriteLine(" new alpha = " + newAlpaValue);

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

                        for (int i = 0; i < GameProperties.Instance.colorControlPoints.Count(); i++)
                        {
                            if (GameProperties.Instance.colorControlPoints[i].isoValue == oldIsoValue
                                && GameProperties.Instance.alphaControlPoints[i].isoValue == oldIsoValue)
                            {
                                GameProperties.Instance.colorControlPoints[i].isoValue = newIsoValue;
                                GameProperties.Instance.alphaControlPoints[i].isoValue = newIsoValue;
                                GameProperties.Instance.alphaControlPoints[i].color.W = newAlpaValue;
                                i = GameProperties.Instance.colorControlPoints.Count();
                            }
                        }

                        //debug
                        //Console.WriteLine("moved color value:" + controlPoints[newPos.X].color.ToString());


                        //update start pos for this control point
                        tfPanelMouseDownPos = newPos;

                        //refresh xna
                        inputManager.updateXnaEngineState(false, false, true, true);

                        //refresh graphic
                        updateColorArray = true;
                        TransferFunctionPanel.Invalidate();
                    }
                }
            
        }

        private void TransferFunctionPanel_MouseUp(object sender, MouseEventArgs e)
        {
            tfPanelMouseDown = false;
        }

        #endregion

        #region extended features
        

        private void handleMaxIntensityProjCheckBox(object sender, EventArgs e)
        {
            if (MaxIntensityProjCheckBox.Checked)
            {
                maximumIntensityProjectionToolStripMenuItem.Checked = true;
            }
            else
            {
                maximumIntensityProjectionToolStripMenuItem.Checked = false;
            }
            inputManager.enableMaxIntensityProjection(MaxIntensityProjCheckBox.Checked);
        }

        private void handlePerspProjRadioButt(object sender, EventArgs e)
        {
            perspectiveProjectionToolStripMenuItem.Checked = true;
            orthogonalProjectionToolStripMenuItem.Checked = false;
            inputManager.enablePerspProjection(true);
        }

        private void handleOrthProjRadioButt(object sender, EventArgs e)
        {
            perspectiveProjectionToolStripMenuItem.Checked = false;
            orthogonalProjectionToolStripMenuItem.Checked = true;
            inputManager.enablePerspProjection(false);
        }

        private void handleBlendRadioButt1(object sender, EventArgs e)
        {
            frontToBackBlendingToolStripMenuItem.Checked = true;
            backToFrontBlendingToolStripMenuItem.Checked = false;
            inputManager.enableFrontToBackBlending(true);
        }

        private void handleBlendRadioButt2(object sender, EventArgs e)
        {
            frontToBackBlendingToolStripMenuItem.Checked = false;
            backToFrontBlendingToolStripMenuItem.Checked = true;
            inputManager.enableFrontToBackBlending(false);
        }

        private void handleShadingCheckBox(object sender, EventArgs e)
        {
            if (ShadingCheckBox.Checked)
            {
                shadingToolStripMenuItem.Checked = true;
            }
            else
            {
                shadingToolStripMenuItem.Checked = false;
            }
            inputManager.enableShading(ShadingCheckBox.Checked);
        }

        #endregion

        #endregion

        #endregion

        #region helper functions

        //transfer function
        private void updateIsoValuesData()
        {
            if (GameProperties.Instance.distinctDensityValues != null && GameProperties.Instance.distinctDensityValues.Length > 0)
            {
                isoValues = GameProperties.Instance.distinctDensityValues;
                isoValuesFrequency = GameProperties.Instance.countDensityValues;
                int width = this.TransferFunctionPanel.Width;
                int height = this.TransferFunctionPanel.Height;

                float minIso = isoValues[0];
                float maxIso = isoValues[isoValues.Length - 1];
                stepsize = (int)(width / Math.Abs(maxIso - minIso));
                float maxFrequency = (float)Math.Log10(isoValuesFrequency.Max());
                for (int i = 0; i < isoValuesFrequency.Length; i++)
                {
                    isoValuesFrequency[i] = (int)(((Math.Log10((float)isoValuesFrequency[i])) / maxFrequency) * (height));
                }

                updateIsoValues = false;
            }
       
        }

        private void updateControlPointsData()
        {

            //load control points froma a xml file defintion
            if (GameProperties.Instance.colorControlPoints != null && GameProperties.Instance.colorControlPoints.Count() > 0)
            {
                controlPoints.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;
                    controlPoints.Add(cpValue, cpNext);
                }

            }
            else //default control points when new data set was loaded
            {
                TransferControlPoint cp1 = new TransferControlPoint(0.0f, 0.0f, 0.0f, 0);
                TransferControlPoint cp2 = new TransferControlPoint(1.0f, 0.0f, 0.0f, 80);
                TransferControlPoint cp3 = new TransferControlPoint(0.0f, 1.0f, 0.0f, 128);
                TransferControlPoint cp4 = new TransferControlPoint(0.0f, 0.0f, 0.0f, 255);
                
                GameProperties.Instance.colorControlPoints.Add(cp1);
                GameProperties.Instance.colorControlPoints.Add(cp2);
                GameProperties.Instance.colorControlPoints.Add(cp3);
                GameProperties.Instance.colorControlPoints.Add(cp4);
                GameProperties.Instance.alphaControlPoints.Add(new TransferControlPoint(0.0f, 0));
                GameProperties.Instance.alphaControlPoints.Add(new TransferControlPoint(0.5f, 80));
                GameProperties.Instance.alphaControlPoints.Add(new TransferControlPoint(0.5f, 128));
                GameProperties.Instance.alphaControlPoints.Add(new TransferControlPoint(0.0f, 255));

                TransferControlPoint cp1_ = new TransferControlPoint(0.0f, 0.0f, 0.0f, 0);
                TransferControlPoint cp2_ = new TransferControlPoint(1.0f, 0.0f, 0.0f, 80);
                TransferControlPoint cp3_ = new TransferControlPoint(0.0f, 1.0f, 0.0f, 128);
                TransferControlPoint cp4_ = new TransferControlPoint(0.0f, 0.0f, 0.0f, 255);
                cp1_.color.W = 0.0f;
                cp2_.color.W = 0.5f;
                cp3_.color.W = 0.5f;
                cp4_.color.W = 0.0f;

                controlPoints.Add(0, cp1_);
                controlPoints.Add(80, cp2_);
                controlPoints.Add(128, cp3_);
                controlPoints.Add(255, cp4_);

            }

            updateControlPoints = false;
        }

        private void updateColorArrayData()
        {
            if (GameProperties.Instance.colorArray != null && GameProperties.Instance.colorArray.Count() > 0)
            {
                for (int i = 0; i < GameProperties.Instance.colorArray.Count(); i++)
                {
                    colorArray[i] = XNAToWindowsFormsColor(GameProperties.Instance.colorArray[i]);
                    colorArray[i] = Color.FromArgb((int)(GameProperties.Instance.alphaArray[i] * 255), colorArray[i]);
                }

                updateColorArray = false;
            }
        }

        private Color XNAToWindowsFormsColor(Microsoft.Xna.Framework.Vector4 xnaColor)
        {
            int r = (int)(xnaColor.X * 255);
            int g = (int)(xnaColor.Y * 255);
            int b = (int)(xnaColor.Z * 255);
            int a = (int)(xnaColor.W * 255);

            Color color = Color.FromArgb(a, r, g, b);
            return color;
        }

        private Color XNAToWindowsFormsColor(Microsoft.Xna.Framework.Graphics.Color xnaColor)
        {
            Color color = Color.FromArgb(xnaColor.A, xnaColor.R, xnaColor.G, xnaColor.B);
            return color;
        }


        private Color lerpColor(Color c1, Color c2, float amount)
        {
            int r = (int)(c1.R + amount * (c2.R - c1.R));
            int g = (int)(c1.G + amount * (c2.G - c1.G));
            int b = (int)(c1.B + amount * (c2.B - c1.B));
            int a = (int)(c1.A + amount * (c2.A - c1.A));
            Color lerpColor = Color.FromArgb(a, r, g, b);
            lerpColor = Color.FromArgb(255, lerpColor);

            return lerpColor;
        }

        private int getControlPointKey(Point mousePos)
        {
            if (controlPoints.ContainsKey(mousePos.X)) return mousePos.X;
            else
            {
                foreach (int key in controlPoints.Keys)
                {
                    if (mousePos.X >= (key - (controlPointSize.Width / 2)) &&
                        mousePos.X <= (key + (controlPointSize.Width / 2)))
                    {
                        return key;
                    }
                }
            }
            /*for (int i = -controlPointSize.Width / 2; i <= +controlPointSize.Width / 2; i++)
            {
                if (controlPoints.ContainsKey(mousePos.X + i)) return mousePos.X + i;
            }*/
            return -1;
        }

        private Point clampToPanelDimensions(int posX, int posY)
        {
            Point p = new Point(posX, posY);
            if (p.X < 0) { p.X = 0; }
            else if (p.X > this.TransferFunctionPanel.Width - 1)
            { p.X = this.TransferFunctionPanel.Width - 1; }
            if (p.Y < 0) { p.Y = 0; }
            else if (p.Y > this.TransferFunctionPanel.Height - 1)
            { p.Y = this.TransferFunctionPanel.Height - 1; }
            return p;
        }
        #endregion

        #region handle xna draw surface events

        private void handleXNADrawSurface_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            inputManager.setViewMode();
            volViewToolStripMenuItem.Checked = false;
            topViewToolStripMenuItem.Checked = false;
            sideViewToolStripMenuItem.Checked = false;
            frontViewToolStripMenuItem.Checked = false;
            XSliceGroup.Enabled = false;
            YSliceGroup.Enabled = false;
            ZSliceGroup.Enabled = false;
            switch (inputManager.getViewMode())
            {
 
                case 0:
                    volViewToolStripMenuItem.Checked = true;
                    break;
                case 1:
                    topViewToolStripMenuItem.Checked = true;
                    YSliceGroup.Enabled = true;
                    break;
                case 2:
                    sideViewToolStripMenuItem.Checked = true;
                    XSliceGroup.Enabled = true;
                    break;
                case 3:
                    frontViewToolStripMenuItem.Checked = true;
                    ZSliceGroup.Enabled = true;
                    break;
                default:
                    volViewToolStripMenuItem.Checked = true;
                    break;

            }
            inputManager.updateXnaEngineState(true, false, true, true);
        }


        private void handleXNADrawSurface_MouseDown(object sender, MouseEventArgs e)
        {
            inputManager.XnaDrawSurface_MouseDownEvent = true;
            inputManager.MouseDownPosX = e.X;
            inputManager.MouseDownPosY = e.Y;
        
        }

        private void handleXNADrawSurface_MouseUp(object sender, MouseEventArgs e)
        {
            inputManager.XnaDrawSurface_MouseDownEvent = false;
            inputManager.resetMousePos();
        }

        private void handleXNADrawSurface_MouseMove(object sender, MouseEventArgs e)
        {
            if (inputManager.XnaDrawSurface_MouseDownEvent)
            {
                inputManager.updateMousePos(e.X, e.Y);
                inputManager.updateXnaEngineState(true, false, true, true);
            }
        }

        private void handleXNADrawSurface_MouseScroll(object sender, MouseEventArgs e)
        {
            if (inputManager.XnaDrawSurface_MouseDownEvent)
            {
                inputManager.updateMouseScroll(e.Delta / SystemInformation.MouseWheelScrollDelta);
                //inputManager.updateMouseScroll(e.Delta);
                inputManager.updateXnaEngineState(true, false, true, true);
            }
        }
        #endregion

      

    }
}