MainForm.cs

using System;
using System.Diagnostics;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using Gigasoft.ProEssentials;
using Gigasoft.ProEssentials.Enums;
using Gigasoft.ProEssentials.EventArg;

namespace GigaPrime3D
{
    /// <summary>
    /// GigaPrime3D - WinForms .NET 8 port of the WPF ProEssentials 3D surface demo.
    ///
    /// Three synchronized charts:
    ///   Chart3DSurface (Pe3do)  - GPU compute-shader 3D surface (center, fills)
    ///   Chart2DContour (Pesgo)  - linked 2D top-down contour (bottom-left overlay)
    ///   Chart2DLine    (Pesgo)  - live cross-section at the X plane (right column)
    ///
    /// Per the port rules: the ProEssentials chart-logic blocks below are copied
    /// VERBATIM from the WPF code-behind - only the host shell (layout, control
    /// creation, event signatures) is rewritten. Cross-framework conversions:
    ///   * WPF Pe3doWpf/PesgoWpf            -> WinForms Pe3do/Pesgo
    ///   * System.Windows.Media.Color.FromRgb(r,g,b) -> FromRgb helper (opaque ARGB)
    ///   * System.Windows.Media.Colors.White         -> System.Drawing.Color.White
    ///   * Slider RoutedPropertyChangedEventArgs<double> -> EventArgs + slider.Value
    ///   * CheckBox Checked/Unchecked pair  -> one CheckedChanged reading .Checked
    ///   * ComboBox SelectionChanged        -> SelectedIndexChanged
    ///   * Window.Closing -> FormClosing,  Main.SizeChanged -> Resize
    ///   * Cursor.LastMouseMove System.Windows.Point(double) -> System.Drawing.Point(int)
    ///   * GCHandle pins freed in Dispose(bool), not a finalizer
    ///   * control Loaded events -> Form.Load / Initialize* calls
    /// </summary>
    public partial class MainForm : Form
    {
        // ===== ProEssentials chart controls (WPF Pe3doWpf/PesgoWpf -> Pe3do/Pesgo) =====
        private Pe3do Chart3DSurface;
        private Pesgo Chart2DContour;
        private Pesgo Chart2DLine;

        // ===== Sidebar host controls (replace the named WPF XAML elements) =====
        private ComboBox HeightMaps;
        private FlatCheckBox ShowLegend;
        private FlatCheckBox BottomContour;
        private FlatCheckBox ShowPlane;
        private FlatCheckBox HotSpots;
        private ComboBox ReduceDataAmount;
        private Button HelpButton;
        private FlatSlider SliderHorizontalMove;
        private FlatSlider SliderVerticalMove;
        private FlatSlider SliderHorizontalLightRotation;
        private FlatSlider SliderVerticalLightRotation;

        // ===== Center overlay sliders (overlay the 3D surface, top-left) =====
        private FlatSlider SliderVerticalRotation;
        private FlatSlider SliderHorizontalRotation;
        private FlatSlider SliderZoom;
        private FlatSlider SliderZExaggeration;

        // ===== Right column (WPF Chart2DContainer grid) and its X-plane slider =====
        private Panel Chart2DContainer;
        private FlatSlider SliderXPlane;

        // #002B35 dark scientific background used throughout (WPF "#002B35")
        private static readonly Color BackTeal = Color.FromArgb(255, 0x00, 0x2B, 0x35);

        // Startup cover - hides the white first-paint while the heavy load blocks the
        // UI thread; lifted by a one-shot timer once the real UI has actually painted.
        private Form _startupCover;
        private System.Windows.Forms.Timer _coverLiftTimer;

        // ================== state fields (verbatim from WPF) ==================
        public HeightMap CurrentHeightMap { get; set; }
        public HeightMap HeightMapA { get; set; }

        private bool _bShowingPlane = false;

        private int _nDataStep = 2;    // Reduce Data default as user may have a slow PC without dedicated GPU
        private int _nAppliedStep = 2; // if less than 1000x1000 we avoid reduction.

        private int _rows;
        private int _cols;
        private bool _bZoomed = false;

        private float _maxx = 0f;
        private float _miny = 0f;
        private float _maxy = 0f;
        private float _minz = 0f;
        private float _maxz = 0f;

        private float _VertLightDegree = 0f;
        private float _HorzLightDegree = 0f;

        private int CursorTrackingMenu3d = 0;
        private int UndoZoomMenu3d = 1;

        private bool _updatingUi;

        // 36M points x 4 bytes ~150M
        // Passing shared app memory to both Pe3do and Pesgo saves 150M
        // Set up static shared memory resources
        private static float[] sMyXData = new float[6000];      // cols max
        private static float[] sMyZData = new float[6000];      // rows max
        private static float[] sMyYData = new float[36000000];  // rows x cols max

        private GCHandle _pinXHandle;  // data less than 85K bytes, best to pin
        private GCHandle _pinZHandle;  // no need to pin YData > 85K

        public MainForm()
        {
            // being safe, pin the smaller data arrays x and z
            _pinXHandle = GCHandle.Alloc(sMyXData, GCHandleType.Pinned);
            _pinZHandle = GCHandle.Alloc(sMyZData, GCHandleType.Pinned);

            // ===== Window properties (WPF Window attrs -> Form properties) =====
            Text = "GigaPrime3D  -  3D Surface + 2D Contour (WinForms)";
            BackColor = BackTeal;
            MinimumSize = new Size(400, 400);              // WPF MinWidth/MinHeight
            StartPosition = FormStartPosition.CenterScreen;
            var wa = Screen.PrimaryScreen.WorkingArea;     // WPF CenterWindowOnScreen: 80% of screen, centered
            Size = new Size((int)(wa.Width * 0.8), (int)(wa.Height * 0.8));

            BuildLayout();

            // Wire chart events (WPF wired these in the ctor + via XAML attributes).
            Chart3DSurface.MouseMove   += Chart_MouseMove;
            Chart3DSurface.PeCustomMenu += new Pe3do.CustomMenuEventHandler(Chart_PeCustomMenu);
            Chart3DSurface.PeHorzScroll += Chart_OnPeHorzScroll;   // XAML PeHorzScroll="..."
            Chart3DSurface.PeVertScroll += Chart_OnPeVertScroll;   // XAML PeVertScroll="..."
            Chart3DSurface.PeZoomIn     += Chart_OnPeZoomIn;       // XAML PeZoomIn="..."

            Chart2DContour.MouseEnter   += Chart2DContour_MouseEnter;
            Chart2DContour.PeZoomIn     += Chart2DContour_OnPeZoomIn;
            Chart2DContour.PeZoomOut    += Chart2DContour_OnPeZoomOut;
            Chart2DContour.PeHorzScroll += Chart2DContour_PeHorzScroll;
            Chart2DContour.PeVertScroll += Chart2DContour_PeVertScroll;

            // WinForms: initialize charts in Form.Load (the WPF per-control Loaded
            // events are not needed - by Form.Load all handles exist).
            this.Load        += MainForm_Load;
            this.FormClosing += Window_Closing;     // WPF Window.Closing
            this.Resize      += Main_SizeChanged;    // WPF Main.SizeChanged
        }

