source: branches/HeuristicLab.Problems.GaussianProcessTuning/ILNumerics.2.14.4735.573/Drawing/Shapes/ILCompositeShape.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.Drawing; 
using System.Collections.Generic;
using System.Text;
using ILNumerics.Drawing.Graphs; 
using ILNumerics; 
using ILNumerics.Exceptions; 
using ILNumerics.Drawing.Interfaces; 
using ILNumerics.Drawing; 
using ILNumerics.Misc; 

namespace ILNumerics.Drawing.Shapes {
    public abstract class ILCompositeShape<VertexType> : ILShape<VertexType> 
        where VertexType : struct, IILVertexDefinition {

        #region eventing 
        #endregion

        #region attributes
        /// <summary>
        /// actual indices used for rendering (sorted for translucent shapes)
        /// </summary>
        protected int[] m_renderIndices;
        /// <summary>
        /// cache indices defining each shapes corners
        /// </summary>
        protected ILArray<int> m_shapeIndices = ILMath.returnType<int>(); 
        /// <summary>
        /// cache camera position of last sorting
        /// </summary>
        protected ILPoint3Df m_oldCameraPosition;

        //private float[] m_vertexPositions; 
        #endregion

        #region properties
        /// <summary>
        /// Indices used to render primitives from vertices 
        /// </summary>
        public ILRetArray<int> Indices {
            get {
                return m_shapeIndices.C; 
            }
            set {
                m_shapeIndices.a = value; 
            }
        }
        #endregion

        #region constructors
        /// <summary>
        /// create composite shape
        /// </summary>
        /// <param name="panel">scene hosting the scene</param>
        /// <param name="numVertices">number of overall vertices for the shape</param>
        /// <param name="verticesPerShape">Number of vertices per shape</param>
        public ILCompositeShape (ILPanel panel, int numVertices, int verticesPerShape) 
            : base(panel,numVertices,verticesPerShape) {
            Opacity = 255; 
            m_shapeIndices.a = ILMath.toint32(
                ILMath.counter(0.0,1.0,VerticesPerShape,numVertices / VerticesPerShape)); 
        }

        ///// <summary>
        ///// create composite shape 
        ///// </summary>
        ///// <param name="panel">hosting panel</param>
        ///// <param name="verticesPerShape">number of vertices per shape</param>
        ///// <param name="X">x coordinates vector </param>
        ///// <param name="Y">y coordinates vector </param>
        ///// <param name="Z">z coordinates vector </param>
        ///// <remarks>The constructor creates a new composite shape out of all vertices specified in X,Y and Z.
        ///// Every vertex is only used once. Every shape uses 
        ///// <see cref="ILNumerics.Drawing.Shapes.ILShape&lt;T>.VerticesPerShape"/> vertices one after another.</remarks>
        //public ILCompositeShape(ILPanel panel, int verticesPerShape, ILBaseArray X, ILBaseArray Y, ILBaseArray Z)
        //    : base(panel, X.Length, verticesPerShape) {
        //    Update(X, Y, Z);
        //    m_shapeIndices.a = ILMath.toint32(
        //        ILMath.counter(0.0, 1.0, VerticesPerShape, m_vertCount / VerticesPerShape));
        //    Opacity = 255;
        //    m_shading = ShadingStyles.Flat;
        //}

        ///// <summary>
        ///// create composite shape 
        ///// </summary>
        ///// <param name="panel">hosting panel</param>
        ///// <param name="verticesPerShape">number of vertices per shape</param>
        ///// <param name="X">x coordinates vector </param>
        ///// <param name="Y">y coordinates vector </param>
        ///// <param name="Z">z coordinates vector </param>
        ///// <param name="mapping">Mapping of shapes, composes shapes out of vertices. Matrix having  
        ///// <see cref="ILNumerics.Drawing.Shapes.ILShape&lt;T>.VerticesPerShape"/> rows.
        ///// Every element in a column specifies the index of a vertex according to its position in X,Y,Z.
        ///// The <see cref="ILNumerics.Drawing.Shapes.ILShape&lt;T>.VerticesPerShape"/> elements in a column therefore 
        ///// compose a single shape. Vertices may get used arbitrary times (or not at all). All elements must be 
        ///// positive integer values in range 0...[<see cref="ILNumerics.Drawing.Shapes.ILShape.VertexCount"/>-1].</param>
        //public ILCompositeShape (ILPanel panel, int verticesPerShape, ILBaseArray X, ILBaseArray Y, ILBaseArray Z, ILBaseArray mapping) 
        //    : base (panel,X.Length,verticesPerShape) {
        //    Update(X, Y, Z, mapping);
        //    Opacity = 255; 
        //    m_shading = ShadingStyles.Interpolate; 
        //}

        ///// <summary>
        ///// create composite shape 
        ///// </summary>
        ///// <param name="panel">hosting panel</param>
        ///// <param name="verticesPerShape">number of vertices per shape</param>
        ///// <param name="X">x coordinates vector </param>
        ///// <param name="Y">y coordinates vector </param>
        ///// <param name="Z">z coordinates vector </param>
        ///// <param name="colors">matrix with <see cref="ILNumerics.Drawing.Shapes.ILShape.VertexCount"/> 
        ///// rows, 3 columns for (R,G,B) or 4 columns for 
        ///// (A,R,G,B) for every vertex specified by X,Y,Z. Elements must range from 0..255. If colors 
        ///// has 3 columns only, alpha values of 255 are used as default.</param>
        ///// <param name="mapping">Mapping of shapes, composes shapes out of vertices. Matrix having  
        ///// <see cref="ILNumerics.Drawing.Shapes.ILShape&lt;T>.VerticesPerShape"/> rows.
        ///// Every element in a column specifies the index of a vertex according to its position in X,Y,Z.
        ///// The <see cref="ILNumerics.Drawing.Shapes.ILShape&lt;T>.VerticesPerShape"/> elements in a column therefore 
        ///// compose a single shape. Vertices may get used arbitrary times (or not at all). All elements must be 
        ///// positive integer values in range 0...[<see cref="ILNumerics.Drawing.Shapes.ILShape.VertexCount"/>-1].</param>
        //public ILCompositeShape (ILPanel panel, int verticesPerShape, ILBaseArray X, ILBaseArray Y, ILBaseArray Z, ILBaseArray colors, ILBaseArray mapping) 
        //    : base (panel,X.Length,verticesPerShape) {
        //    Update(X, Y, Z, mapping, colors);
        //    System.Diagnostics.Debug.Assert(ILMath.toint32(mapping).MaxValue < Vertices.Length); 
        //    Opacity = 255;
        //    m_shading = ShadingStyles.Interpolate; 
        //}

        #endregion

        #region public interface 
        /// <summary>
        /// update vertices of this shape
        /// </summary>
        /// <param name="inX">x coordinates, vector of length <see cref="ILNumerics.Drawing.Shapes.ILShape.VertexCount"/></param>
        /// <param name="inY">y coordinates, vector of length <see cref="ILNumerics.Drawing.Shapes.ILShape.VertexCount"/></param>
        /// <param name="inZ">z coordinates, vector of length <see cref="ILNumerics.Drawing.Shapes.ILShape.VertexCount"/></param>
        /// <param name="mapping">Mapping of shapes, composes shapes out of vertices. Matrix having
        /// <see cref="ILNumerics.Drawing.Shapes.ILShape&lt;T>.VerticesPerShape"/> rows.
        /// Every element in a column specifies the index of a vertex according to its position in X,Y,Z.
        /// The <see cref="ILNumerics.Drawing.Shapes.ILShape&lt;T>.VerticesPerShape"/> elements in a column therefore
        /// compose a single shape. Vertices may get used arbitrary times (or not at all). All elements must be
        /// positive integer values in range 0...[<see cref="ILNumerics.Drawing.Shapes.ILShape.VertexCount"/>-1].</param>
        /// <param name="colors">matrix with <see cref="ILNumerics.Drawing.Shapes.ILShape.VertexCount"/> 
        /// rows, 3 columns for (R,G,B) or 4 columns for 
        /// (A,R,G,B) for every vertex specified by X,Y,Z. Elements must range from 0..255. If colors 
        /// has 3 columns only, alpha values of 255 are used as default.</param>
        /// <remarks>All vertices of the shape are updated with the data specified in X,Y and Z. Neither the colors or any
        /// other data of vertices are changed, if they are not provided. The shape is invalidated for reconfiguration at next redraw. </remarks>
        public void Update(ILInArray<float> inX, ILInArray<float> inY, ILInArray<float> inZ, ILInArray<int> inMapping = null, ILInArray<int> inColors = null) {
            using (ILScope.Enter(inX, inY, inZ, inMapping, inColors)) {
                if (!VertexDefinition.StoresColor)
                    throw new NotSupportedException("The underlying vertex type cannot store individual color values! Use another shape type, flat shading or ommit color values!");
                ILArray<float> X = ILMath.check(inX, (a) => { return (a.IsVector) ? a : null; }, true, "numeric vectors of same length expected for: X, Y and Z");
                ILArray<float> Y = ILMath.check(inY, (a) => { return (a.IsVector && a.Length == X.Length) ? a : null; }, true, "numeric vectors of same length expected for: X, Y and Z");
                ILArray<float> Z = ILMath.check(inZ, (a) => { return (a.IsVector && a.Length == X.Length) ? a : null; }, true, "numeric vectors of same length expected for: X, Y and Z");
                ILArray<int> mapping = ILMath.check(inMapping, (a) => { return (inMapping.IsMatrix && inMapping.S[0] == VerticesPerShape) ? a : null; }, true
                                                    , "mapping must be a numeric matrix, " + VerticesPerShape.ToString() + " rows, each column specifies indices for the vertices of a single shape.");
                ILArray<int> colors = ILMath.check(inColors, (a) => { return ((a.S[1] == 3 || a.S[1] == 4) && a.S[0] == X.Length) ? a : null; }, true 
                                                    , "invalid size of colors data! Colors must have 3 or 4 columns with color components (RGB) or alpha value + color components (ARGB) respectively. Number of rows must match number of vertices.");

                if (!ILMath.isnull(mapping)) {
                    int minInd, maxInd;
                    if (mapping.GetLimits(out minInd, out maxInd) && (minInd < 0 || maxInd >= X.Length))
                        throw new ILArgumentException("invalid mapping: indices out of range of vertices");
                    m_shapeIndices.a = mapping.C; 
                }
                if (ILMath.isnull(colors)) {
                    for (int i = 0; i < m_vertices.Length && i < X.Length && i < Y.Length && i < Z.Length; i++) {
                        m_vertices[i].XPosition = X.GetValue(i);
                        m_vertices[i].YPosition = Y.GetValue(i);
                        m_vertices[i].ZPosition = Z.GetValue(i);
                    }
                } else if (colors.Size[1] == 3) {
                    for (int i = 0; i < m_vertices.Length; i++) {
                        m_vertices[i].XPosition = X.GetValue(i);
                        m_vertices[i].YPosition = Y.GetValue(i);
                        m_vertices[i].ZPosition = Z.GetValue(i);
                        m_vertices[i].Color = Color.FromArgb(
                                colors.GetValue(i, 0),
                                colors.GetValue(i, 1),
                                colors.GetValue(i, 2));
                    }
                } else if (colors.Size[1] == 4) {
                    for (int i = 0; i < m_vertices.Length; i++) {
                        m_vertices[i].XPosition = X.GetValue(i);
                        m_vertices[i].YPosition = Y.GetValue(i);
                        m_vertices[i].ZPosition = Z.GetValue(i);
                        m_vertices[i].Color = Color.FromArgb(
                                colors.GetValue(i, 1),
                                colors.GetValue(i, 2),
                                colors.GetValue(i, 3));
                        m_vertices[i].Alpha = (byte)colors.GetValue(i);
                    }
                }
                Invalidate();
            }
        }
        protected override void IntDrawShape(ILRenderProperties props) {
            if (m_vertCount >= VerticesPerShape) {
                // draw from back to front
                if (m_oldCameraPosition != m_panel.Camera.Position
                    || m_renderIndices == null) {
                    if (m_shading == ShadingStyles.Flat && m_fillColor.A == byte.MaxValue) {
                        m_shapeIndices.ExportValues(ref m_renderIndices); 
                    } else {
                        sortPrimitives();
                    }
                }
                m_renderer.Draw(props,this,m_renderIndices);
            }
        }
        protected override void IntDrawLabel(ILRenderProperties props) {
            if (m_vertCount >= VerticesPerShape) {
                ILPoint3Df cent = m_vertices[m_shapeIndices.GetValue(0)].Position; 
                // draw label at center of first shape
                if (!String.IsNullOrEmpty(m_label.Text)) {
                    for (int i = 1; i < VerticesPerShape; i++) {
                        cent += m_vertices[m_shapeIndices.GetValue(i)].Position;
                    }
                    m_label.Draw(props, cent / VerticesPerShape); 
                }
            }
        }
        protected override void  ComputeLimits() {
            // only consider used(!) vertices (having indices in mapping)         
          ILPoint3Df cent = new ILPoint3Df();
            if (m_shapeIndices.IsEmpty) {
                // fast exit
                m_positionCenter = cent;
                m_positionMin = cent;
                m_positionMax = cent;
                return;
            }
            ILPoint3Df max = ILPoint3Df.MinValue, min = ILPoint3Df.MaxValue, cur;
            foreach (int vertexID in m_shapeIndices) {
                cur = m_vertices[vertexID].Position;
                cent = cent + cur;
                max = ILPoint3Df.Max(max, cur);
                min = ILPoint3Df.Min(min, cur);
            }
            m_positionCenter = cent / m_vertices.Length;
            m_positionMax = max;
            m_positionMin = min;
            //updateVertexPositions(Vertices, ref m_vertexPositions);
        }
        #endregion

        #region private helper

        //protected void sortPrimitives() {
        //    m_oldCameraPosition = m_panel.Camera.Position;
        //    Computation.SortIndices(
        //                m_vertices, m_shapeIndices, m_vertCount, m_panel.Camera.Position,
        //                VerticesPerShape).ExportValues(ref m_renderIndices);
        //}

        private void sortPrimitives() {
            m_oldCameraPosition = m_panel.Camera.Position;
            if (m_renderIndices == null || m_renderIndices.Length < m_shapeIndices.Size.NumberOfElements)
                m_renderIndices = new int[m_shapeIndices.Size.NumberOfElements];
            float camScale = (ILPoint3Df.Max(m_positionMax, m_positionMin) - m_positionCenter).GetLength(); 
            Computation.SortIndices(
                        Vertices
                        , m_shapeIndices
                        , m_vertCount
                        , m_panel.Camera.LookAt + ((m_panel.Camera.LookAt - m_panel.Camera.Position) * camScale)
                        , VerticesPerShape
                        , m_renderIndices);
        }
        
        private void updateVertexPositions(VertexType[] vertices, ref float[] vertexPositions) {
            if (vertexPositions == null || vertexPositions.Length < 3 * vertices.Length) {
                vertexPositions = new float[3 * vertices.Length];
            }
            int p = 0;
            if (vertices is C4bV3f[]) {
                C4bV3f[] verticesC4bV3f = (C4bV3f[])(object)vertices; 
                foreach (C4bV3f vertex in verticesC4bV3f) {
                    vertexPositions[p++] = vertex.XPosition;
                    vertexPositions[p++] = vertex.YPosition;
                    vertexPositions[p++] = vertex.ZPosition;
                }
            } else if (vertices is C4fN3fV3f[]) {
                C4fN3fV3f[] verticesC4fN3fV3f = (C4fN3fV3f[])(object)vertices; 
                foreach (C4fN3fV3f vertex in verticesC4fN3fV3f) {
                    vertexPositions[p++] = vertex.XPosition;
                    vertexPositions[p++] = vertex.YPosition;
                    vertexPositions[p++] = vertex.ZPosition;
                }
            } 
            // ... more vertex types here? 
        }

        private class Computation : ILMath {
            
            public static void SortIndices(VertexType[] vertices,
                                            ILInArray<int> shapeIndices, int vertCount,
                                            ILPoint3Df camera, int vertPerPrimitive, int[] renderIndices) {
                using (ILScope.Enter(shapeIndices)) {
                    bool dummy; 
                    ILArray<float> dist = array<float>(ILMemoryPool.Pool.New<float>(vertCount, false, out dummy) ,1,vertCount); 
                    float[] distArr = dist.GetArrayForWrite(); 
                    for (int vPos = 0; vPos < vertCount; ) {
                        distArr[vPos] = (vertices[vPos++].Position - camera).GetLength(); 
                    }
#if DEBUG
                    //ILArray<double> indDeb; 
                    //ILArray<float> minID = sort(new ILArray<float>(dist, 1, dist.Length), out indDeb,1,false);
                    //System.Diagnostics.Debug.Write("ind: " + shapeIndices.ValuesToString(0));
                    //System.Diagnostics.Debug.Write("dist: " + new ILArray<float>(dist, 1, dist.Length).ValuesToString(0));
                    //System.Diagnostics.Debug.Write("dist[ind]: " + (new ILArray<float>(dist, 1, dist.Length)[shapeIndices]).ValuesToString(0));
                    //System.Diagnostics.Debug.Write("sum(dist[ind]): " + sum(new ILArray<float>(dist, 1, dist.Length)[shapeIndices]).ValuesToString(0));
#endif
                    ILArray<double> idx = empty(); 
                    sort(sum(dist[shapeIndices], 0), idx, 1, false).Dispose(); 
                    // ind: indices into shapeIndices' columns 
                    shapeIndices[full, idx].ExportValues(ref renderIndices);
                }
            }

            //public static ILArray<int> SortIndices(VertexType[] vertices,
            //                                ILArray<int> shapeIndices, int vertCount,
            //                                ILPoint3Df camera, int vertPerPrimitive) {
            //    //System.Diagnostics.Debug.Assert(Math.IEEERemainder(vertCount,vertPerPrimitive) == 0); 
            //    float[] posArr = new float[3 * vertCount];
            //    int p = 0;
            //    foreach (VertexType vertex in vertices) {
            //        posArr[p++] = vertex.XPosition;
            //        posArr[p++] = vertex.YPosition;
            //        posArr[p++] = vertex.ZPosition;
            //    }
            //    ILArray<float> pos = new ILArray<float>(posArr, 3, vertCount);
            //    ILArray<float> cam = new ILArray<float>(
            //                         new float[] { camera.X, camera.Y, camera.Z }, 3, 1);
            //    // flip the camera around and move it outside the scene 
            //    ILArray<double> ind = null;
            //    cam = -cam * maxall(pos);
            //    cam = repmat(cam, 1, vertCount);
            //    pos = pos - cam;
            //    pos = sum(pos * pos, 0);   // pos holds distances for eaech vertex now
            //    // sort per primitive
            //    pos = sum(reshape(pos[shapeIndices[":"]], vertPerPrimitive, shapeIndices.Dimensions[1]), 0);
            //    ind = ILArray<double>.empty();
            //    sort(pos, out ind, 1, false);
            //    // ind: indices into shapeIndices' columns 
            //    return shapeIndices[null, ind][":"];
            //}

        }

        #endregion
    }
}