WPF 3-D Scientific Charts:

← Back to WPF Chart Comparison

Scientific visualization frequently requires two views of the same data: a 3-D surface that shows topography, and a 2-D contour heatmap that shows exact value distribution. Most charting libraries treat these as completely separate chart types with separate data stores, separate rendering pipelines, and separate memory allocations. ProEssentials does something fundamentally different — it renders both views from the same GPU compute shader pipeline, reading the same data pointer, using zero additional memory.

This page compares 3-D and 2-D scientific charting capabilities across all five WPF libraries, walks through real production code from a material surface scanning application that demonstrates the shared-memory architecture, and details the chart types that only ProEssentials provides — including 4-D color-by-value surfaces, built-in Delaunay triangulation from point clouds, and custom polygon data for arbitrary 3-D geometry.

3-D and 2-D Scientific Chart Type Matrix

The table below compares every scientific chart type across all five WPF libraries. SciChart and LightningChart offer strong 3-D coverage at 12 of 13 types each, but neither provides Delaunay triangulation from point clouds. Syncfusion covers 7 types via its SfSurfaceChart and SfChart3D controls. DevExpress covers 5 via its Chart3DControl. ProEssentials is the only library that covers all thirteen chart types listed below — and the only one with GPU compute shader rendering across surfaces, contours, heatmaps, and real-time 3-D.

ProEssentials supports all 13 scientific chart types in this comparison. SciChart and LightningChart each cover 12, Syncfusion covers 7, and DevExpress covers 5. While all five libraries offer some 3-D surface charting, only ProEssentials provides built-in Delaunay triangulation from point clouds, and only ProEssentials renders surfaces, contours, heatmaps, and real-time 3-D through a unified GPU compute shader pipeline with zero-copy shared memory.

Real-World Code: Material Surface Scan Application

The following code excerpts are from the GigaPrime3D material surface scanning demo — a production-grade WPF application that renders high-resolution surface scan data (up to 6000 × 6000 grids, 36 million data points) as both a 3-D shaded surface and a 2-D contour heatmap simultaneously. This is not a simplified tutorial example. This is the code pattern used in industrial metrology, semiconductor wafer inspection, and terrain analysis applications. The three snippets below demonstrate the shared memory declaration, the dual zero-copy data loading with GPU compute shaders, and the linked zoom synchronization between 2-D and 3-D views.

Step 1: Shared Static Memory — One Array, Two Charts

The application allocates a single static float array (sMyYData) large enough for 36 million elevation values — the Y (height) data for the surface scan. The X and Z arrays hold the grid coordinates for columns and rows respectively. These three arrays are the only data storage in the entire application. No chart control will ever allocate its own copy.

// 36M points × 4 bytes = ~150 MB
// Passing shared app memory to both Pe3do and Pesgo saves ~150 MB
// Always best to save memory where we can
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 × cols max

// Pin smaller arrays (< 85 KB) so GC won't relocate them
private GCHandle _pinXHandle;
private GCHandle _pinZHandle;

public MainWindow()
{
    _pinXHandle = GCHandle.Alloc(sMyXData, GCHandleType.Pinned);
    _pinZHandle = GCHandle.Alloc(sMyZData, GCHandleType.Pinned);
    // ...
}

