source: branches/HeuristicLab.Problems.GaussianProcessTuning/ILNumerics.2.14.4735.573/Drawing/Plots/ILVectorField2D.cs @ 9102

///
///    This file is part of ILNumerics Community Edition.
///
///    ILNumerics Community Edition - high performance computing for applications.
///    Copyright (C) 2006 - 2012 Haymo Kutschbach, http://ilnumerics.net
///
///    ILNumerics Community Edition is free software: you can redistribute it and/or modify
///    it under the terms of the GNU General Public License version 3 as published by
///    the Free Software Foundation.
///
///    ILNumerics Community Edition is distributed in the hope that it will be useful,
///    but WITHOUT ANY WARRANTY; without even the implied warranty of
///    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
///    GNU General Public License for more details.
///
///    You should have received a copy of the GNU General Public License
///    along with ILNumerics Community Edition. See the file License.txt in the root
///    of your distribution package. If not, see <http://www.gnu.org/licenses/>.
///
///    In addition this software uses the following components and/or licenses: 
///
///    =================================================================================
///    The Open Toolkit Library License
///    
///    Copyright (c) 2006 - 2009 the Open Toolkit library.
///    
///    Permission is hereby granted, free of charge, to any person obtaining a copy
///    of this software and associated documentation files (the "Software"), to deal
///    in the Software without restriction, including without limitation the rights to 
///    use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
///    the Software, and to permit persons to whom the Software is furnished to do
///    so, subject to the following conditions:
///
///    The above copyright notice and this permission notice shall be included in all
///    copies or substantial portions of the Software.
///
///    =================================================================================
///    

using System;
using System.Collections.Generic;
using System.Text;
using ILNumerics.Drawing.Graphs;
using ILNumerics.Drawing.Shapes;
using ILNumerics.Drawing.Misc;
using ILNumerics.Exceptions;
using ILNumerics.Drawing.Interfaces;
using ILNumerics.Drawing.Collections; 

namespace ILNumerics.Drawing.Plots {
    /// <summary>
    /// visualizes 2D vector fields
    /// </summary>
    public sealed class ILVectorField2D : ILPlot, IILPanelConfigurator {

        #region attributes
        ILLines m_lines;
        float m_beta = (float)(5 * Math.PI / 180);
        float m_scaling = 0.9f;
        ILArray<float> m_data = ILMath.returnType<float>();
        ICollection<string> m_xLabels;
        ICollection<string> m_yLabels;
        #endregion

        #region properties
        /// <summary>
        /// Colormap used to map values to colors
        /// </summary>
        private ILColormap m_colormap;
        /// <summary>
        /// gets reference to data of all vectors or sets it (restricted to same size)
        /// </summary>
        public ILRetArray<float> Data {
            get {
                return m_data;
            }
            set {
                if (value != null && value.Size.IsSameSize(m_data.Size)) {
                    m_data.a = value.C; 
                    Invalidate(); 
                }
            }
        }

        /// <summary>
        /// get the colormap used for coloring the arrows or sets it
        /// </summary>
        public ILColormap Colormap {
            get { return m_colormap; }
            set {
                m_colormap = value;
                Invalidate();
            }
        }
        /// <summary>
        /// opening angle for the arrow heads, default: 5 deg
        /// </summary>
        public float ArrowHeadAngle {
            get { return m_beta; }
            set {
                m_beta = value;
                Invalidate();
            }
        }

        /// <summary>
        /// Scaling of arrow length, 1.0: full size; default: 0.9
        /// </summary>
        public float ArrowScale {
            get { return m_scaling; }
            set {
                m_scaling = value;
                Invalidate();
            }
        }

        /// <summary>
        /// enables access to the lines composite shape used for rendering
        /// </summary>
        public ILLines LinesShape {
            get {
                return m_lines; 
            }
        }

        /// <summary>
        /// collection of label texts for x axis
        /// </summary>
        public ICollection<string> XLabels {
            get { return m_xLabels; }
            set { 
                m_xLabels = value;
                Invalidate();
            }
        }

        /// <summary>
        /// collection of label texts for y axis
        /// </summary>
        public ICollection<string> YLabels {
            get { return m_yLabels; }
            set { 
                m_yLabels = value;
                Invalidate();
            }
        }

        #endregion

        #region constructors

        /// <summary>
        /// create new vector field (2D) plot 
        /// </summary>
        /// <param name="panel">panel hosting the scene</param>
        /// <param name="data">3d data array: :;:;0 - X coords of vectors, :;:;1 - Y coords</param>
        /// <param name="colormap">Colormap used for coloring, on null: Colormaps.ILNumerics is used as default</param>
        /// <param name="XLabels">labels for X axis, on null: auto labeling</param>
        /// <param name="YLabels">labels for Y axis, on null: auto labeling</param>
        public ILVectorField2D(ILPanel panel, ILInArray<float> data
            , ILColormap colormap, ICollection<string> XLabels
            , ICollection<string> YLabels)
            : base(panel) {
            using (ILScope.Enter(data)) {
                m_data.a = ILMath.check(data, (a) => { return (a.S[2] == 2 && !a.IsEmpty) ? a : null; }, ErrorMessage: "Invalid parameter: data"); 
                m_xLabels = XLabels;
                m_yLabels = YLabels;
                m_colormap = colormap;
                m_lines = new ILLines(m_panel, data.Size[0] * data.Size[1] * 4);
                m_lines.Shading = ShadingStyles.Interpolate;
                m_lines.Properties.Width = 2;
                m_lines.Properties.Antialiasing = true;
                m_lines.Label.Text = "";
                ArrowHeadAngle = (float)(10 * Math.PI / 180);
                Invalidate();
                Add(m_lines);
            }
        }
        #endregion

