VS 2008, преобразование кода изолиний

using System;
using System.Collections;

namespace VisoCSharp.VisoDrawing
{
    /// <summary>
    /// Summary description for Isoline.
    /// </summary>
    public class Isoline : IComparable
    {
        private byte r;
        private byte g;
        private byte b;
        private float val;
        private static int id;
        private static double epsilon = 0.00001;
        float x1, x2, y1, y2, z1, z2;  
        float [] xh = new float[3], yh = new float[3], zh = new float[3];       // coordinates of the point in triangle
        float [] h = new float[3];               // values of the points( temperature,...)
        ArrayList iso_vert = new ArrayList();

        public struct Line
        {
            public float[] v1, v2;

            public Line(float x1, float y1, float z1, float x2, float y2, float z2)
            {
                v1 = new float[3] { x1, y1, z1 };
                v2 = new float[3] { x2, y2, z2 };
            }
        }
       
        public int Id
        {
            get
            {
                return id;
            }
        }

        public float Value
        {
            get
            {
                return val;
            }
        }

        public byte[] RGB
        {
            set
            {
                r = value[0];
                g = value[1];
                b = value[2];
            }
            get
            {
                byte[] col = { r, g, b };
                return col;
            }
        }

        public ArrayList VertIso
        {
            get
            {
                return iso_vert;
            }
        }

        public Isoline( float myval )
        {
            //
            // TODO: Add constructor logic here
            //
            val = myval;
            id++;
            int index = id % 100;
            Color.SetColorIso(this, Color.RGB_standard[index, 0],
                Color.RGB_standard[index, 1], Color.RGB_standard[index, 2]);
        }

        public Isoline( float myval, byte[] rgb )
        {
            val = myval;
            id++;
            r = rgb[0];
            g = rgb[1];
            b = rgb[2];
        }

        public int CompareTo( Object rhs )
        {
            Isoline r = ( Isoline ) rhs;
            return this.Id.CompareTo(r.Id);
        }

        /// <summary>
        /// This function interpolates vertices
        /// of triangle to find given isoline.
        /// </summary>
        public void InterpVert( Triangle tri, float temp )
        {
            int m;   //index in the triangle points
            int[] sh = new int[3];

           
           
            int m1, m2, m3;                               // index of the points in triangle

            int [,,] castab = new int[3,3,3] { {{0,0,8},{0,2,5},{7,6,9}},
                                               {{0,3,4},{1,3,1},{4,3,0}},
                                               {{9,6,7},{5,2,0},{8,0,0}}
                                             };
           
            for ( m = 0; m < 3; m++ )
            {
                h[m]  = tri[m].val - temp;
                xh[m] = tri[m].xyz[0];
                yh[m] = tri[m].xyz[1];
                zh[m] = tri[m].xyz[2];
                if ( h[m] > 0.0 )
                    sh[m] = 1;
                else if( h[m] < 0.0 )
                    sh[m] = -1;
                else
                    sh[m] = 0;
            }

            m1 = 0;
            m2 = 1;
            m3 = 2;
            int case_value = castab[sh[m1]+1,sh[m2]+1,sh[m3]+1];
            if ( case_value != 0 )
            {
                switch( case_value )
                {
                    case 1:
                        x1 = xh[m1];
                        y1 = xh[m1];
                        z1 = zh[m1];
                        x2 = xh[m2];
                        y2 = xh[m2];
                        z2 = xh[m2];
                        break;
                    case 2:  // case 2 line between vertices 2 and 3
                        x1 = xh[m2];
                        y1 = yh[m2];
                        z1 = zh[m2];
                        x2 = xh[m3];
                        y2 = yh[m3];
                        z2 = zh[m3];
                        break;
                    case 3:  // case 3 line between vertices 3 and 1
                        x1 = xh[m3];
                        y1 = yh[m3];
                        z1 = zh[m3];
                        x2 = xh[m3];
                        y2 = yh[m3];
                        z2 = zh[m3];
                        break;
                    case 4:  // case 4 line between 1 and side 2-3
                        x1 = xh[m1];
                        y1 = yh[m1];
                        z1 = zh[m1];
                        x2 = xsect( m3, m1 );
                        y2 = ysect( m3, m1 );
                        z2 = zsect( m3, m1 );
                        break;  
                    case 5:  // case 5 line between vertex 2 and side 3-1
                        x1 = xh[m2];
                        y1 = xh[m2];
                        z1 = zh[m2];
                        x2 = xsect(m3, m1);
                        y2 = ysect(m3, m1);
                        z2 = zsect(m3, m1);
                        break;
                    case 6:
                        x1 = xh[m3];
                        y1 = yh[m3];
                        z1 = zh[m3];
                        x2 = xsect( m1 ,m2 );
                        y2 = ysect( m1 ,m2 );
                        z2 = zsect( m1, m2 );
                        break;
                    case 7:
                        x1 = xsect( m1, m2 );
                        y1 = ysect( m1, m2 );
                        z1 = zsect( m1, m2 );
                        x2 = xsect( m2, m3 );
                        y2 = ysect( m2, m3 );
                        z2 = zsect( m2, m3 );
                        break;
                    case 8:
                        x1 = xsect( m2, m3 );
                        y1 = ysect( m2, m3 );
                        z1 = zsect( m2, m3 );
                        x2 = xsect( m3, m1 );
                        y2 = ysect( m3, m1 );
                        z2 = zsect( m3, m1 );
                        break;
                    case 9:
                        x1 = xsect( m3, m1 );
                        y1 = ysect( m3, m1 );
                        z1 = zsect( m3, m1 );
                        x2 = xsect( m1, m2 );
                        y2 = ysect( m1, m2 );
                        z2 = zsect( m1, m2 );
                        break;
                    default:
                        break;
                }
                CreateIsoline(x1,y1,z1,x2,y2,z2);      
            }
        }