The smaller X and Z arrays (never moved by GC anyway — no pinning needed. This is a detail that matters in real production code: understanding .NET memory management at the level required for zero-copy charting.

Step 2: GPU Compute Shader + Zero-Copy for Both Views

When the user loads a new surface scan file, the RefreshUi method populates the shared arrays and then passes the same pointer to both chart controls. The critical lines are UseDataAtLocation() — which stores a pointer instead of copying — and ComputeShader = true — which activates GPU-side scene construction. Notice that the Pesgo 2-D contour chart uses the same ComputeShader property and the same UseDataAtLocation call pattern as the Pe3do 3-D surface:

// ─── 3-D Surface (Pe3do) ─── GPU compute shader + zero-copy ───
Chart3DSurface.PeData.Subsets = _rows;
Chart3DSurface.PeData.Points  = _cols;
Chart3DSurface.PeData.DuplicateDataX = DuplicateData.PointIncrement;
Chart3DSurface.PeData.DuplicateDataZ = DuplicateData.SubsetIncrement;
Chart3DSurface.PeData.ComputeShader  = true;  // GPU-side scene construction

// No data transfer — chart reads your array via pointer
Chart3DSurface.PeData.X.UseDataAtLocation(sMyXData, _cols);
Chart3DSurface.PeData.Y.UseDataAtLocation(sMyYData, size);
Chart3DSurface.PeData.Z.UseDataAtLocation(sMyZData, _rows);

// ─── 2-D Contour (Pesgo) ─── same GPU pipeline, same pointer ───
Chart2DContour.PeData.Subsets = _rows;
Chart2DContour.PeData.Points  = _cols;
Chart2DContour.PeData.DuplicateDataX = DuplicateData.PointIncrement;
Chart2DContour.PeData.DuplicateDataY = DuplicateData.SubsetIncrement;
Chart2DContour.PeData.ComputeShader  = true;  // same GPU path as 3-D

// Same shared memory — no copy, no duplication
Chart2DContour.PeData.X.UseDataAtLocation(sMyXData, _cols);
Chart2DContour.PeData.Z.UseDataAtLocation(sMyYData, size);
Chart2DContour.PeData.Y.UseDataAtLocation(sMyZData, _rows);

Chart2DContour.PePlot.Method = SGraphPlottingMethod.ContourColors;

Both charts now read from sMyXData, sMyYData, and sMyZData — the same static arrays. The 3-D surface and 2-D contour are two GPU-rendered views of identical data. Changing the source array and calling ReinitializeResetImage() on both controls updates both views instantly. Note the axis mapping difference: Pe3do uses Y as elevation and Z as depth, while Pesgo uses Z as the contour value and Y as the spatial axis. UseDataAtLocation handles the pointer indirection in both cases.

Step 3: Linked Zoom — 2-D Contour Drives 3-D Surface

The GigaPrime3D demo links the two views so zooming the 2-D contour automatically zooms the 3-D surface to the same region. When the user rubber-bands a zoom rectangle on the contour chart, the PeZoomIn event fires and the code reads the contour's zoom extents, applies them as manual axis ranges on the 3-D surface, and triggers an efficient rebuild:

// When user zooms the 2-D contour, sync the 3-D surface view
private void Chart2DContour_OnPeZoomIn(object sender, EventArgs e)
{
    // Enable pixel shader culling — only render triangles in view
    Chart3DSurface.PeGrid.Configure.DxPsManualCullXZ = true;

    // Transfer 2-D zoom extents → 3-D manual axis range
    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;

    // Efficient rebuild — skip ranging, rebuild only vertices
    Chart3DSurface.PeFunction.Force3dxVerticeRebuild = true;
    Chart3DSurface.PeData.SkipRanging = true;
    Chart3DSurface.PeFunction.Reinitialize();
    Chart3DSurface.Invalidate();
}

DxPsManualCullXZ is the key performance property here — it enables pixel shader culling so that triangles outside the zoom region are discarded by the GPU rather than rendered invisibly. Without it, zooming a 36-million-point surface would still process every triangle even though most are outside the view. SkipRanging tells the engine to skip the CPU-side min/max data scan (unnecessary because axis limits are set manually), and Reinitialize() rebuilds axis scales without clearing the cached image. The result: zooming a 6000 × 6000 surface feels instant.

Chart Type Deep Dives

ProEssentials' Pe3do chart object uses a two-level dispatch system: PolyMode selects the chart category (surface, bar, scatter, polygon data), and PlottingMethod selects the rendering variant within that category (wireframe, shaded, contoured, area). This design means one chart control handles all 3-D chart types — there is no need to swap between different chart components when changing visualization.

3-D Surface with Contour Overlay

The 3-D surface is ProEssentials' flagship 3-D chart type — and the one demonstrated in the GigaPrime3D code above. It takes an X × Z grid of Y-elevation values and renders a continuous mesh with configurable wireframe, shading, lighting, and contour color banding. Setting PlottingMethod to Four (Surface + Contour) overlays the contour color gradient directly onto the surface mesh.

The GigaPrime3D demo renders grids up to 6000 × 6000 (36 million vertices) with compute shaders, 256-band contour coloring, adjustable light positioning via SetLight(), and interactive mouse-drag rotation. DuplicateData optimization (DuplicateDataX = PointIncrement, DuplicateDataZ = SubsetIncrement) avoids passing redundant grid coordinates — only one row of X values and one column of Z values are needed for a uniform grid.

Multiple light sources can be positioned in 3-D space, and the pixel shader culling (DxPsManualCullXZ) demonstrated in the zoom code ensures that zoomed views only process visible triangles. GridAspect properties control the X:Y:Z axis proportions — the demo dynamically calculates aspect ratios from the physical dimensions of the scanned material sample.

2-D Contour and Heatmap (GPU Compute Shader)

ProEssentials' 2-D contour rendering uses the same GPU compute shader pipeline as 3-D surfaces — as demonstrated in the GigaPrime3D code where both charts set ComputeShader = true. The Pesgo chart object renders contour-colored fills (heatmaps), contour lines, or both from an X × Y grid of Z-elevation values.

The GigaPrime3D demo uses manual SubsetColors with 256 bands to define a precise blue-cyan-green-yellow-red gradient for the contour visualization — the same color map applied to both the 3-D surface and the 2-D contour. Contour coloring also supports predefined ContourColorSet palettes and custom ContourColors arrays with interpolation via ContourColorBlends.

SciChart offers heatmap rendering but not contour lines. LightningChart supports contour lines and fills. Syncfusion offers surface-based contour and wireframe contour rendering via SfSurfaceChart. DevExpress provides a separate Heatmap control but no contour line rendering. ProEssentials, LightningChart, and Syncfusion all offer contour line rendering — but only ProEssentials does it on the GPU compute shader with zero-copy data access from a shared pointer.

3-D Waterfall with Contour-Colored Slices

Waterfall charts visualize frequency spectrum data, vibration analysis, and any time-evolving signal where each slice represents a measurement at a different time or position. ProEssentials renders waterfalls using PolyMode.Scatter with PlottingMethod.Area, which draws each subset as a filled area slice in 3-D space. Contour coloring is applied per-slice via WaterfallContours, producing color-banded slices that match the elevation values.

Waterfall borders, contour color blends, and per-subset line types give fine control over the visual appearance. SciChart and LightningChart both offer waterfall charts, but neither competitor provides the contour-colored slice rendering that ProEssentials does natively.

4-D, Delaunay, and Custom Polygon Data

ProEssentials supports three advanced chart types that set it apart from every competitor. The 4-D W-data system (PeData.W) adds an independent fourth data dimension that controls surface contour coloring separately from the Y-axis elevation — SciChart and LightningChart offer similar capabilities, but ProEssentials renders it through the same GPU compute shader pipeline used for surfaces and contours. Built-in Delaunay triangulation is unique to ProEssentials — no other WPF charting library offers it. See Example 415.

Built-in Delaunay triangulation (PePlot.Option.Delaunay3D = true) converts an unstructured point cloud into a triangulated surface automatically. Feed the engine a flat list of XYZ points — no pre-gridding required — and it triangulates the XZ plane using Y as height, producing a proper surface mesh with contour coloring. No other WPF charting library offers built-in Delaunay. See Example 414.

Custom polygon data (PolyMode.PolygonData) enables arbitrary 3-D geometry by defining raw vertex positions and per-polygon colors. This is used for custom 3-D shapes — spheres, imported objects, engineering models — rendered within the same Pe3do chart control. Graph annotations also support polygon data for placing 3-D shape annotations in data space. See Example 406 (sphere) and Example 416 (complex annotation shapes).

3-D Camera, Rotation, and Zoom Interaction

The GigaPrime3D demo demonstrates ProEssentials' full 3-D interaction model: smooth mouse-drag rotation, mouse-wheel zoom with configurable smoothness, shift-drag viewport panning, middle-button light positioning, and touch pinch-zoom — all with adjustable smoothness parameters.

Camera control includes ViewingHeight (elevation angle 0–36), DegreeOfRotation (0–359), DxZoom with configurable min/max limits, and DxFOV for controlling perspective projection. The demo exposes these as sliders alongside the chart, giving users precise control over viewing angle, zoom distance, vertical and horizontal offset, and Z-axis exaggeration — all updating the 3-D view in real time via on-demand rendering.

DegreePrompting displays the current rotation angle, zoom distance, and light location on screen during interaction. Combined with on-demand rendering (GPU renders only during active interaction, stops when the user releases), this provides responsive interaction with zero idle power draw — a critical advantage over game-engine loops for laptop and kiosk deployments.

Contour Color Systems: Three Approaches

The GigaPrime3D demo uses manual SubsetColors with 256 bands — iterating through a custom blue-to-red gradient array and assigning each color to a SubsetColors entry. This gives pixel-level control over the contour color ramp and ensures the 3-D surface and 2-D contour use identical coloring.

For quicker setup, predefined ContourColorSet enums (BlueCyanGreenYellowBrownWhite, Grayscale, and others) provide instant palettes with configurable ContourColorBlends for smooth interpolation. Custom ContourColors arrays allow defining exact color stops at specific gradient positions.

The anchor-point interpolation technique — defining anchor colors at value thresholds and computing linear RGB interpolation between them — produces publication-quality color ramps with precise control at critical data boundaries. After setting SubsetColors in Direct3D mode, Force3dxNewColors and Force3dxVerticeRebuild ensure the GPU updates both the color map and the geometry.

The Bottom Line on 3-D and 2-D Scientific Charting

The GigaPrime3D material surface scan demo proves these capabilities with real production code — not marketing claims. 36 million data points, one shared array, two GPU-rendered views, 150 MB saved, linked zoom with pixel shader culling, and industrial-grade interaction. ProEssentials covers all 13 chart types in this comparison — including Delaunay triangulation from point clouds that no competitor offers. Both 3-D surfaces and 2-D contours render through the same unified GPU compute shader pipeline.

SciChart and LightningChart are strong 3-D competitors, each covering 12 of 13 chart types. Syncfusion covers 7 with surface, wireframe, contour, scatter, bar, heatmap, and contour-line support. DevExpress covers 5. But none of these competitors offer shared data pointers between chart views, unified compute shader rendering across 2-D and 3-D, or built-in Delaunay triangulation from point clouds. For scientific, engineering, geospatial, medical imaging, metrology, and semiconductor visualization, ProEssentials' 3-D and 2-D capabilities remain the most comprehensive in the WPF charting market.

Performance & Architecture

How GPU compute shaders and on-demand rendering deliver speed without continuous power draw.

Pricing & Support

Perpetual licensing, free unlimited support, and 5-year TCO compared across all five libraries.

Platform Coverage

WPF, WinForms, C++ MFC, Delphi VCL, and ActiveX — one charting engine for every Windows stack.