        // WPF finalizer ~MainWindow freed the pins; WinForms uses Dispose(bool).
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (_pinXHandle.IsAllocated) { _pinXHandle.Free(); }
                if (_pinZHandle.IsAllocated) { _pinZHandle.Free(); }
            }
            base.Dispose(disposing);
        }

        // =====================================================================
        // BuildLayout - replaces MainWindow.xaml.
        //
        // WPF 3-column Grid (275 sidebar | star chart | 220 right) becomes:
        //   centerPanel  Dock=Fill   - holds the 3D surface + rotation overlay
        //   Chart2DContainer Dock=Right W=220 - holds the 2D line + X-plane slider
        //   sidebar      Dock=Left  W=275 - the controls column
        //   Chart2DContour - a floating 360x360 overlay pinned bottom-left
        //
        // Docking rule (per the WinForms template): add the Fill control FIRST so
        // it sits at the back of the z-order; docked edges added afterward claim
        // their strips and Fill takes the remainder. Floating overlays are added
        // last and brought to front.
        // =====================================================================
        private void BuildLayout()
        {
            // ----- Center: 3D surface fills, rotation sliders overlay top-left -----
            var centerPanel = new Panel { Dock = DockStyle.Fill, BackColor = BackTeal };

            Chart3DSurface = new Pe3do { Dock = DockStyle.Fill };
            centerPanel.Controls.Add(Chart3DSurface);          // Fill added first

            var rotationOverlay = new FlowLayoutPanel
            {
                FlowDirection = FlowDirection.TopDown,
                WrapContents = false,
                AutoSize = true,
                AutoSizeMode = AutoSizeMode.GrowAndShrink,
                BackColor = BackTeal,                          // blends with the chart's dark corner
                Location = new Point(6, 30),
            };
            SliderVerticalRotation   = MakeSlider(-90, 90, 0);
            SliderHorizontalRotation = MakeSlider(0, 360, 0);
            SliderZoom               = MakeSlider(-50, -5, -24);
            SliderZExaggeration      = MakeSlider(1, 50, 10);
            SliderVerticalRotation.ValueChanged   += SliderVerticalRotation_OnValueChanged;
            SliderHorizontalRotation.ValueChanged += SliderHorizontalRotation_OnValueChanged;
            SliderZoom.ValueChanged               += SliderZoom_OnValueChanged;
            SliderZExaggeration.ValueChanged      += SliderZExaggeration_OnValueChanged;
            rotationOverlay.Controls.Add(MakeLabel("Vertical rotation"));
            rotationOverlay.Controls.Add(SliderVerticalRotation);
            rotationOverlay.Controls.Add(MakeLabel("Horizontal rotation"));
            rotationOverlay.Controls.Add(SliderHorizontalRotation);
            rotationOverlay.Controls.Add(MakeLabel("Magnification / Distance"));
            rotationOverlay.Controls.Add(SliderZoom);
            rotationOverlay.Controls.Add(MakeLabel("Explode Z Axis"));
            rotationOverlay.Controls.Add(SliderZExaggeration);
            centerPanel.Controls.Add(rotationOverlay);
            rotationOverlay.BringToFront();

            // ----- Right column: 2D line cross-section + X-plane slider -----
            Chart2DContainer = new Panel { Dock = DockStyle.Right, Width = 220, BackColor = BackTeal };

            Chart2DLine = new Pesgo { Dock = DockStyle.Fill };
            Chart2DContainer.Controls.Add(Chart2DLine);        // Fill added first

            var xplanePanel = new Panel { Dock = DockStyle.Top, Height = 34, BackColor = BackTeal };
            SliderXPlane = MakeSlider(0, 100, 0);
            SliderXPlane.Width = 150;
            SliderXPlane.Anchor = AnchorStyles.Top | AnchorStyles.Right;
            SliderXPlane.Location = new Point(xplanePanel.Width - 150 - 8, 7);
            SliderXPlane.ValueChanged += SliderXPlane_OnValueChanged;
            xplanePanel.Controls.Add(SliderXPlane);
            Chart2DContainer.Controls.Add(xplanePanel);        // docked Top, above the line chart

            // ----- Left sidebar: the controls column -----
            var sidebar = new Panel { Dock = DockStyle.Left, Width = 275, BackColor = BackTeal };
            var sideFlow = new FlowLayoutPanel
            {
                Dock = DockStyle.Fill,
                FlowDirection = FlowDirection.TopDown,
                WrapContents = false,
                AutoScroll = true,
                BackColor = BackTeal,
                Padding = new Padding(6, 6, 6, 6),
            };

            HeightMaps = new ComboBox
            {
                DropDownStyle = ComboBoxStyle.DropDownList,
                FlatStyle = FlatStyle.Flat,
                Width = 258,
                Font = new Font("Segoe UI", 11f),
                BackColor = BackTeal,
                ForeColor = Color.White,
                Margin = new Padding(1, 6, 0, 15),
            };
            HeightMaps.SelectedIndexChanged += HeightMaps_SelectionChanged;

            ShowLegend    = MakeCheck("Legend");
            BottomContour = MakeCheck("Bottom Contour");
            ShowPlane     = MakeCheck("X Plane");
            HotSpots      = MakeCheck("Cursor Tracking");
            ShowLegend.CheckedChanged    += ShowLegend_CheckedChanged;
            BottomContour.CheckedChanged += ShowContour_CheckedChanged;
            ShowPlane.CheckedChanged     += ShowPlane_CheckedChanged;
            HotSpots.CheckedChanged      += HotSpots_CheckedChanged;
            ShowPlane.Margin = new Padding(3, 3, 3, 18);
            HotSpots.Margin  = new Padding(3, 3, 3, 18);

            var reduceRow = new FlowLayoutPanel
            {
                FlowDirection = FlowDirection.LeftToRight,
                WrapContents = false,
                AutoSize = true,
                AutoSizeMode = AutoSizeMode.GrowAndShrink,
                BackColor = BackTeal,
                Margin = new Padding(0, 0, 0, 18),
            };
            var reduceLabel = MakeLabel("Reduce Data");
            reduceLabel.Margin = new Padding(3, 8, 6, 0);
            ReduceDataAmount = new ComboBox
            {
                DropDownStyle = ComboBoxStyle.DropDownList,
                FlatStyle = FlatStyle.Flat,
                Width = 64,
                Font = new Font("Segoe UI", 10f),
                BackColor = BackTeal,
                ForeColor = Color.White,
                // Bottom margin so the FlowLayoutPanel's auto-height clears the
                // combo's bottom border (a DropDownList forces its own height).
                Margin = new Padding(0, 5, 0, 4),
            };
            ReduceDataAmount.SelectedIndexChanged += ReduceDataAmount_SelectionChanged;
            reduceRow.Controls.Add(reduceLabel);
            reduceRow.Controls.Add(ReduceDataAmount);

            HelpButton = new Button
            {
                Text = "Help ?",
                AutoSize = false,
                Width = 80,
                Height = 30,
                FlatStyle = FlatStyle.Flat,
                BackColor = Color.Black,
                ForeColor = Color.White,
                Margin = new Padding(3, 0, 3, 18),
            };
            HelpButton.FlatAppearance.BorderColor = Color.FromArgb(255, 0x5A, 0xAA, 0xEB);
            HelpButton.Click += HelpButton_Click;

            SliderHorizontalMove          = MakeSlider(-10, 10, 0);
            SliderVerticalMove            = MakeSlider(-10, 10, 0);
            SliderHorizontalLightRotation = MakeSlider(0, 360, 0);
            SliderVerticalLightRotation   = MakeSlider(0, 360, 0);
            SliderHorizontalMove.ValueChanged          += SliderHorizontalMove_OnValueChanged;
            SliderVerticalMove.ValueChanged            += SliderVerticalMove_OnValueChanged;
            SliderHorizontalLightRotation.ValueChanged += SliderHorizontalLightRotation_OnValueChanged;
            SliderVerticalLightRotation.ValueChanged   += SliderVerticalLightRotation_OnValueChanged;

            sideFlow.Controls.Add(HeightMaps);
            sideFlow.Controls.Add(ShowLegend);
            sideFlow.Controls.Add(BottomContour);
            sideFlow.Controls.Add(ShowPlane);
            sideFlow.Controls.Add(HotSpots);
            sideFlow.Controls.Add(reduceRow);
            sideFlow.Controls.Add(HelpButton);
            sideFlow.Controls.Add(MakeLabel("Move Horizontally"));
            sideFlow.Controls.Add(SliderHorizontalMove);
            sideFlow.Controls.Add(MakeLabel("Move Vertically"));
            sideFlow.Controls.Add(SliderVerticalMove);
            sideFlow.Controls.Add(MakeLabel("Rotate Light Horizontally"));
            sideFlow.Controls.Add(SliderHorizontalLightRotation);
            sideFlow.Controls.Add(MakeLabel("Rotate Light Vertically"));
            sideFlow.Controls.Add(SliderVerticalLightRotation);
            sidebar.Controls.Add(sideFlow);

            // ----- Assemble on the form: Fill first, then edges, then floating -----
            Controls.Add(centerPanel);       // Dock=Fill  (back of z-order)
            Controls.Add(Chart2DContainer);  // Dock=Right
            Controls.Add(sidebar);           // Dock=Left

            // 2D contour floats over the bottom-left corner (WPF: 360x360, ZIndex 1)
            Chart2DContour = new Pesgo { Size = new Size(360, 360) };
            Controls.Add(Chart2DContour);
            Chart2DContour.BringToFront();
            PositionContour();
        }

        private FlatSlider MakeSlider(int min, int max, int value)
        {
            var s = new FlatSlider { Width = 250, Height = 24, Margin = new Padding(5) };
            s.Minimum = min;
            s.Maximum = max;
            s.Value = value;
            return s;
        }

        private Label MakeLabel(string text)
        {
            return new Label
            {
                Text = text,
                ForeColor = Color.White,
                AutoSize = true,
                Font = new Font("Segoe UI", 10.5f),
                Margin = new Padding(3, 3, 3, 0),
            };
        }

        private FlatCheckBox MakeCheck(string text)
        {
            return new FlatCheckBox { Text = text, Width = 180, Height = 26, Margin = new Padding(3, 3, 3, 0) };
        }

        // Pin the 2D contour to the bottom-left corner (WPF margin 0,450 in a tall
        // maximized window placed it at the lower-left; we anchor it there).
        private void PositionContour()
        {
            if (Chart2DContour == null) { return; }
            int y = ClientSize.Height - Chart2DContour.Height - 8;
            if (y < 8) { y = 8; }
            Chart2DContour.Location = new Point(8, y);
        }

        // =====================================================================
        // MainForm_Load - replaces WPF Main_Loaded + the three chart Loaded events.
        // =====================================================================
        private void MainForm_Load(object sender, EventArgs e)
        {
            // Startup cover: a SEPARATE top-level teal form (see CreateStartupCover)
            // sized over our client area, force-painted now so it stays composited on
            // screen while the heavy bring-up below blocks the UI thread - hiding the
            // white first-paint. A child panel can't do this (it's painted by the same
            // blocked message loop); a top-level window has its own backing store and
            // Refresh() paints it synchronously. Lifted in the finally, once the real
            // UI is fully rendered, so the cover never reveals a half-painted app.
            _startupCover = CreateStartupCover();
            _startupCover.Show(this);
            _startupCover.Refresh();   // synchronous paint - survives the blocking load that follows

            try
            {
                _nDataStep = _nAppliedStep;  // you can change for better performance (e.g. 3)

                _updatingUi = true;

                Chart2DContainer.Visible = false;   // WPF Chart2DContainer.Visibility = Collapsed

                HeightMaps.Items.Add("MaterialSurfaceScan1-2464x2056.bhm");
                HeightMaps.Items.Add("MaterialSurfaceScan2-5024x2736.bhm");
                HeightMaps.Items.Add("MaterialSurfaceScan3-5024x2736.bhm");
                HeightMaps.Items.Add("GrandCanyon-4033x4033.bhm");
                HeightMaps.Items.Add("NoisyTerrain-4352x4352.bhm");
                HeightMaps.Items.Add("GrandCanyon-grayscale-rawpng-512x512.png");
                HeightMaps.Items.Add("Terrain-rgb-rawpng-1000x1000.png");
                HeightMaps.Items.Add("Cat-grayscale-rawpng-2047x1531.png");
                HeightMaps.Items.Add("leaf-grayscale-rawpng-1096x2048.png");

                ReduceDataAmount.Items.Add("None");
                ReduceDataAmount.Items.Add("2X");
                ReduceDataAmount.Items.Add("3X");
                ReduceDataAmount.Items.Add("4X");

                ReduceDataAmount.SelectedIndex = 1;

                _updatingUi = false;

                // ----- (WPF Chart_Loaded / Chart2DContour_Loaded / Chart2D_Loaded) -----
                Initialize3D();
                Initialize2D();
                Initialize2DContour();

                HeightMaps.SelectedIndex = 0; // Set default chart example file; invokes initial RefreshUi(hm)

                SliderHorizontalRotation.Value = (int)Chart3DSurface.PeUserInterface.Scrollbar.DegreeOfRotation;
                SliderVerticalRotation.Value   = (int)Chart3DSurface.PeUserInterface.Scrollbar.ViewingHeight;
                SliderZoom.Value               = (int)Chart3DSurface.PePlot.Option.DxZoom;

                _updatingUi = true;
                SliderVerticalLightRotation.Value   = 300;
                SliderHorizontalLightRotation.Value = 180;
                SliderHorizontalMove.Value          = 0;
                SliderVerticalMove.Value            = 2;   // WPF 2.5f (DxViewportY already 2.5 from Initialize3D)
                _updatingUi = false;

                PositionContour();
            }
            finally
            {
                // Kick the now-complete UI to repaint, then lift the cover from a
                // one-shot timer rather than closing it here. Closing synchronously
                // races the first paint: this.Refresh() does NOT force the child
                // windows (sidebar + native charts) to paint - their WM_PAINTs are
                // still queued - so the reveal would show them paint white->themed.
                // WM_PAINT outranks WM_TIMER, so by the time the timer ticks the loop
                // has flushed every queued paint; the delay also covers the GPU present.
                this.Refresh();
                Chart3DSurface.Refresh();
                Chart2DContour.Refresh();
                Chart2DLine.Refresh();

                _coverLiftTimer = new System.Windows.Forms.Timer { Interval = 700 };
                _coverLiftTimer.Tick += LiftStartupCover;
                _coverLiftTimer.Start();
            }
        }

        private void LiftStartupCover(object sender, EventArgs e)
        {
            if (_coverLiftTimer != null)
            {
                _coverLiftTimer.Stop();
                _coverLiftTimer.Dispose();
                _coverLiftTimer = null;
            }
            if (_startupCover != null)
            {
                _startupCover.Close();
                _startupCover.Dispose();
                _startupCover = null;
            }
        }

        // Builds the startup cover form. Text is drawn in the Paint handler (not a
        // child Label) so a single synchronous cover.Refresh() paints both the teal
        // background and the "Loading..." text in one WM_PAINT.
        private Form CreateStartupCover()
        {
            var cover = new Form
            {
                FormBorderStyle = FormBorderStyle.None,
                StartPosition = FormStartPosition.Manual,
                Bounds = RectangleToScreen(ClientRectangle),
                BackColor = BackTeal,
                ShowInTaskbar = false,
                ControlBox = false,
            };
            cover.Paint += (s, pe) =>
            {
                pe.Graphics.Clear(BackTeal);
                using (var f = new Font("Segoe UI", 18f))
                    TextRenderer.DrawText(pe.Graphics, "Loading...", f, cover.ClientRectangle,
                        Color.White, TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter);
            };
            return cover;
        }

        private void Initialize3D()
        {
            try
            {
                // always start a 3D new initialization with a call to Reset
                Chart3DSurface.PeFunction.Reset();

                Chart3DSurface.PeSpecial.AutoImageReset = false; // important for final optimization

                Chart3DSurface.PeString.MainTitle = string.Empty;
                Chart3DSurface.PeString.SubTitle = string.Empty;
                Chart3DSurface.PeString.MultiSubTitles[0] = string.Empty;
                Chart3DSurface.PeString.XAxisLabel = "X";
                Chart3DSurface.PeString.YAxisLabel = "Z";
                Chart3DSurface.PeString.ZAxisLabel = "Y";

                Chart3DSurface.PeUserInterface.Dialog.ModelessAutoClose = true;
                Chart3DSurface.PeUserInterface.Dialog.PlotCustomization = true;

                Chart3DSurface.PePlot.PolyMode = PolyMode.SurfacePolygons;
                Chart3DSurface.PePlot.Method = ThreeDGraphPlottingMethod.Four;
                Chart3DSurface.PeColor.DxTransparencyMode = TransparencyMode.None;

                Chart3DSurface.PeGrid.Configure.DxPsManualCullXZ = true;
                Chart3DSurface.PePlot.Option.DxFitControlShape = false;
                Chart3DSurface.PePlot.Option.DxViewportX = 0;
                Chart3DSurface.PePlot.Option.DxViewportY = 2.5F;
                Chart3DSurface.PePlot.Option.DxFOV = 1;
                Chart3DSurface.PePlot.Option.DxZoom = -24.0f;
                Chart3DSurface.PeUserInterface.Scrollbar.ViewingHeight = 28;
                Chart3DSurface.PeUserInterface.Scrollbar.DegreeOfRotation = 145;

                Chart3DSurface.PePlot.Option.DegreePrompting = true;
                Chart3DSurface.PePlot.LinesOrTubes = LinesOrTubes.AllLines;
                Chart3DSurface.PePlot.SubsetLineTypes[0] = LineType.MediumThinSolid;

                Chart3DSurface.PePlot.Allow.WireFrame = false;
                Chart3DSurface.PePlot.Option.SurfacePolygonBorders = true;
                Chart3DSurface.PePlot.Option.ShowContour = ShowContour.None;

                Chart3DSurface.PeFont.SizeGlobalCntl = 1.1f;
                Chart3DSurface.PeFont.Fixed = true;
                Chart3DSurface.PeFont.FontSize = Gigasoft.ProEssentials.Enums.FontSize.Large;

                Chart3DSurface.PeAnnotation.Show = true;

                Chart3DSurface.PeGrid.Configure.AutoPadBeyondZeroX = true;
                Chart3DSurface.PeGrid.Configure.AutoPadBeyondZeroY = true;
                Chart3DSurface.PeGrid.Configure.AutoPadBeyondZeroZ = true;
                Chart3DSurface.PeGrid.Configure.AutoMinMaxPaddingX = 1;
                Chart3DSurface.PeGrid.Configure.AutoMinMaxPaddingY = 1;
                Chart3DSurface.PeGrid.Configure.AutoMinMaxPaddingZ = 1;

                Chart3DSurface.PeGrid.Configure.ManualScaleControlX = ManualScaleControl.None;
                Chart3DSurface.PeGrid.Configure.ManualScaleControlY = ManualScaleControl.None;
                Chart3DSurface.PeGrid.Configure.ManualScaleControlZ = ManualScaleControl.None;
                Chart3DSurface.PeGrid.Option.ShowXAxis = ShowAxis.All;
                Chart3DSurface.PeGrid.Option.ShowYAxis = ShowAxis.All;
                Chart3DSurface.PeGrid.Option.ShowZAxis = ShowAxis.All;

                Chart3DSurface.PeUserInterface.RotationDetail = RotationDetail.WireFrame;
                Chart3DSurface.PeUserInterface.Allow.FocalRect = false;
                Chart3DSurface.PeUserInterface.Menu.LegendLocation = MenuControl.Hide;

                Chart3DSurface.PeUserInterface.Scrollbar.ScrollSmoothness = 0;
                Chart3DSurface.PeUserInterface.Scrollbar.MouseWheelZoomSmoothness = 2;
                Chart3DSurface.PeUserInterface.Scrollbar.MouseWheelZoomFactor = 25.0f;
                Chart3DSurface.PeUserInterface.Scrollbar.PinchZoomSmoothness = 2;
                Chart3DSurface.PeUserInterface.Scrollbar.PinchZoomFactor = 20.0f;

                Chart3DSurface.PePlot.Option.DxViewportPanFactor = 10.0F;
                Chart3DSurface.PePlot.Option.DxZoomMin = -40;
                Chart3DSurface.PePlot.Option.DxZoomMax = -3;

                Chart3DSurface.PeUserInterface.Scrollbar.HorzScrollBar = false;
                Chart3DSurface.PeUserInterface.Scrollbar.VertScrollBar = false;
                Chart3DSurface.PeUserInterface.Scrollbar.MouseDraggingX = true;
                Chart3DSurface.PeUserInterface.Scrollbar.MouseDraggingY = true;
                Chart3DSurface.PeUserInterface.Scrollbar.MouseWheelFunction = MouseWheelFunction.HorizontalVerticalZoom;
                Chart3DSurface.PeUserInterface.Scrollbar.MouseWheelZoomEvents = true;

                Chart3DSurface.PeData.DuplicateDataX = DuplicateData.PointIncrement;
                Chart3DSurface.PeData.DuplicateDataZ = DuplicateData.SubsetIncrement;

                // Controls color of Surface //
                Chart3DSurface.PeColor.SubsetColors.Clear();
                Chart3DSurface.PeColor.SubsetShades.Clear();
                for (var colx = 0; colx < 256; ++colx)
                {
                    var index = (byte)(colx / 256.0 * (MyColors.Length - 1));
                    var color = MyColors[index];
                    Chart3DSurface.PeColor.SubsetColors[colx] = color;
                    Chart3DSurface.PeColor.SubsetShades[colx] = Color.FromArgb(255, (byte)(100 + colx), (byte)(100 + colx), (byte)(100 + colx));
                }
                Chart3DSurface.PeColor.SubsetColors[(int)Gigasoft.ProEssentials.Enums.SurfaceColors.SolidSurface] = Color.FromArgb(255, 170, 170, 255);

                // non data Color settings //
                Chart3DSurface.PeColor.BitmapGradientMode = false;
                Chart3DSurface.PeColor.QuickStyle = QuickStyle.DarkNoBorder;
                Chart3DSurface.PeConfigure.BorderTypes = TABorder.NoBorder;
                Chart3DSurface.PeColor.GraphBmpStyle = BitmapStyle.NoBmp;
                Chart3DSurface.PeColor.GraphBackground = FromRgb(0x00, 0x2B, 0x35);
                Chart3DSurface.PeColor.Desk = FromRgb(0x35, 0x2B, 0x00); // RGB is BGR for DeskColor, don't want to break code so leaving it
                Chart3DSurface.PeColor.GraphForeground = Color.White;
                Chart3DSurface.PeColor.ZAxis = Color.White;
                Chart3DSurface.PeColor.YAxis = Color.White;
                Chart3DSurface.PeColor.XAxis = Color.White;
                Chart3DSurface.PeColor.Text = Color.White;

                Chart3DSurface.PeLegend.ContourStyle = true;
                Chart3DSurface.PeLegend.Show = false; // there will be a UI CheckBox that controls this
                Chart3DSurface.PeLegend.Location = LegendLocation.Right;

                Chart3DSurface.PeData.NullDataValue = -9999;
                Chart3DSurface.PeData.NullDataValueX = -9999;
                Chart3DSurface.PeData.NullDataValueZ = -9999;

                Chart3DSurface.PeUserInterface.Cursor.PromptLocation = CursorPromptLocation.ToolTip;

                Chart3DSurface.PeLegend.ContourLegendPrecision = ContourLegendPrecision.TwoDecimals;

                Chart3DSurface.PeFont.SizeGlobalCntl = 1.35F;

                Chart3DSurface.PeUserInterface.Allow.Customization = false;
                Chart3DSurface.PeUserInterface.Allow.Maximization = false;
                Chart3DSurface.PeUserInterface.Menu.Contour = MenuControl.Hide;
                Chart3DSurface.PeUserInterface.Menu.BorderType = MenuControl.Hide;
                Chart3DSurface.PeUserInterface.Menu.BitmapGradient = MenuControl.Hide;
                Chart3DSurface.PeUserInterface.Menu.ShowLegend = MenuControl.Hide;
                Chart3DSurface.PeUserInterface.Menu.CustomizeDialog = MenuControl.Hide;
                Chart3DSurface.PeUserInterface.Menu.DataShadow = MenuControl.Hide;
                Chart3DSurface.PeUserInterface.Menu.QuickStyle = MenuControl.Hide;
                Chart3DSurface.PeUserInterface.Menu.DataPrecision = MenuControl.Hide;
                Chart3DSurface.PeUserInterface.Menu.Rotation = MenuControl.Hide;
                Chart3DSurface.PeUserInterface.Menu.LegendLocation = MenuControl.Hide;

                Chart3DSurface.PeUserInterface.Dialog.AllowEmfExport = false;
                Chart3DSurface.PeUserInterface.Dialog.AllowSvgExport = false;
                Chart3DSurface.PeUserInterface.Dialog.AllowWmfExport = false;
                Chart3DSurface.PeUserInterface.Allow.TextExport = false;
                Chart3DSurface.PeUserInterface.Dialog.HideExportImageDpi = true;
                Chart3DSurface.PeUserInterface.Dialog.HidePrintDpi = true;
                Chart3DSurface.PeUserInterface.Allow.FocalRect = false;

                Chart3DSurface.PeUserInterface.Menu.CustomMenuText[CursorTrackingMenu3d] = "Cursor Tracking";
                Chart3DSurface.PeUserInterface.Menu.CustomMenuState[CursorTrackingMenu3d, 0] = CustomMenuState.UnChecked;
                Chart3DSurface.PeUserInterface.Menu.CustomMenuLocation[CursorTrackingMenu3d] = CustomMenuLocation.Bottom;

                Chart3DSurface.PeUserInterface.Menu.CustomMenuText[UndoZoomMenu3d] = "Undo Zoom";
                Chart3DSurface.PeUserInterface.Menu.CustomMenuLocation[UndoZoomMenu3d] = CustomMenuLocation.Bottom;
                Chart3DSurface.PeUserInterface.Menu.CustomMenu[UndoZoomMenu3d, 0] = CustomMenu.Grayed;

                Chart3DSurface.PeConfigure.RenderEngine = RenderEngine.Direct3D;
                Chart3DSurface.PeConfigure.PrepareImages = true;
                Chart3DSurface.PeConfigure.CacheBmp = true;
                Chart3DSurface.PeConfigure.AntiAliasGraphics = false;
                Chart3DSurface.PeConfigure.AntiAliasText = false;

                Chart3DSurface.PeFunction.SetViewingAt(0.0f, 0.0f, 0.0f);

                // Final settings to control how scene is asked to render / refresh
                Chart3DSurface.PeFunction.Force3dxNewColors = true;
                Chart3DSurface.PeFunction.Force3dxAnnotVerticeRebuild = true;
                Chart3DSurface.PeFunction.Force3dxVerticeRebuild = true;
                Chart3DSurface.PeFunction.ReinitializeResetImage();
                Chart3DSurface.Invalidate();
            }
            catch (Exception e)
            {
                Debug.WriteLine(e.Message);
            }
        }

        private void Initialize2DContour()  // Left side Pesgo 2d contour
        {
            Chart2DContour.PeConfigure.RenderEngine = RenderEngine.Direct3D;
            Chart2DContour.PeConfigure.Composite2D3D = Composite2D3D.Foreground;

            Chart2DContour.PeUserInterface.Allow.Zooming = AllowZooming.HorzAndVert;
            Chart2DContour.PeUserInterface.Allow.ZoomStyle = ZoomStyle.Ro2Not;

            Chart2DContour.PePlot.Allow.ContourColors = true;
            Chart2DContour.PePlot.Allow.ContourColorsShadows = true;
            Chart2DContour.PePlot.Allow.ContourLines = false;

            Chart2DContour.PeConfigure.PrepareImages = true;
            Chart2DContour.PeConfigure.CacheBmp = true;
            Chart2DContour.PeConfigure.AntiAliasGraphics = true;
            Chart2DContour.PePlot.SubsetLineTypes[0] = LineType.MediumSolid;

            Chart2DContour.PeUserInterface.Allow.FocalRect = false;

            Chart2DContour.PeColor.Desk = FromRgb(0x00, 0x2B, 0x35);

            Chart2DContour.PeColor.Text = FromRgb(255, 255, 255);
            Chart2DContour.PeColor.GraphBackground = FromRgb(0x00, 0x2B, 0x35);

            Chart2DContour.PeConfigure.BorderTypes = TABorder.NoBorder;

            Chart2DContour.PeString.MainTitle = "";
            Chart2DContour.PeString.SubTitle = "";
            Chart2DContour.PeString.YAxisLabel = "";
            Chart2DContour.PeString.XAxisLabel = "";

            Chart2DContour.PeGrid.Configure.AutoMinMaxPadding = 0;

            Chart2DContour.PeLegend.ContourLegendPrecision = ContourLegendPrecision.TwoDecimals;
            Chart2DContour.PeLegend.ContourStyle = true;
            Chart2DContour.PeLegend.Location = LegendLocation.Left;
            Chart2DContour.PeLegend.Show = false;


            Chart2DContour.PeColor.SubsetColors.Clear();
            Chart2DContour.PeColor.SubsetShades.Clear();
            for (var colx = 0; colx < 256; ++colx)
            {
                var index = (byte)(colx / 256.0 * (MyColors.Length - 1));
                var color = MyColors[index];
                Chart2DContour.PeColor.SubsetColors[colx] = color;
                Chart2DContour.PeColor.SubsetShades[colx] = Color.FromArgb(255, (byte)(100 + colx), (byte)(100 + colx), (byte)(100 + colx));
            }

            Chart2DContour.PeConfigure.ImageAdjustLeft = -100; // shrink-tweak the borders
            Chart2DContour.PeConfigure.ImageAdjustRight = -100;
            Chart2DContour.PeConfigure.ImageAdjustTop = 50;
            Chart2DContour.PeConfigure.ImageAdjustBottom = 0;

            Chart2DContour.PeUserInterface.Scrollbar.ScrollingHorzZoom = true;
            Chart2DContour.PeUserInterface.Scrollbar.ScrollingVertZoom = true;

            Chart2DContour.PeConfigure.Composite2D3D = Composite2D3D.Foreground;
            Chart2DContour.PeConfigure.RenderEngine = RenderEngine.Direct3D;

            Chart2DContour.PeUserInterface.Allow.Customization = false;
            Chart2DContour.PeUserInterface.Allow.Maximization = false;
            Chart2DContour.PeUserInterface.Menu.BorderType = MenuControl.Hide;
            Chart2DContour.PeUserInterface.Menu.BitmapGradient = MenuControl.Hide;
            Chart2DContour.PeUserInterface.Menu.ShowLegend = MenuControl.Hide;
            Chart2DContour.PeUserInterface.Menu.PlotMethod = MenuControl.Hide;
            Chart2DContour.PeUserInterface.Menu.CustomizeDialog = MenuControl.Hide;
            Chart2DContour.PeUserInterface.Menu.DataShadow = MenuControl.Hide;
            Chart2DContour.PeUserInterface.Menu.QuickStyle = MenuControl.Hide;
            Chart2DContour.PeUserInterface.Menu.DataPrecision = MenuControl.Hide;
            Chart2DContour.PeUserInterface.Menu.LegendLocation = MenuControl.Hide;
            Chart2DContour.PeUserInterface.Menu.MarkDataPoints = MenuControl.Hide;
            Chart2DContour.PeUserInterface.Menu.ViewingStyle = MenuControl.Hide;
            Chart2DContour.PeUserInterface.Menu.GridLine = MenuControl.Hide;

            Chart2DContour.PeUserInterface.Dialog.AllowEmfExport = false;
            Chart2DContour.PeUserInterface.Dialog.AllowSvgExport = false;
            Chart2DContour.PeUserInterface.Dialog.AllowWmfExport = false;
            Chart2DContour.PeUserInterface.Allow.TextExport = false;
            Chart2DContour.PeUserInterface.Dialog.HideExportImageDpi = true;
            Chart2DContour.PeUserInterface.Dialog.HidePrintDpi = true;

            Chart2DContour.PeColor.Desk = FromRgb(0x35, 0x2B, 0x00); // there's a bug in the control! Ya, R B reversed.
        }

        private void Initialize2D() // Right side Pesgo 2d crosssection plane
        {
            Chart2DLine.PeConfigure.RenderEngine = RenderEngine.Direct2D;  // its also the default

            Chart2DLine.PeString.MainTitle = "";
            Chart2DLine.PeString.SubTitle = "";
            Chart2DLine.PeString.XAxisLabel = "Z";
            Chart2DLine.PeString.YAxisLabel = "Y";
            Chart2DLine.PeGrid.Option.XAxisVertNumbering = true;

            Chart2DLine.PeFont.SizeGlobalCntl = .90F;

            Chart2DLine.PeConfigure.PrepareImages = true;
            Chart2DLine.PeConfigure.CacheBmp = true;
            Chart2DLine.PeConfigure.AntiAliasGraphics = true;
            Chart2DLine.PePlot.SubsetLineTypes[0] = LineType.MediumSolid;

            Chart2DLine.PeUserInterface.Allow.FocalRect = false;

            Chart2DLine.PeColor.Desk = FromRgb(0x00, 0x2B, 0x35);
            Chart2DLine.PeColor.Text = FromRgb(255, 255, 255);
            Chart2DLine.PeColor.GraphBackground = FromRgb(0x00, 0x2B, 0x35);
            Chart2DLine.PeColor.GraphForeground = Color.White;

            Chart2DLine.PeConfigure.BorderTypes = TABorder.NoBorder;
            Chart2DLine.PeGrid.GridBands = false;

            Chart2DLine.PeUserInterface.Allow.Customization = false;
            Chart2DLine.PeUserInterface.Allow.Maximization = false;
            Chart2DLine.PeUserInterface.Menu.BorderType = MenuControl.Hide;
            Chart2DLine.PeUserInterface.Menu.BitmapGradient = MenuControl.Hide;
            Chart2DLine.PeUserInterface.Menu.ShowLegend = MenuControl.Hide;
            Chart2DLine.PeUserInterface.Menu.PlotMethod = MenuControl.Hide;
            Chart2DLine.PeUserInterface.Menu.CustomizeDialog = MenuControl.Hide;
            Chart2DLine.PeUserInterface.Menu.DataShadow = MenuControl.Hide;
            Chart2DLine.PeUserInterface.Menu.QuickStyle = MenuControl.Hide;
            Chart2DLine.PeUserInterface.Menu.DataPrecision = MenuControl.Hide;
            Chart2DLine.PeUserInterface.Menu.LegendLocation = MenuControl.Hide;
            Chart2DLine.PeUserInterface.Menu.MarkDataPoints = MenuControl.Hide;
            Chart2DLine.PeUserInterface.Menu.ViewingStyle = MenuControl.Hide;

            Chart2DLine.PeUserInterface.Dialog.AllowEmfExport = false;
            Chart2DLine.PeUserInterface.Dialog.AllowSvgExport = false;
            Chart2DLine.PeUserInterface.Dialog.AllowWmfExport = false;
            Chart2DLine.PeUserInterface.Allow.TextExport = false;
            Chart2DLine.PeUserInterface.Dialog.HideExportImageDpi = true;
            Chart2DLine.PeUserInterface.Dialog.HidePrintDpi = true;
        }

        private void Chart2DContour_MouseEnter(object sender, EventArgs e)
        {
            // Disable Chart Pe3do hot spots (cursor tracking)
            CustomMenuState n = Chart3DSurface.PeUserInterface.Menu.CustomMenuState[CursorTrackingMenu3d, 0];
            if (n == CustomMenuState.Checked || HotSpots.Checked == true)
            {
                Chart2DContour.PeAnnotation.Graph.Show = false;  // remove the dot if there happens to be one
                Chart2DContour.PeAnnotation.Show = false;
                Chart2DContour.PeFunction.ResetImage(0, 0);
                Chart2DContour.Invalidate();

                n = CustomMenuState.UnChecked;
                Chart3DSurface.Freeze = true;
                Chart3DSurface.PeUserInterface.Cursor.HighlightColor = Color.FromArgb(0, 0, 0, 0);
                HotSpots.Checked = false;
                Chart3DSurface.PeUserInterface.HotSpot.Data = false;
                Chart3DSurface.PeUserInterface.Cursor.PromptTracking = false;
                Chart3DSurface.PeUserInterface.Menu.CustomMenuState[CursorTrackingMenu3d, 0] = n;
                Chart3DSurface.PeFunction.Force3dxVerticeRebuild = true;
                Chart3DSurface.PeFunction.ReinitializeResetImage();
                Chart3DSurface.Invalidate();
                Chart3DSurface.Freeze = false;
            }
        }

        private void Chart_PeCustomMenu(object sender, Gigasoft.ProEssentials.EventArg.CustomMenuEventArgs e)
        {
            CustomMenuState n = CustomMenuState.UnChecked;

            // Custom Menu was clicked //
            if (e.MenuIndex == CursorTrackingMenu3d) // Cursor Tracking State
            {
                // Reverse option //
                n = Chart3DSurface.PeUserInterface.Menu.CustomMenuState[CursorTrackingMenu3d, 0];
                if (n == CustomMenuState.UnChecked)
                {
                    n = CustomMenuState.Checked;
                    HotSpots.Checked = true;
                    Chart3DSurface.PeUserInterface.HotSpot.Data = true;
                    Chart3DSurface.PeUserInterface.Cursor.PromptTracking = true;
                    Chart3DSurface.PeUserInterface.Cursor.HighlightColor = Color.FromArgb(255, 255, 0, 0);
                }
                else
                {
                    n = CustomMenuState.UnChecked;
                    HotSpots.Checked = false;
                    Chart3DSurface.PeUserInterface.HotSpot.Data = false;
                    Chart3DSurface.PeUserInterface.Cursor.PromptTracking = false;
                    Chart3DSurface.PeUserInterface.Cursor.HighlightColor = Color.FromArgb(0, 0, 0, 0);
                }
                Chart3DSurface.PeUserInterface.Menu.CustomMenuState[CursorTrackingMenu3d, 0] = n;

                Chart3DSurface.PeFunction.Force3dxVerticeRebuild = true;
                Chart3DSurface.PeFunction.ReinitializeResetImage();

                Chart3DSurface.Invalidate();
                return;
            }
            if (e.MenuIndex == UndoZoomMenu3d) // Undo Zoom
            {
                if (_bZoomed)
                {
                    Chart2DContour.PeGrid.Zoom.Mode = false;
                    _bZoomed = false;
                    Chart2DContour.Invalidate();

                    Chart3DSurface.PeUserInterface.Menu.CustomMenu[UndoZoomMenu3d, 0] = CustomMenu.Grayed;

                    Chart3DSurface.PeGrid.Configure.ManualScaleControlX = ManualScaleControl.None;
                    Chart3DSurface.PeGrid.Configure.ManualScaleControlZ = ManualScaleControl.None;

                    Chart3DSurface.PeFunction.Force3dxVerticeRebuild = true;
                    Chart3DSurface.PeFunction.Force3dxAnnotVerticeRebuild = true;
                    Chart3DSurface.PeData.SkipRanging = true;

                    Chart3DSurface.PeFunction.Reinitialize();
                    Chart3DSurface.Invalidate();

                    float fRange = (float)(Chart3DSurface.PeGrid.Configure.ManualMaxX - Chart3DSurface.PeGrid.Configure.ManualMinX);
                    double dPos = Chart3DSurface.PeGrid.Configure.ManualMinX + (fRange * SliderXPlane.Value / 100.0F);
                    MoveXPlane(dPos);
                }
            }
        }

        private void RefreshUi(HeightMap hm)
        {
            // Changing the data of the chart, mostly maintaining all existing settings and states.

            CurrentHeightMap = hm;

            _nAppliedStep = 1;
            if (hm.HeightPx > 1001 || hm.WidthPx > 1001) { _nAppliedStep = _nDataStep; }

            _rows = hm.HeightPx / _nAppliedStep;
            _cols = hm.WidthPx / _nAppliedStep;

            var size = _rows * _cols;
            float fResolution = (float)hm.Resolution;

            var idx = 0;
            for (var row = 0; row < hm.HeightPx - (_nAppliedStep - 1); row += _nAppliedStep)
                sMyZData[idx++] = row * fResolution;

            idx = 0;
            for (var col = 0; col < hm.WidthPx - (_nAppliedStep - 1); col += _nAppliedStep)
                sMyXData[idx++] = col * fResolution;

            Chart3DSurface.PeData.ScaleForYData = 0;

            if (_nAppliedStep > 1)
            {
                idx = 0;
                for (var row = 0; row < hm.HeightPx - (_nAppliedStep - 1); row += _nAppliedStep)
                {
                    for (var col = 0; col < hm.WidthPx - (_nAppliedStep - 1); col += _nAppliedStep)
                    {
                        sMyYData[idx++] = (hm.GetPel(row, col));
                    }
                }
            }
            else
            {
                Array.Copy(hm.ImageData, sMyYData, _rows * _cols);
            }

            _maxx = (float)hm.WidthMm;
            _miny = (float)hm.MinZMm;
            _maxy = (float)hm.MaxZMm;
            _minz = 0.0F;
            _maxz = (float)hm.HeightMm;

            Chart3DSurface.PeData.Subsets = _rows;
            Chart3DSurface.PeData.Points = _cols;

            Chart3DSurface.PeData.DuplicateDataX = DuplicateData.PointIncrement;
            Chart3DSurface.PeData.DuplicateDataZ = DuplicateData.SubsetIncrement;

            // v10 new feature - build the scene on the GPU vs the CPU.
            Chart3DSurface.PeData.ComputeShader = true;

            // GPU staging buffers keep the X/Y/Z data resident video-side so later
            // forced rebuilds that DON'T change data (dragging Explode-Z) can reuse
            // them. ReuseData* are false here because the data IS changing on load -
            // the Explode-Z handler flips them true around its rebuild.
            Chart3DSurface.PeData.StagingBufferX = true;
            Chart3DSurface.PeData.StagingBufferY = true;
            Chart3DSurface.PeData.StagingBufferZ = true;
            Chart3DSurface.PeData.ReuseDataX = false;
            Chart3DSurface.PeData.ReuseDataY = false;
            Chart3DSurface.PeData.ReuseDataZ = false;

            // No transfer of data, set chart uses the app memory, same memory used for Pesgo below //
            Chart3DSurface.PeData.X.UseDataAtLocation(sMyXData, _cols);
            Chart3DSurface.PeData.Y.UseDataAtLocation(sMyYData, size);
            Chart3DSurface.PeData.Z.UseDataAtLocation(sMyZData, _rows);

            var width = (float)hm.WidthMm;
            var height = (float)hm.HeightMm;
            var diag = (float)Math.Sqrt(width * width + height * height);

            Chart3DSurface.PeGrid.Option.GridAspectX = width;
            Chart3DSurface.PeGrid.Option.GridAspectZ = height;
            Chart3DSurface.PeGrid.Option.GridAspectY = diag * 0.1f; // Z Axis Expansion

            Chart3DSurface.PeString.MainTitle = hm.Path;

            Chart3DSurface.PeFunction.SetLight(0, -2.0F, -7.0F, -7.0F);  // reset the light location

            _updatingUi = true;
            SliderHorizontalRotation.Value = (int)Chart3DSurface.PeUserInterface.Scrollbar.SBPos;
            SliderVerticalRotation.Value = (int)Chart3DSurface.PeUserInterface.Scrollbar.ViewingHeight;
            SliderZExaggeration.Value = 10;
            _updatingUi = false;

            Chart3DSurface.PeFunction.Force3dxVerticeRebuild = true;
            Chart3DSurface.PeFunction.ReinitializeResetImage();
            Chart3DSurface.Invalidate();

            ///////////////////////////////
            // Set data for 2D Contour   //
            ///////////////////////////////
            Initialize2DContour();

            Chart2DContour.PeConfigure.RenderEngine = RenderEngine.Direct3D;
            Chart2DContour.PeData.Subsets = _rows;
            Chart2DContour.PeData.Points = _cols;

            Chart2DContour.PeData.ComputeShader = true;

            Chart2DContour.PeData.DuplicateDataX = DuplicateData.PointIncrement;
            Chart2DContour.PeData.DuplicateDataY = DuplicateData.SubsetIncrement;

            // No transfer of data, set chart uses the app memory, same memory used for Pe3do above //
            Chart2DContour.PeData.X.UseDataAtLocation(sMyXData, _cols);
            Chart2DContour.PeData.Z.UseDataAtLocation(sMyYData, size);
            Chart2DContour.PeData.Y.UseDataAtLocation(sMyZData, _rows);

            Chart2DContour.PeGrid.Option.GridAspect = (float)_rows / (float)_cols;

            Chart2DContour.PePlot.Method = SGraphPlottingMethod.ContourColors;

            Chart2DContour.PeConfigure.Composite2D3D = Composite2D3D.Foreground;
            Chart2DContour.PeConfigure.RenderEngine = RenderEngine.Direct3D;
            Chart2DContour.PeFunction.Force3dxNewColors = true;
            Chart2DContour.PeFunction.Force3dxVerticeRebuild = true;

            Chart2DContour.PeFunction.ReinitializeResetImage();
            Chart2DContour.Invalidate();
        }

        private void Window_Closing(object sender, FormClosingEventArgs e)
        {
        }

        void Chart_MouseMove(object sender, MouseEventArgs e)
        {
            // Show on 2D Contour a Dot as location of mouse cursor over the 3D chart
            if (HotSpots.Checked == true)
            {
                // get last mouse location within control //
                // WPF System.Windows.Point (double) -> WinForms System.Drawing.Point (int); no (int) casts needed.
                System.Drawing.Point pt = Chart3DSurface.PeUserInterface.Cursor.LastMouseMove;
                int pX = pt.X;
                int pY = pt.Y;

                // Call to fill hot spot data structure with hot spot data at given x and y
                Chart3DSurface.PeFunction.GetHotSpot(pX, pY);
                Gigasoft.ProEssentials.Structs.HotSpotData ds = Chart3DSurface.PeFunction.GetHotSpotData();

                // get ydata value at hot spot //
                if (ds.Type == HotSpotType.DataPoint)
                {
                    int nHighLightSubset = ds.Data1;
                    int nHighLightPoint = ds.Data2;

                    int aCnt = 0;
                    Chart2DContour.PeAnnotation.Graph.X[aCnt] = Chart3DSurface.PeData.X[nHighLightSubset, nHighLightPoint];
                    Chart2DContour.PeAnnotation.Graph.Y[aCnt] = Chart3DSurface.PeData.Z[nHighLightSubset, nHighLightPoint];
                    Chart2DContour.PeAnnotation.Graph.Type[aCnt] = (int)Gigasoft.ProEssentials.Enums.GraphAnnotationType.LargeDotSolid;
                    Chart2DContour.PeAnnotation.Graph.Color[aCnt] = Color.FromArgb(255, 50, 50, 50);
                    aCnt++;

                    Chart2DContour.PeAnnotation.Graph.Show = true;
                    Chart2DContour.PeAnnotation.Show = true;
                    Chart2DContour.PeAnnotation.InFront = true;

                    Chart2DContour.PeFunction.ResetImage(0, 0);
                    Chart2DContour.Invalidate();
                }
            }
        }

        float InterpolateColor(float mine, float next)
        {
            var diff = next - mine;
            return Math.Abs(diff) < 0.0001 ? mine : mine + diff / 2;
        }

        private void SliderHorizontalRotation_OnValueChanged(object sender, EventArgs e)
        {
            if (_updatingUi)
                return;

            Chart3DSurface.PeUserInterface.Scrollbar.DegreeOfRotation = (int)SliderHorizontalRotation.Value;

            // Unlike ViewingHeight (vertical), which re-fits the view on a repaint,
            // DegreeOfRotation (horizontal) is consumed when the scene is CONSTRUCTED,
            // so a bare Invalidate/Refresh never shows the new angle - the image must
            // be rebuilt. Data and ranges are unchanged, so reuse the resident GPU
            // buffers and skip ranging to keep the drag fast.
            Chart3DSurface.PeData.ReuseDataX = true;
            Chart3DSurface.PeData.ReuseDataY = true;
            Chart3DSurface.PeData.ReuseDataZ = true;
            Chart3DSurface.PeData.SkipRanging = true;
            Chart3DSurface.PeFunction.ReinitializeResetImage();
            Chart3DSurface.Refresh();   // Pe3do needs explicit Refresh() on WinForms
        }

        private void SliderZoom_OnValueChanged(object sender, EventArgs e)
        {
            if (_updatingUi)
                return;

            // Zoom towards/away the center of scene (WPF used Dispatcher.InvokeAsync;
            // WinForms BeginInvoke defers the same way).
            BeginInvoke((Action)(() =>
            {
                Chart3DSurface.PePlot.Option.DxZoom = (float)SliderZoom.Value;
                Chart3DSurface.Refresh();   // Pe3do needs explicit Refresh() on WinForms
            }));
        }

        private void SliderVerticalLightRotation_OnValueChanged(object sender, EventArgs e)
        {
            if (_updatingUi)
                return;

            if (CurrentHeightMap != null)
            {
                _HorzLightDegree = (float)SliderHorizontalLightRotation.Value;
                _VertLightDegree = (float)SliderVerticalLightRotation.Value;
                float x = (float)Math.Sin(_HorzLightDegree * 0.0174533f) * 20.0F;
                float z = (float)Math.Cos(_HorzLightDegree * 0.0174533f) * 20.0F;
                float y = (float)Math.Sin(_VertLightDegree * 0.0174533f) * 20.0F;
                Chart3DSurface.PeFunction.SetLight(0, x, y, z);
            }
            Chart3DSurface.Refresh();   // Pe3do needs explicit Refresh() on WinForms
        }

        private void SliderHorizontalLightRotation_OnValueChanged(object sender, EventArgs e)
        {
            if (_updatingUi)
                return;

            if (CurrentHeightMap != null)
            {
                _HorzLightDegree = (float)SliderHorizontalLightRotation.Value;
                _VertLightDegree = (float)SliderVerticalLightRotation.Value;
                float x = (float)Math.Sin(_HorzLightDegree * 0.0174533f) * 20.0F;
                float z = (float)Math.Cos(_HorzLightDegree * 0.0174533f) * 20.0F;
                float y = (float)Math.Sin(_VertLightDegree * 0.0174533f) * 20.0F;
                Chart3DSurface.PeFunction.SetLight(0, x, y, z);
            }
            Chart3DSurface.Refresh();   // Pe3do needs explicit Refresh() on WinForms
        }

        private void SliderVerticalRotation_OnValueChanged(object sender, EventArgs e)
        {
            if (_updatingUi)
                return;

            Chart3DSurface.PeUserInterface.Scrollbar.ViewingHeight = (int)SliderVerticalRotation.Value;
            Chart3DSurface.Refresh();   // Pe3do needs explicit Refresh() on WinForms
        }

        private void Chart_OnPeHorzScroll(object sender, Gigasoft.ProEssentials.EventArg.ScrollEventArgs e)
        {
            // 3D chart built in click drag interface can rotate, so we update the UI slider to match
            _updatingUi = true;
            SliderHorizontalRotation.Value = (int)Chart3DSurface.PeUserInterface.Scrollbar.SBPos;
            _updatingUi = false;
        }

        private void Chart_OnPeVertScroll(object sender, Gigasoft.ProEssentials.EventArg.ScrollEventArgs e)
        {
            // 3D chart built in click drag interface can rotate, so we update the UI slider to match
            _updatingUi = true;
            var pos = e.Position > 32767 ? e.Position - 65536 : e.Position;
            SliderVerticalRotation.Value = (int)Chart3DSurface.PeUserInterface.Scrollbar.ViewingHeight;
            _updatingUi = false;
        }

        private void Chart_OnPeZoomIn(object sender, EventArgs e)
        {
            // MouseWheel used to zoom 3d chart, so we update the UI slider to match
            _updatingUi = true;
            SliderZoom.Value = (int)Chart3DSurface.PePlot.Option.DxZoom;
            _updatingUi = false;
        }

        private void SliderZExaggeration_OnValueChanged(object sender, EventArgs e)
        {
            if (_updatingUi == true) { return; }

            if (CurrentHeightMap is null)
                return;

            if (HotSpots.Checked == true)
            {
                // Disable hot spots and cursor prompt tracking during many image re-constructions.
                HotSpots.Checked = false;
            }

            var zExaggeration = (float)SliderZExaggeration.Value / 100.0f;

            var width = (float)CurrentHeightMap.WidthMm;
            var height = (float)CurrentHeightMap.HeightMm;
            var diag = (float)Math.Sqrt(width * width + height * height);

            Chart3DSurface.PeGrid.Option.GridAspectX = width;
            Chart3DSurface.PeGrid.Option.GridAspectZ = height;
            Chart3DSurface.PeGrid.Option.GridAspectY = diag * zExaggeration;

            if (_bShowingPlane)
            {
                float fRange = (float)(Chart3DSurface.PeGrid.Configure.ManualMaxX - Chart3DSurface.PeGrid.Configure.ManualMinX);
                double dPos = Chart3DSurface.PeGrid.Configure.ManualMinX + (fRange * (SliderXPlane.Value / 100.0F));
                MoveXPlane(dPos);
            }

            // Explode changes only the Y aspect ratio - the X/Y/Z data is unchanged.
            // Tell ProEssentials the data buffers are unchanged so the GPU reuses the
            // resident Direct3D staging buffers (set up in RefreshUi) instead of
            // re-uploading the whole surface on every slider tick.
            Chart3DSurface.PeData.ReuseDataX = true;
            Chart3DSurface.PeData.ReuseDataY = true;
            Chart3DSurface.PeData.ReuseDataZ = true;

            Chart3DSurface.PeFunction.Force3dxNewColors = true;
            Chart3DSurface.PeFunction.Force3dxVerticeRebuild = true;
            Chart3DSurface.PeFunction.ReinitializeResetImage();
            Chart3DSurface.Refresh();   // Pe3do needs explicit Refresh() on WinForms
        }

        private void HeightMaps_SelectionChanged(object sender, EventArgs e)
        {
            _bZoomed = false;
            Chart3DSurface.PeGrid.Configure.ManualScaleControlX = ManualScaleControl.None;
            Chart3DSurface.PeGrid.Configure.ManualScaleControlZ = ManualScaleControl.None;

            Chart3DSurface.PeUserInterface.Menu.CustomMenu[UndoZoomMenu3d, 0] = CustomMenu.Grayed;
            Chart2DContour.PeGrid.Zoom.Mode = false;

            string newfile = HeightMaps.SelectedItem.ToString();   // WPF SelectedValue -> WinForms SelectedItem
            HeightMapA = new HeightMap(newfile);
            RefreshUi(HeightMapA);

            BottomContour.Checked = false;         // reset bottom contour
            ShowLegend.Checked = true;             // reset show legend
            ShowPlane.Checked = true;              // show plane

            if (_bShowingPlane)
            {
                float fRange = (float)(Chart3DSurface.PeGrid.Configure.ManualMaxX - Chart3DSurface.PeGrid.Configure.ManualMinX);
                double dPos = Chart3DSurface.PeGrid.Configure.ManualMinX + (fRange * (SliderXPlane.Value / 100.0F));
                MoveXPlane(dPos);
            }
        }

        private void ShowPlane_CheckedChanged(object sender, EventArgs e)
        {
            if (ShowPlane.Checked)
            {
                if (CurrentHeightMap is null)
                    return;

                _bShowingPlane = true;

                if (SliderXPlane.Value == 40)
                {
                    float fRange = (float)(Chart3DSurface.PeGrid.Configure.ManualMaxX - Chart3DSurface.PeGrid.Configure.ManualMinX);
                    double dPos = Chart3DSurface.PeGrid.Configure.ManualMinX + (fRange * 40.0F / 100.0F);
                    MoveXPlane(dPos);

                    Chart3DSurface.PeFunction.Force3dxAnnotVerticeRebuild = true;
                    Chart3DSurface.PeData.SkipRanging = true;
                    Chart3DSurface.PeFunction.Reinitialize();
                    Chart3DSurface.Invalidate();
                }
                else
                {
                    SliderXPlane.Value = 40;
                    Chart3DSurface.PeFunction.Force3dxAnnotVerticeRebuild = true;
                    Chart3DSurface.PeData.SkipRanging = true;
                    Chart3DSurface.PeFunction.Reinitialize();
                    Chart3DSurface.Invalidate();
                }

                Chart2DContainer.Visible = true;   // WPF Visibility.Visible
            }
            else
            {
                _bShowingPlane = false;
                Chart3DSurface.PeAnnotation.Show = false;
                Chart3DSurface.PeFunction.Force3dxAnnotVerticeRebuild = true;
                Chart3DSurface.PeData.SkipRanging = true;
                Chart3DSurface.PeFunction.Reinitialize();
                Chart3DSurface.Invalidate();
                Chart2DContainer.Visible = false;  // WPF Visibility.Collapsed
            }
        }

        private void SliderXPlane_OnValueChanged(object sender, EventArgs e)
        {
            if (_updatingUi)
                return;

            float fRange = (float)(Chart3DSurface.PeGrid.Configure.ManualMaxX - Chart3DSurface.PeGrid.Configure.ManualMinX);
            double dPos = Chart3DSurface.PeGrid.Configure.ManualMinX + (fRange * SliderXPlane.Value / 100.0F);
            MoveXPlane(dPos);
        }

        /// <summary>
        /// Called when X Plane Slider is adjusted
        /// </summary>
        private void MoveXPlane(double fPos)
        {
            if (CurrentHeightMap is null)
                return;

            Chart3DSurface.PeAnnotation.Show = true;
            Chart3DSurface.PeAnnotation.Graph.Show = true;

            var x = fPos;
            var col = (int)(x / CurrentHeightMap.WidthMm * (CurrentHeightMap.WidthPx - (_nAppliedStep - 1) - 1));
            if (col <= 0) { col = 0; }
            if (col >= CurrentHeightMap.WidthPx) { col = CurrentHeightMap.WidthPx - 1; }

            // place the line right on the pixel
            x = col * CurrentHeightMap.Resolution;
            const byte alpha = 64;

            var index = 0;
            float fRange = (float)(Chart3DSurface.PeGrid.Configure.ManualMaxY - Chart3DSurface.PeGrid.Configure.ManualMinY);
            float fRangeOffset = fRange * 0.40F;
            double fOffset = fRange * 0.25F;  // offset the plane intersecting line upward

            // Create a Polygon graph annotation for translucent plane //

            Chart3DSurface.PeAnnotation.Graph.HotSpot[index] = false;
            Chart3DSurface.PeAnnotation.Graph.Type[index] = (int)GraphAnnotationType.StartPoly;
            Chart3DSurface.PeAnnotation.Graph.Color[index] = Color.FromArgb(alpha, 255, 255, 255);
            Chart3DSurface.PeAnnotation.Graph.X[index] = x;
            Chart3DSurface.PeAnnotation.Graph.Y[index] = _miny;
            Chart3DSurface.PeAnnotation.Graph.Z[index] = _minz;
            index++;

            Chart3DSurface.PeAnnotation.Graph.Type[index] = (int)GraphAnnotationType.AddPolyPoint;
            Chart3DSurface.PeAnnotation.Graph.Color[index] = Color.FromArgb(alpha, 255, 255, 255);
            Chart3DSurface.PeAnnotation.Graph.X[index] = x;
            Chart3DSurface.PeAnnotation.Graph.Y[index] = _miny;
            Chart3DSurface.PeAnnotation.Graph.Z[index] = _maxz;
            index++;

            Chart3DSurface.PeAnnotation.Graph.Type[index] = (int)GraphAnnotationType.AddPolyPoint;
            Chart3DSurface.PeAnnotation.Graph.Color[index] = Color.FromArgb(alpha, 255, 255, 255);
            Chart3DSurface.PeAnnotation.Graph.X[index] = x;
            Chart3DSurface.PeAnnotation.Graph.Y[index] = _maxy + fRangeOffset;
            Chart3DSurface.PeAnnotation.Graph.Z[index] = _maxz;
            index++;

            Chart3DSurface.PeAnnotation.Graph.Type[index] = (int)GraphAnnotationType.EndPolygon;
            Chart3DSurface.PeAnnotation.Graph.Color[index] = Color.FromArgb(alpha, 255, 255, 255);
            Chart3DSurface.PeAnnotation.Graph.X[index] = x;
            Chart3DSurface.PeAnnotation.Graph.Y[index] = _maxy + fRangeOffset;
            Chart3DSurface.PeAnnotation.Graph.Z[index] = _minz;
            index++;

            // Bound the plane with black line, with LineContinues //

            Chart3DSurface.PeAnnotation.Graph.HotSpot[index] = false;
            Chart3DSurface.PeAnnotation.Graph.Type[index] = (int)GraphAnnotationType.ThinSolidLine;
            Chart3DSurface.PeAnnotation.Graph.Color[index] = Color.FromArgb(255, 0, 0, 0);
            Chart3DSurface.PeAnnotation.Graph.X[index] = x;
            Chart3DSurface.PeAnnotation.Graph.Y[index] = _miny;
            Chart3DSurface.PeAnnotation.Graph.Z[index] = _minz;
            index++;

            Chart3DSurface.PeAnnotation.Graph.Type[index] = (int)GraphAnnotationType.LineContinue;
            Chart3DSurface.PeAnnotation.Graph.Color[index] = Color.FromArgb(255, 0, 0, 0);
            Chart3DSurface.PeAnnotation.Graph.X[index] = x;
            Chart3DSurface.PeAnnotation.Graph.Y[index] = _miny;
            Chart3DSurface.PeAnnotation.Graph.Z[index] = _maxz;
            index++;

            Chart3DSurface.PeAnnotation.Graph.Type[index] = (int)GraphAnnotationType.LineContinue;
            Chart3DSurface.PeAnnotation.Graph.Color[index] = Color.FromArgb(255, 0, 0, 0);
            Chart3DSurface.PeAnnotation.Graph.X[index] = x;
            Chart3DSurface.PeAnnotation.Graph.Y[index] = _maxy + fRangeOffset;
            Chart3DSurface.PeAnnotation.Graph.Z[index] = _maxz;
            index++;

            Chart3DSurface.PeAnnotation.Graph.Type[index] = (int)GraphAnnotationType.LineContinue;
            Chart3DSurface.PeAnnotation.Graph.Color[index] = Color.FromArgb(255, 0, 0, 0);
            Chart3DSurface.PeAnnotation.Graph.X[index] = x;
            Chart3DSurface.PeAnnotation.Graph.Y[index] = _maxy + fRangeOffset;
            Chart3DSurface.PeAnnotation.Graph.Z[index] = _minz;
            index++;

            Chart3DSurface.PeAnnotation.Graph.Type[index] = (int)GraphAnnotationType.LineContinue;
            Chart3DSurface.PeAnnotation.Graph.Color[index] = Color.FromArgb(255, 0, 0, 0);
            Chart3DSurface.PeAnnotation.Graph.X[index] = x;
            Chart3DSurface.PeAnnotation.Graph.Y[index] = _miny;
            Chart3DSurface.PeAnnotation.Graph.Z[index] = _minz;
            index++;

            // Create a Yellow line that outlines where the plane intersects the surface //

            var row = 0;
            var yOffset = (CurrentHeightMap.MaxZMm - CurrentHeightMap.MinZMm) * 0.0005;
            var z = CurrentHeightMap.GetRowMm(row);
            var y = CurrentHeightMap.GetPel(CurrentHeightMap.HeightPx - (_nAppliedStep - 1) - row - 1, col);

            Chart3DSurface.PeAnnotation.Graph.HotSpot[index] = false;
            Chart3DSurface.PeAnnotation.Graph.Type[index] = (int)GraphAnnotationType.ThinSolidLine;
            Chart3DSurface.PeAnnotation.Graph.Color[index] = Color.FromArgb(255, 255, 255, 0);
            Chart3DSurface.PeAnnotation.Graph.X[index] = x;
            Chart3DSurface.PeAnnotation.Graph.Y[index] = (y + yOffset) + fOffset;
            Chart3DSurface.PeAnnotation.Graph.Z[index] = z;
            index++;

            for (row = 0; row < CurrentHeightMap.HeightPx - (_nAppliedStep - 1); row++)
            {
                z = CurrentHeightMap.GetRowMm(row);
                y = CurrentHeightMap.GetPel(CurrentHeightMap.HeightPx - (_nAppliedStep - 1) - row - 1, col);
                Chart3DSurface.PeAnnotation.Graph.Type[index] = (int)GraphAnnotationType.LineContinue;
                Chart3DSurface.PeAnnotation.Graph.Color[index] = Color.FromArgb(255, 255, 255, 0);
                Chart3DSurface.PeAnnotation.Graph.X[index] = x;
                Chart3DSurface.PeAnnotation.Graph.Y[index] = (y + yOffset) + fOffset;
                Chart3DSurface.PeAnnotation.Graph.Z[index] = z;
                index++;
            }

            row = CurrentHeightMap.HeightPx - (_nAppliedStep - 1) - 1;
            z = CurrentHeightMap.GetRowMm(row);
            y = CurrentHeightMap.GetPel(row, col);
            Chart3DSurface.PeAnnotation.Graph.Type[index] = (int)GraphAnnotationType.EndPolyLineMedium;
            Chart3DSurface.PeAnnotation.Graph.Color[index] = Color.FromArgb(255, 255, 255, 0);
            Chart3DSurface.PeAnnotation.Graph.X[index] = x;
            Chart3DSurface.PeAnnotation.Graph.Y[index] = (y + yOffset) + fOffset;
            Chart3DSurface.PeAnnotation.Graph.Z[index] = z;

            Chart3DSurface.PeAnnotation.InFront = true;
            Chart3DSurface.PeFunction.Force3dxAnnotVerticeRebuild = true;
            Chart3DSurface.Invalidate();

            // Update Data within the Right Side Chart2D cross section chart

            Chart2DLine.PeData.Subsets = 1;
            Chart2DLine.PeData.Points = CurrentHeightMap.HeightPx - (_nAppliedStep - 1);

            index = 0;
            row = 0;
            yOffset = (CurrentHeightMap.MaxZMm - CurrentHeightMap.MinZMm) * 0.0005;
            z = CurrentHeightMap.GetRowMm(row);
            y = CurrentHeightMap.GetPel(CurrentHeightMap.HeightPx - (_nAppliedStep - 1) - row - 1, col);

            // simple spoon feeding a small slice of data
            Chart2DLine.PeData.Y[0, index] = (float)z;
            Chart2DLine.PeData.X[0, index] = (float)(y + yOffset);
            index++;

            float fMin = 1e35F;
            float fMax = -1e35F;
            int nMaxIndex = 0;
            int nMinIndex = 0;

            float fRangeY = (float)(Chart3DSurface.PeGrid.Configure.ManualMaxY - Chart3DSurface.PeGrid.Configure.ManualMinY);
            for (row = 0; row < CurrentHeightMap.HeightPx - (_nAppliedStep - 1); row++)
            {
                z = CurrentHeightMap.GetRowMm(row);
                y = CurrentHeightMap.GetPel(CurrentHeightMap.HeightPx - (_nAppliedStep - 1) - row - 1, col);

                if (y > fMax) { fMax = y; nMaxIndex = row; }
                if (y < fMin) { fMin = y; nMinIndex = row; }

                // simple spoon feeding a small slice of data
                Chart2DLine.PeData.Y[0, index] = (float)z;
                Chart2DLine.PeData.X[0, index] = (float)(y + yOffset);

                float fY = (float)(y + yOffset);
                float fYMinY = (float)(y + yOffset) - (float)Chart3DSurface.PeGrid.Configure.ManualMinY;
                float fIndex = (float)((y + yOffset) - Chart3DSurface.PeGrid.Configure.ManualMinY) / (float)fRangeY;

                fIndex = fIndex * 255.0F;
                if (fIndex > 255) { fIndex = 255; }
                Chart2DLine.PePlot.PointColors[0, index] = MyColors[(int)fIndex];
                index++;
            }

            row = CurrentHeightMap.HeightPx - (_nAppliedStep - 1) - 1;
            z = CurrentHeightMap.GetRowMm(row);
            y = CurrentHeightMap.GetPel(row, col);

            Chart2DLine.PeData.Y[0, index] = (float)z;
            Chart2DLine.PeData.X[0, index] = (float)(y + yOffset);

            Chart2DLine.PeGrid.Configure.ManualMinX = Chart3DSurface.PeGrid.Configure.ManualMinY;
            Chart2DLine.PeGrid.Configure.ManualMaxX = Chart3DSurface.PeGrid.Configure.ManualMaxY;
            Chart2DLine.PeGrid.Configure.ManualScaleControlX = ManualScaleControl.MinMax;

            int aCnt = 0;
            Chart2DLine.PeAnnotation.Graph.X[aCnt] = Chart2DLine.PeData.X[0, nMaxIndex];
            Chart2DLine.PeAnnotation.Graph.Y[aCnt] = Chart2DLine.PeData.Y[0, nMaxIndex];
            Chart2DLine.PeAnnotation.Graph.Text[aCnt] = fMax.ToString();
            Chart2DLine.PeAnnotation.Graph.Type[aCnt] = (int)GraphAnnotationType.Pointer;
            Chart2DLine.PeAnnotation.Graph.Color[aCnt] = Color.FromArgb(255, 255, 255, 255);
            aCnt++;

            Chart2DLine.PeAnnotation.Graph.X[aCnt] = Chart2DLine.PeData.X[0, nMinIndex];
            Chart2DLine.PeAnnotation.Graph.Y[aCnt] = Chart2DLine.PeData.Y[0, nMinIndex];
            Chart2DLine.PeAnnotation.Graph.Text[aCnt] = fMin.ToString();
            Chart2DLine.PeAnnotation.Graph.Type[aCnt] = (int)GraphAnnotationType.Pointer;
            Chart2DLine.PeAnnotation.Graph.Color[aCnt] = Color.FromArgb(255, 255, 255, 255);
            aCnt++;

            if (_bZoomed)
            {
                Chart2DLine.PeAnnotation.Graph.X[aCnt] = Chart2DLine.PeGrid.Configure.ManualMinX;
                Chart2DLine.PeAnnotation.Graph.Y[aCnt] = Chart3DSurface.PeGrid.Configure.ManualMinZ;
                Chart2DLine.PeAnnotation.Graph.Text[aCnt] = "";
                Chart2DLine.PeAnnotation.Graph.Type[aCnt] = (int)GraphAnnotationType.StartPoly;
                aCnt++;

                Chart2DLine.PeAnnotation.Graph.X[aCnt] = Chart2DLine.PeGrid.Configure.ManualMaxX;
                Chart2DLine.PeAnnotation.Graph.Y[aCnt] = Chart3DSurface.PeGrid.Configure.ManualMinZ;
                Chart2DLine.PeAnnotation.Graph.Text[aCnt] = "";
                Chart2DLine.PeAnnotation.Graph.Type[aCnt] = (int)GraphAnnotationType.AddPolyPoint;
                aCnt++;

                Chart2DLine.PeAnnotation.Graph.X[aCnt] = Chart2DLine.PeGrid.Configure.ManualMaxX;
                Chart2DLine.PeAnnotation.Graph.Y[aCnt] = Chart3DSurface.PeGrid.Configure.ManualMaxZ;
                Chart2DLine.PeAnnotation.Graph.Text[aCnt] = "";
                Chart2DLine.PeAnnotation.Graph.Type[aCnt] = (int)GraphAnnotationType.AddPolyPoint;
                aCnt++;

                Chart2DLine.PeAnnotation.Graph.X[aCnt] = Chart2DLine.PeGrid.Configure.ManualMinX;
                Chart2DLine.PeAnnotation.Graph.Y[aCnt] = Chart3DSurface.PeGrid.Configure.ManualMaxZ;
                Chart2DLine.PeAnnotation.Graph.Text[aCnt] = "";
                Chart2DLine.PeAnnotation.Graph.Type[aCnt] = (int)GraphAnnotationType.EndPolygon;  // index 5
                Chart2DLine.PeAnnotation.Graph.Color[aCnt] = Color.FromArgb(40, 255, 255, 255);
                aCnt++;

                Chart2DLine.PeAnnotation.Line.YAxis[0] = Chart3DSurface.PeGrid.Configure.ManualMinZ;
                Chart2DLine.PeAnnotation.Line.YAxisInFront[0] = AnnotationInFront.InFront;
                Chart2DLine.PeAnnotation.Line.YAxis[1] = Chart3DSurface.PeGrid.Configure.ManualMaxZ;
                Chart2DLine.PeAnnotation.Line.YAxisInFront[1] = AnnotationInFront.InFront;
            }
            else
            {
                Chart2DLine.PeAnnotation.Line.YAxisInFront[0] = AnnotationInFront.Hide;
                Chart2DLine.PeAnnotation.Line.YAxisInFront[1] = AnnotationInFront.Hide;
                Chart2DLine.PeAnnotation.Graph.Type[5] = (int)GraphAnnotationType.NoSymbol;
            }

            Chart2DLine.PeAnnotation.Line.YAxisShow = true;
            Chart2DLine.PeAnnotation.Graph.TextSize = 140;
            Chart2DLine.PeAnnotation.Graph.Show = true;
            Chart2DLine.PeAnnotation.Show = true;

            Chart2DContainer.Visible = true;   // WPF Visibility.Visible

            Chart2DLine.PeFunction.ReinitializeResetImage();
            Chart2DLine.Invalidate();
        }

        private void ShowLegend_CheckedChanged(object sender, EventArgs e)
        {
            if (ShowLegend.Checked)
            {
                Chart3DSurface.PeLegend.Location = LegendLocation.Bottom;
                Chart3DSurface.PeLegend.Show = true;
            }
            else
            {
                Chart3DSurface.PeLegend.Show = false;
            }
            Chart3DSurface.Invalidate();
        }

        private void ShowContour_CheckedChanged(object sender, EventArgs e)
        {
            if (BottomContour.Checked)
            {
                Chart3DSurface.PePlot.Option.ShowContour = ShowContour.BottomColors;
            }
            else
            {
                Chart3DSurface.PePlot.Option.ShowContour = ShowContour.None;
            }
            Chart3DSurface.Invalidate();
        }

        private void HotSpots_CheckedChanged(object sender, EventArgs e)
        {
            if (HotSpots.Checked)
            {
                // update the menu for the 3D chart to reflect the HotSpots check box UI control
                Chart3DSurface.PeUserInterface.Menu.CustomMenuState[CursorTrackingMenu3d, 0] = CustomMenuState.Checked;

                // any of these 3 will actually enable hotspot OctTree construction, so set all three
                Chart3DSurface.PeUserInterface.HotSpot.Data = true;
                Chart3DSurface.PeUserInterface.Cursor.PromptTracking = true;
                Chart3DSurface.PeUserInterface.Cursor.HighlightColor = Color.FromArgb(255, 255, 0, 0);

                Chart3DSurface.PeUserInterface.Cursor.PromptStyle = CursorPromptStyle.YValue;
                Chart3DSurface.PeUserInterface.Cursor.PromptLocation = CursorPromptLocation.ToolTip;
                Chart3DSurface.PeData.Precision = DataPrecision.TwoDecimals;
            }
            else
            {
                // update the menu for the 3D chart to reflect the HotSpots check box UI control
                Chart3DSurface.PeUserInterface.Menu.CustomMenuState[CursorTrackingMenu3d, 0] = CustomMenuState.UnChecked;

                // any of these 3 will actually enable hotspot OctTree construction, so reset all three
                Chart3DSurface.PeUserInterface.HotSpot.Data = false;
                Chart3DSurface.PeUserInterface.Cursor.PromptTracking = false;
                Chart3DSurface.PeUserInterface.Cursor.HighlightColor = Color.FromArgb(0, 0, 0, 0);

                Chart3DSurface.PeUserInterface.Cursor.PromptStyle = CursorPromptStyle.None;
            }

            Chart3DSurface.PeFunction.Force3dxVerticeRebuild = true;
            Chart3DSurface.PeFunction.ReinitializeResetImage();
            Chart3DSurface.Invalidate();
        }

        private void ReduceDataAmount_SelectionChanged(object sender, EventArgs e)
        {
            if (CurrentHeightMap == null) { return; }
            if (_updatingUi) { return; }

            _nDataStep = ReduceDataAmount.SelectedIndex + 1;   // indices 0123 equals "None","2X","3X","4X"

            // changing data for both 3D and 2D charts
            RefreshUi(CurrentHeightMap);

            if (_bShowingPlane)
            {
                float fRange = (float)(Chart3DSurface.PeGrid.Configure.ManualMaxX - Chart3DSurface.PeGrid.Configure.ManualMinX);
                double dPos = Chart3DSurface.PeGrid.Configure.ManualMinX + (fRange * (SliderXPlane.Value / 100.0F));
                MoveXPlane(dPos);
            }
        }

        private void Chart2DContour_OnPeZoomIn(object sender, EventArgs e)
        {
            // set the zoom state of the Pe3do 3D surface chart //
            _bZoomed = true;
            Chart3DSurface.PeUserInterface.Menu.CustomMenu[UndoZoomMenu3d, 0] = CustomMenu.Show;

            Chart3DSurface.PeGrid.Configure.DxPsManualCullXZ = true;

            Chart3DSurface.PeGrid.Configure.ManualScaleControlX = ManualScaleControl.MinMax;
            Chart3DSurface.PeGrid.Configure.ManualMinX = Chart2DContour.PeGrid.Zoom.MinX;
            Chart3DSurface.PeGrid.Configure.ManualMaxX = Chart2DContour.PeGrid.Zoom.MaxX;

            Chart3DSurface.PeGrid.Configure.ManualScaleControlZ = ManualScaleControl.MinMax;
            Chart3DSurface.PeGrid.Configure.ManualMinZ = Chart2DContour.PeGrid.Zoom.MinY;
            Chart3DSurface.PeGrid.Configure.ManualMaxZ = Chart2DContour.PeGrid.Zoom.MaxY;

            Chart3DSurface.PeFunction.Force3dxVerticeRebuild = true;
            Chart3DSurface.PeFunction.Force3dxAnnotVerticeRebuild = true;
            Chart3DSurface.PeData.SkipRanging = true;
            Chart3DSurface.PeFunction.Reinitialize();
            Chart3DSurface.Invalidate();

            float fRange = (float)(Chart3DSurface.PeGrid.Configure.ManualMaxX - Chart3DSurface.PeGrid.Configure.ManualMinX);
            double dPos = Chart3DSurface.PeGrid.Configure.ManualMinX + (fRange * SliderXPlane.Value / 100.0F);
            MoveXPlane(dPos);
        }

        private void Chart2DContour_OnPeZoomOut(object sender, EventArgs e)
        {
            // undo the zoom state of the Pe3do 3D surface chart //
            _bZoomed = false;
            Chart3DSurface.PeUserInterface.Menu.CustomMenu[UndoZoomMenu3d, 0] = CustomMenu.Grayed;

            Chart3DSurface.PeGrid.Configure.ManualScaleControlX = ManualScaleControl.None;
            Chart3DSurface.PeGrid.Configure.ManualScaleControlZ = ManualScaleControl.None;

            Chart3DSurface.PeFunction.Force3dxVerticeRebuild = true;
            Chart3DSurface.PeFunction.Force3dxAnnotVerticeRebuild = true;
            Chart3DSurface.PeData.SkipRanging = true;
            Chart3DSurface.PeFunction.Reinitialize();
            Chart3DSurface.Invalidate();

            float fRange = (float)(Chart3DSurface.PeGrid.Configure.ManualMaxX - Chart3DSurface.PeGrid.Configure.ManualMinX);
            double dPos = Chart3DSurface.PeGrid.Configure.ManualMinX + (fRange * SliderXPlane.Value / 100.0F);
            MoveXPlane(dPos);
        }

        private void Chart2DContour_PeVertScroll(object sender, Gigasoft.ProEssentials.EventArg.ScrollEventArgs e)
        {
            // update the 3D chart with the 2D Contour zoom parameters //
            Chart3DSurface.PeGrid.Configure.ManualScaleControlX = ManualScaleControl.MinMax;
            Chart3DSurface.PeGrid.Configure.ManualMinX = Chart2DContour.PeGrid.Zoom.MinX;
            Chart3DSurface.PeGrid.Configure.ManualMaxX = Chart2DContour.PeGrid.Zoom.MaxX;

            Chart3DSurface.PeGrid.Configure.ManualScaleControlZ = ManualScaleControl.MinMax;
            Chart3DSurface.PeGrid.Configure.ManualMinZ = Chart2DContour.PeGrid.Zoom.MinY;
            Chart3DSurface.PeGrid.Configure.ManualMaxZ = Chart2DContour.PeGrid.Zoom.MaxY;

            Chart3DSurface.PeFunction.Force3dxAnnotVerticeRebuild = true;
            Chart3DSurface.PeFunction.Force3dxVerticeRebuild = true;
            Chart3DSurface.PeData.SkipRanging = true;
            Chart3DSurface.PeFunction.Reinitialize();
            Chart3DSurface.Invalidate();
        }

        private void Chart2DContour_PeHorzScroll(object sender, Gigasoft.ProEssentials.EventArg.ScrollEventArgs e)
        {
            // update the 3D chart with the 2D Contour zoom parameters //
            Chart3DSurface.PeGrid.Configure.ManualScaleControlX = ManualScaleControl.MinMax;
            Chart3DSurface.PeGrid.Configure.ManualMinX = Chart2DContour.PeGrid.Zoom.MinX;
            Chart3DSurface.PeGrid.Configure.ManualMaxX = Chart2DContour.PeGrid.Zoom.MaxX;

            Chart3DSurface.PeGrid.Configure.ManualScaleControlZ = ManualScaleControl.MinMax;
            Chart3DSurface.PeGrid.Configure.ManualMinZ = Chart2DContour.PeGrid.Zoom.MinY;
            Chart3DSurface.PeGrid.Configure.ManualMaxZ = Chart2DContour.PeGrid.Zoom.MaxY;

            Chart3DSurface.PeFunction.Force3dxAnnotVerticeRebuild = true;
            Chart3DSurface.PeFunction.Force3dxVerticeRebuild = true;
            Chart3DSurface.PeData.SkipRanging = true;
            Chart3DSurface.PeFunction.Reinitialize();
            Chart3DSurface.Invalidate();
        }

        private void Main_SizeChanged(object sender, EventArgs e)
        {
            // WinForms repositions the docked/anchored charts automatically; we only
            // keep the floating 2D contour pinned to the bottom-left corner.
            // (WPF needed Chart2DContour.Chart.UpdateRelativeLocation(); not required here.)
            PositionContour();
        }

        private void SliderHorizontalMove_OnValueChanged(object sender, EventArgs e)
        {
            if (_updatingUi) { return; }
            Chart3DSurface.PePlot.Option.DxViewportX = (float)SliderHorizontalMove.Value;
            Chart3DSurface.Refresh();   // Pe3do needs explicit Refresh() on WinForms
        }

        private void SliderVerticalMove_OnValueChanged(object sender, EventArgs e)
        {
            if (_updatingUi) { return; }
            Chart3DSurface.PePlot.Option.DxViewportY = (float)SliderVerticalMove.Value;
            Chart3DSurface.Refresh();   // Pe3do needs explicit Refresh() on WinForms
        }

        private void HelpButton_Click(object sender, EventArgs e)
        {
            string hs = "3D Chart \n";
            hs += "1. Left button and drag to rotate.\n";
            hs += "2. Shift + Left button drag to translate surface.\n";
            hs += "3. Mouse Wheel zooms in and out entire scene.\n";
            hs += "4. Middle button and drag adjusts light location.\n";
            hs += "5. Right click shows popup menu.\n\n";
            hs += "2D Contour - Bottom Left \n";
            hs += "1. Left button and drag to zoom. Also zooms 3D Chart3DSurface.\n";
            hs += "2. Right click shows popup menu. \n";
            hs += "3. Right click UndoZoom to undo the 3D Chart's zoom. \n\n";
            hs += "Sliders allow manipulation similar to click and drag built in UI.\n\n";
            hs += "Explode Z Axis slider adjusts the aspect ratio of z axis to xy axes. This process requires the triangle data to be re-constructed and is gpu intensive.\n\n";
            hs += "Cursor Tracking enables cursor prompt tracking of mouse across 3D surface. This setting may reset itself based on various UI behaviors.\n";
            hs += "For large surfaces, the hit testing is accomplished cpu-side and is cpu-intensive to build the huge octree and then search the octree during mousemove events. \n\n";
            hs += "Reduce Data setting provides more responsive cursor tracking. Files are so large, reducing data may show little visual difference. \n\n";
            hs += "Reduce Data setting will help old computers without a dedicated GPU or improved integrated graphics.\n\n";
            hs += "Performance is dependent on the cpu/gpu. Old computers without a gpu (or poor integrated graphics) may struggle with this amount of data. Though Gigasoft plots this data faster than any other known Chart3DSurface. ";

            MessageBox.Show(hs);
        }
    }
}