trunk/visLU/FlowChannel.cs

Go to the documentation of this file.

#region Using Statements
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
#endregion

namespace visLU2
{
    public struct SingleChannel
    {
        float[] values;
        float[] normalizedValues;
        List<int> distinctValues;
        float minVal;
        float maxVal;

        #region Properties
        public float[] ChannelValues
        {
            set { values = value; }
            get { return values; }
        }

        public List<int> DistinctValues
        {
            get
            {
                if (distinctValues.Count() == 0)
                {
                    groupValues();
                } 
                return distinctValues;
            }
        }

        public float[] NormValues
        {
            get
            {
                if (normalizedValues == null)
                {
                    normalizeValues();
                }
                return normalizedValues;
            }
        }

        public float MinValue
        {
            set { minVal = value; }
            get { return minVal; }
        }

        public float MaxValue
        {
            set { maxVal = value; }
            get { return maxVal; }
        }
        #endregion

        public SingleChannel(int dimX, int dimY)
        {
            values = new float[dimX * dimY];
            normalizedValues = null;
            distinctValues = new List<int>();
            minVal = 0;
            maxVal = 0;
        }

        private void normalizeValues()
        {
            normalizedValues = new float[values.Length];

            for (int i = 0; i < values.Length; i++)
            {
                normalizedValues[i] = (values[i] - minVal) / (maxVal - minVal);
            }
        }

        private void groupValues()
        {
            List<float> valuesTmp = new List<float>();
            valuesTmp = NormValues.ToList<float>();
            valuesTmp.Sort();
            int globalCount = 0; //debug

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

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

                }

                distinctValues.Add(value1);
                globalCount += count;
            }
        }
 
    }

    public struct VelocityChannel
    {
        Vector3[] values;
        Vector3 minVal;
        Vector3 maxVal;

        #region Properties
        public Vector3[] VelocityValues
        {
            set { values = value; }
            get { return values; }
        }

        public Vector3 MinValue
        {
            set { minVal = value; }
            get { return minVal; }
        }

        public Vector3 MaxValue
        {
            set { maxVal = value; }
            get { return maxVal; }
        }
        #endregion

        public VelocityChannel(int dimX, int dimY)
        {
            values = new Vector3[dimX * dimY];
            minVal = Vector3.Zero;
            maxVal = Vector3.Zero;
        }


    }

    public struct FlowChannel
    {
        VelocityChannel velocity;
        SingleChannel[] addChannels;

        int timestepIdx; 
        
        //float timestep;

        #region Properties
        public VelocityChannel Velocity
        {
            get { return velocity; }
            set { velocity = value; }
        }

        public SingleChannel[] AddChannels
        {
            get { return addChannels; }
            set { addChannels = value; }
        }

        public int TimestepIdx
        {
            get { return timestepIdx; }
            set { timestepIdx = value; }
        }
        #endregion


        #region Contructor
        public FlowChannel(int xDim, int yDim, int addChannelsCount, int timestepIndex)
        {
            velocity = new VelocityChannel(xDim, yDim);
            addChannels = new SingleChannel[addChannelsCount];
            for (int i = 0; i < addChannelsCount; i++)
            {
                addChannels[i] = new SingleChannel(xDim, yDim);
            }
            timestepIdx = timestepIndex;
            
        }
        #endregion

        #region Methods
        public void setMinVelocity(Vector3 minVal)
        {
            velocity.MinValue = minVal;
        }

        public void setMaxVelocity(Vector3 maxVal)
        {
            velocity.MaxValue = maxVal;
        }

        public void setChannelMinVal(int channelIdx, float minVal)
        {
            addChannels[channelIdx].MinValue = minVal;
        }
        public void setChannelMaxVal(int channelIdx, float maxVal)
        {
            addChannels[channelIdx].MaxValue = maxVal;
        }
        #endregion
    }
}