        #region public interface
        /// <summary>
        /// (internal use) reconfigures the plot after changes
        /// </summary>
        internal override void Configure() {
            using (ILScope.Enter()) {
                if (m_invalidated) {
                    ILArray<int> indices = ILMath.empty<int>();
                    ILArray<float> vertices = Computation.CreateVertices(
                        m_data, indices, m_beta, m_scaling / 2, m_colormap);
                    m_lines.Update(vertices["0;:"], vertices["1;:"], vertices["2;:"], indices, ILMath.toint32(vertices["3:5;:"].T));
                    // configure axes
                    configureAxis(AxisNames.XAxis, XLabels);
                    configureAxis(AxisNames.YAxis, YLabels);
                }
                base.Configure();
            }
        }
        #endregion

        #region IILPanelConfigurator Members
        /// <summary>
        /// configure the panel, called after the plot was added to the scene
        /// </summary>
        /// <param name="panel"></param>
        public void ConfigurePanel(ILPanel panel) {
            panel.DefaultView.SetDeg(0, 0, 100);
        }

        #endregion

        #region private helper
        private void configureAxis(AxisNames axis
                                    , ICollection<string> values) {
            ILTickCollection labels = m_panel.Axes[axis].LabeledTicks;
            if (values != null) {
                labels.Mode = TickMode.Manual;
                labels.Clear();
                int pos = 1;
                int axisIdx = (axis == AxisNames.XAxis) ?
                    1 : (axis == AxisNames.YAxis) ?
                    0 : 1; 
                foreach (string labelString in values) {
                    if (pos > m_data.Size[axisIdx])
                        break;
                    labels.Add(pos++, labelString); 
                }
            } else {
                labels.Mode = TickMode.Auto; 
            }
        }
        #endregion

        #region computation
        public class Computation : ILNumerics.ILMath {

            internal static ILRetArray<float> CreateVertices(ILInArray<float> inData
                                            , ILOutArray<int> outIndices
                                            , float beta, float scaling
                                            , ILColormap colormap) {
                using (ILScope.Enter(inData)) {
                    // each arrow needs 4 vertices (indexed rendering)
                    ILArray<float> data = check(inData);
                    ILArray<int> indices = empty<int>(); 

                    int numRows = data.Size[0];
                    int numCols = data.Size[1];
                    ILArray<float> ret = zeros<float>(4, numCols * numRows, 2);
                    // prepare indices
                    indices.a = repmat(new ILArray<int>(new int[] { 0, 2, 1, 2, 3, 2 }, 6, 1), 1, numCols * numRows);
                    indices.a = indices + repmat(toint32(counter(0.0, 4.0, 1, numCols * numRows)), 6, 1);
                    indices.a = indices.Reshape(new ILSize(2, numRows * numCols * 3));
                    // normalize incoming data to length 1.0 
                    ILArray<float> l = sqrt(sum(data * data, 2));
                    float maxL = (float)max(maxall(l), epsf);
                    l.a = (l / maxL)[":"].T * scaling;
                    ILArray<float> alpha = atan2(data[":;:;1"], data[":;:;0"]);
                    alpha.a = alpha[":"].T;
                    ILArray<float> x = data[":;:;0"][":"].T * scaling;
                    ILArray<float> y = data[":;:;1"][":"].T * scaling;
                    ILArray<float> xO = repmat(linspace<float>(1, numCols, numCols), numRows, 1)[":"].T;
                    ILArray<float> yO = repmat(linspace<float>(numRows, 1, numRows).T, 1, numCols)[":"].T;
                    ret["0;:;0"] = xO - x;
                    ret["1;:;0"] = xO + x - l / 2 * cos(alpha + beta);
                    ret["2;:;0"] = xO + x;
                    ret["3;:;0"] = xO + x - l / 2 * cos(alpha - beta);

                    ret["0;:;1"] = yO - y;
                    ret["1;:;1"] = yO + y - l / 2 * sin(alpha + beta);
                    ret["2;:;1"] = yO + y;
                    ret["3;:;1"] = yO + y - l / 2 * sin(alpha - beta);

                    ret["0;0;2"] = 0.0f;
                    // prepare colors 
                    ret[":;:;3:5"] = 
                        repmat(colormap.Map(l * colormap.Length).Reshape(1, l.Length, 3) * 255, 4, 1, 1);
                    return ret.Reshape(4 * numRows * numCols, 6).T;
                }
            }
            /// <summary>
            /// create data for a simple vector field for demonstration purposes
            /// </summary>
            /// <param name="numRows">number of rows</param>
            /// <param name="numCols">number of colums</param>
            /// <param name="offs">offset, linearly varing values lets the field 'roll'</param>
            /// <returns>three dimensional data array</returns>
            public static ILRetArray<float> CreateTestData(int numRows, int numCols, float offs) {
                using (ILScope.Enter()) {
                    ILArray<float> Y = repmat(linspace<float>(offs, pi * 2 + offs, numCols), numRows, 1);
                    ILArray<float> X = cos(Y);
                    X[":;:;1"] = sin(Y);
                    // scale vector length
                    X.a = X * repmat(0.6f + sin(Y) * 0.4f, 1, 1, 2);
                    return X;
                }
            }
        }
        #endregion

    }
}