        private float xsect( int p1, int p2 )
        {
            return (h[p2]*xh[p1]-h[p1]*xh[p2])/(h[p2]-h[p1]);
        }

        private float ysect( int p1, int p2 )
        {
            return (h[p2]*yh[p1]-h[p1]*yh[p2])/(h[p2]-h[p1]);
        }
        private float zsect( int p1, int p2 )
        {
            return (h[p2]*zh[p1]-h[p1]*zh[p2])/(h[p2]-h[p1]);
        }

        private void CreateIsoline( float x1, float y1, float z1,
            float x2, float y2, float z2 )
        {
            Line l = new Line(x1, y1, z1, x2, y2, z2);
            iso_vert.Add(l);
        }

        /// <summary>
        /// Simple - slow version of removing duplicates in
        /// vertices ArrayList.
        /// </summary>
        private bool HasNeighbour(Line d)
        {
            float[] vert1 = new float[3];
            float[] vert2 = new float[3];

            for (int i = 0; i < iso_vert.Count; i++)
            {
                vert1 = ((Line)iso_vert).v1;
                vert2 = ((Line)iso_vert).v2;
                if ( Math.Abs(vert1[0] - d.v1[0]) < 0.0001f && Math.Abs(vert1[1] - d.v1[1]) < 0.0001f )
                    return true;

            }
            return false;
        }
    }


    public class Isolines
    {
        private ArrayList arrIso = new ArrayList();

        public Isolines()
        {
        }

        public int AddIsoline( Isoline iso )
        {
            arrIso.Add( iso );
            return iso.Id;
        }

        public int RemoveIsoline( Isoline remIso )
        {
            arrIso.Remove( remIso );
            return remIso.Id;
        }

        public static Isoline BinarySearch( Object iso )
        {
            return null;
        }

        public int Count
        {
            get
            {
                return arrIso.Count;
            }
        }

        public Isoline this[int index]
        {
            get
            {
                return (Isoline) arrIso[index];
            }
            set
            {
                arrIso[index] = (Isoline) value;
            }
        }
    }
}