WPF에서 1억 포인트 그리기

WPF 라인 차트에서 1억 데이터 포인트를 어떻게 표시합니까? 답은 전적으로 어떤 차트 라이브러리를 사용하느냐에 달려 있습니다. 일부는 15줄의 코드로 메모리 오버헤드 없이 처리합니다. 일부는 특수 시리즈 유형이 필요하며 데이터 충실도를 희생합니다. 일부는 단순히 전혀 할 수 없습니다.

이 글은 5개 주요 WPF 차트 라이브러리 — ProEssentials, SciChart, LightningChart, Syncfusion, DevExpress — 모두에 대해 동일한 1억 float 값을 단일 시리즈 라인 차트로 그리는 완전하고 작동하는 C# 코드를 제공합니다. 코드 줄 수, 메모리 소비, 렌더 시간, 데이터 충실도, 각 라이브러리가 실제로 데이터에 무엇을 하는지 등 모든 측면을 비교합니다.

"WPF 수백만 포인트 그리기" 또는 "WPF 차트 성능"을 검색했다면, 이것이 구체적인 코드 수준의 답입니다.

직접 사용해 보세요: ProEssentials 설치에는 GigaPrime2D라는 데모가 포함되어 있습니다(전체 예제 프로젝트 소스 코드 포함). 이 데모는 1억 개의 포인트를 지속적으로 플롯하며 — 매 업데이트마다 모든 1억 개의 값을 변경합니다. 코드는 의도적으로 최소화되어 있어 경쟁 라이브러리를 쉽게 연결하고 1억 포인트에서의 실질적인 나란히 비교를 구축할 수 있습니다.

테스트: 1억 Float 값

모든 라이브러리가 동일한 테스트를 받습니다: 랜덤 노이즈가 있는 사인파를 나타내는 1억 개의 순차적 float 값에서 단일 시리즈 라인 차트를 렌더링합니다 — 센서 데이터, 신호 처리, 과학적 수집의 전형적인 패턴입니다. 질문은 차트가 예쁜지가 아니라 — 라이브러리가 데이터를 처리할 수 있는지, 그리고 메모리, 시간, 충실도에서 얼마의 비용이 드는지입니다.

아래에서 각 라이브러리의 완전한 C# 코드를 제공하며, 각 단계에서 데이터에 무슨 일이 일어나는지 주석을 달았습니다. 두 가지에 주목하세요: 라이브러리가 데이터를 어떻게 수신하는지(복사 vs 포인터), 그리고 어떻게 렌더링하는지(모든 포인트 vs 리샘플링된 서브셋).

라이브러리 1: ProEssentials — 제로 카피 + GPU Compute Shader

ProEssentials는 UseDataAtLocation()을 사용하여 차트를 기존 float 배열에 직접 연결합니다. 복사 없음, 변환 없음, 중복 없음. 차트의 네이티브 DLL이 메모리에 대한 포인터를 저장하고 렌더링 중에 읽습니다. ComputeShader = true와 결합하면 GPU의 Compute Shader가 잠재적으로 2,000개 이상의 셰이더 코어를 사용하여 차트 이미지를 구성합니다 — CPU는 1억 값을 반복하지 않습니다.

// ProEssentials — Plot 100 Million Points (WPF, ~15 lines)
// NuGet: Install-Package Gigasoft.ProEssentials

// 1. Allocate your data — this is the ONLY copy that will ever exist
float[] yData = new float[100_000_000];
for (int i = 0; i < yData.Length; i++)
    yData[i] = (float)Math.Sin(i * 0.0001) + (float)(rand.NextDouble() * 0.1);

// 2. Configure the chart
Pesgo1.PeData.Subsets = 1;
Pesgo1.PeData.Points = 100_000_000;
Pesgo1.PePlot.Method = SGraphPlottingMethod.Line;
Pesgo1.PeConfigure.RenderEngine = RenderEngine.Direct3D;
Pesgo1.PeData.ComputeShader = true;
Pesgo1.PeData.Filter2D3D = true;  // GPU pre-filter shader — lossless min/max

// 3. Zero-copy: point the chart at your existing array — no duplication
Pesgo1.PeData.Y.UseDataAtLocation(yData, yData.Length);

// 4. Tell the Direct3D engine to rebuild vertices and colors
Pesgo1.PeFunction.Force3dxVerticeRebuild = true;
Pesgo1.PeFunction.Force3dxNewColors = true;

// 5. Render
Pesgo1.PeFunction.ReinitializeResetImage();

핵심 코드는 UseDataAtLocation(yData, yData.Length)입니다. 이것은 복사 작업이 아니라 포인터 할당입니다. 차트는 배열을 그 자리에서 읽습니다. Filter2D3D = true를 사용하면 ProEssentials는 최종 렌더링 셰이더가 실행되기 전에 무손실 min/max 필터링을 수행하는 예비 GPU Compute Shader를 렌더링 파이프라인에 삽입합니다. SciChart와 DevExpress가 사용하는 공격적인 뷰포트 너비 리샘플링 — 1억 포인트를 수천 개로 줄일 수 있는 — 과 달리 ProEssentials의 필터는 의도적으로 보수적입니다: 시리즈는 필터링 후 항상 최소 500,000 포인트를 유지합니다. 필터링 셰이더와 렌더링 셰이더 모두 GPU에서 마이크로초 단위로 실행되므로 필요 이상으로 데이터를 버릴 이유가 없기 때문입니다. 결과는 신호의 모든 피크, 골짜기, 과도 현상을 보존하는 무손실 표현입니다.

Force3dxVerticeRebuild와 Force3dxNewColors 플래그는 Direct3D 엔진에 소스 배열에서 정점 및 색상 데이터를 재구성하도록 지시합니다. 나중에 yData의 값을 수정하고 ReinitializeResetImage()를 호출하기 전에 이 플래그를 다시 설정하면 차트가 동일한 메모리를 읽고 있으므로 변경 사항이 즉시 반영됩니다. 전체 설정은 15줄입니다. 특수 시리즈 유형 없음 — 100 포인트를 처리하는 동일한 Pesgo(Scientific Graph Object)가 1억을 처리합니다. ProEssentials 자체 예제 115는 5개 시리즈에 걸쳐 2,000만 포인트(총 1억)를 그리며 대화형 속도로 렌더링합니다 — Compute Shader 파이프라인에게 시리즈당 2,000만은 아무것도 아닙니다.

라이브러리 2: SciChart — 배열 복사 + 리샘플링

SciChart는 1억 포인트를 표시할 수 있지만, 두 가지 중요한 절충이 수반됩니다. 첫째, dataSeries.Append()가 1억 값 모두를 SciChart의 내부 저장소에 double[]로 복사합니다 — float(4바이트)에서 double(8바이트)로 메모리를 두 배로 늘립니다. 둘째, SciChart의 렌더링 파이프라인이 데이터를 뷰포트 너비의 약 2배(1920픽셀 디스플레이에서 약 3,840 포인트)로 다운샘플링합니다.

// SciChart — Plot 100 Million Points (WPF)
// NuGet: Install-Package SciChart, SciChart.Wpf

// 1. Allocate your data
double[] yData = new double[100_000_000];  // Note: SciChart uses double[], not float[]
double[] xData = new double[100_000_000];
for (int i = 0; i < yData.Length; i++) {
    xData[i] = i;
    yData[i] = Math.Sin(i * 0.0001) + rand.NextDouble() * 0.1;
}

// 2. Create data series — copies all 100M values into internal storage
var dataSeries = new XyDataSeries<double, double>();
dataSeries.Append(xData, yData);  // ~800 MB internal copy (float→double + overhead)

// 3. Configure resampling — without this, 100M points will not render
var lineSeries = new FastLineRenderableSeries();
lineSeries.DataSeries = dataSeries;
lineSeries.ResamplingMode = ResamplingMode.Auto;  // downsamples to ~2×viewport width

// 4. Add to chart surface
sciChartSurface.RenderableSeries.Add(lineSeries);

ResamplingMode.Auto 설정이 SciChart에서 1억 포인트를 실현 가능하게 만드는 것입니다. 이것 없이는 GPU 파이프라인이 1억 데이터 포인트의 정점 버퍼를 처리해야 합니다 — SciChart의 게임 엔진 아키텍처가 작동하는 방식이 아닙니다. 대신 CPU 측 리샘플러가 대표 서브셋(픽셀 빈당 min/max 사용)을 선택하고 해당 서브셋만 렌더링을 위해 GPU로 전송됩니다.

이는 SciChart가 1억 중 약 3,840 포인트를 렌더링함을 의미합니다 — 데이터의 약 0.004%. 전체 축소 시 시각적 개요로는 종종 허용 가능합니다. 그러나 10시간 녹음의 1초 창으로 확대하면 리샘플러가 CPU에서 관련 범위를 다시 스캔하여 새로운 대표 서브셋을 생성합니다. 원래 1억 값은 SciChart의 내부 double[] 배열에 ~800MB를 소비하며 필요에 따라 리샘플링되기를 기다립니다.

라이브러리 3: LightningChart — 배열 복사 + 특수 시리즈

LightningChart는 1억 포인트를 처리할 수 있지만, SampleDataSeries를 통해서만 가능합니다 — 고정 간격(균일 샘플링) 데이터를 위해 특별히 설계된 특수 시리즈 유형입니다. 표준 시리즈 유형(PointLineSeries, FreeformPointLineSeries)은 이 규모를 처리할 수 없습니다. 데이터는 AddSamples(float[]) 메서드를 통해 내부 버퍼로 복사되며, LightningChart의 DirectX 즉시 모드 렌더러가 이를 처리합니다. 최신 변형인 SampleDataBlockSeries(v10.1+)는 스트리밍/스위핑 시나리오에서 더 나은 성능을 제공합니다.

// LightningChart — Plot 100 Million Points (WPF)
// NuGet: Install-Package Arction.LightningChart.Ultimate

// 1. Allocate your data
float[] yData = new float[100_000_000];
for (int i = 0; i < yData.Length; i++)
    yData[i] = (float)Math.Sin(i * 0.0001) + (float)(rand.NextDouble() * 0.1);

// 2. Configure chart for large data — must use Non-Bindable edition for best performance
lightningChart.BeginUpdate();
lightningChart.ViewXY.XAxes[0].SetRange(0, 100_000_000);

// 3. Create SampleDataSeries (fixed-interval data) — standard PointLineSeries can't scale
var series = new SampleDataSeries(lightningChart.ViewXY, lightningChart.ViewXY.XAxes[0],
    lightningChart.ViewXY.YAxes[0]);
series.FirstSampleTimeStamp = 0;
series.SamplingFrequency = 1;  // 1 sample per X unit (sequential)

// 4. Add all 100M samples — copies float[] into internal buffer
series.AddSamples(yData, false);

// 5. Add series to chart
lightningChart.ViewXY.SampleDataSeries.Add(series);
lightningChart.EndUpdate();

// Note: SampleDataBlockSeries (v10.1+) is the newer, faster alternative
//       for streaming/sweeping data. Both require Non-Bindable edition
//       for best performance — MVVM data binding is limited.

중요한 제한: 최상의 성능을 위해 LightningChart는 Non-Bindable 에디션이 필요합니다. LightningChart의 WPF 제품은 Bindable과 Non-Bindable 에디션으로 제공됩니다 — Non-Bindable 에디션이 더 빠르고 멀티스레딩을 지원하지만 WPF의 MVVM 데이터 바인딩 인프라를 포기합니다. 애플리케이션이 WPF의 데이터 바인딩 패턴을 사용한다면(대부분의 현대 WPF 앱처럼) 성능과 아키텍처 호환성 사이의 절충에 직면합니다.

LightningChart는 DirectX 파이프라인을 통해 1억 포인트 모두를 무손실로 렌더링합니다. 절충은 배열 복사(~400MB 추가 메모리), 필수 특수 시리즈 유형, Non-Bindable 에디션 권장, 차트가 유휴 상태일 때도 GPU를 활성 상태로 유지하는 LightningChart의 연속 렌더링 루프입니다.

라이브러리 4: Syncfusion — 객체별 포인트 아키텍처

Syncfusion의 WPF 차트는 객체별 포인트 데이터 모델을 사용합니다. 각 데이터 값은 클래스 인스턴스(일반적으로 X, Y 속성 포함)에 래핑되어 IEnumerable 컬렉션에 추가되어야 합니다. 1억 포인트에서 이는 1억 개의 .NET 객체 생성을 의미합니다 — 각각 24바이트 객체 헤더(64비트), 두 개의 double 속성(16바이트), 패딩 포함. 합계: 원래 400MB 소스 데이터 위에 약 2.4GB의 관리 힙 할당.

// Syncfusion — Plot 100 Million Points (WPF)
// NuGet: Install-Package Syncfusion.SfChart.WPF

// 1. Create data model class — Syncfusion requires object-per-point
public class DataPoint {
    public double X { get; set; }
    public double Y { get; set; }
}

// 2. Allocate 100 million objects (~2.4 GB+ with object headers)
var data = new ObservableCollection<DataPoint>();
for (int i = 0; i < 100_000_000; i++)
    data.Add(new DataPoint {
        X = i,
        Y = Math.Sin(i * 0.0001) + rand.NextDouble() * 0.1
    });
// ⚠ This loop alone takes minutes and will likely trigger OutOfMemoryException
//    Syncfusion's practical ceiling is ~1 million points

// 3. Use FastLineBitmapSeries for best performance
var series = new FastLineBitmapSeries();
series.ItemsSource = data;
series.XBindingPath = "X";
series.YBindingPath = "Y";
chart.Series.Add(series);

실제로 이 할당 루프는 수 분이 걸리며, 특히 32비트 프로세스나 메모리가 제한된 시스템에서는 완료 전에 일반적으로 OutOfMemoryException이 발생합니다. Syncfusion의 반응형 차트를 위한 실질적 상한은 FastLineBitmapSeries를 사용하여 약 100만 포인트입니다. 이 라이브러리는 적당한 데이터 볼륨의 비즈니스 대시보드에 적합하지만, 1억 포인트 과학/엔지니어링 시나리오를 위해 설계되지 않았습니다.

라이브러리 5: DevExpress — 객체별 포인트 + 리샘플링

DevExpress WPF는 대규모 데이터 처리를 위해 LineSeries2D와 AllowResample = true를 사용합니다. 참고: 성능 논의에서 자주 참조되는 DevExpress의 SwiftPlotSeriesView는 WinForms 전용이며 WPF 차트 컨트롤에는 존재하지 않습니다. WPF에서 AllowResample(v20.1에서 도입)은 렌더링을 가시 범위로 제한하는 뷰포트 인식 리샘플링을 활성화합니다. DevExpress의 자체 블로그 게시물은 이 접근 방식을 5,000만 포인트까지 테스트했습니다. 그러나 데이터 모델은 여전히 객체별 포인트입니다 — 1억에서는 렌더링이 시작되기 전에 ~2.4GB의 DataPoint 객체를 할당해야 합니다.

// DevExpress — Plot 100 Million Points (WPF)
// NuGet: Install-Package DevExpress.Wpf.Charts

// 1. Create data model — DevExpress WPF requires object-per-point
public class DataPoint {
    public double Argument { get; set; }
    public double Value { get; set; }
}

// 2. Allocate 100 million objects (~2.4 GB+ with object headers)
var data = new List<DataPoint>(100_000_000);
for (int i = 0; i < 100_000_000; i++)
    data.Add(new DataPoint {
        Argument = i,
        Value = Math.Sin(i * 0.0001) + rand.NextDouble() * 0.1
    });
// ⚠ Minutes of allocation, ~2.4 GB managed heap
//    DevExpress tested AllowResample up to 50M (v20.1 blog post)

// 3. Use LineSeries2D with AllowResample (resamples to viewport)
var series = new LineSeries2D();
series.DataSource = data;
series.ArgumentDataMember = "Argument";
series.ValueDataMember = "Value";
series.AllowResample = true;   // critical — resamples to viewport width
series.MarkerVisible = false;  // required for large-data performance
series.LineStyle.Thickness = 1;

// 4. Add to XYDiagram2D
var diagram = (XYDiagram2D)chartControl.Diagram;
diagram.Series.Add(series);

// Note: SwiftPlotSeriesView is WinForms-only — NOT available in WPF.
//       WPF uses LineSeries2D + AllowResample for large data.

1억 포인트에서 1억 개의 .NET 객체 생성은 충분한 RAM이 있는 64비트 시스템에서 경계선적으로 가능합니다(소스 데이터 포함 총 ~2.8GB). 할당이 성공하면 AllowResample이 뷰포트 서브셋만 렌더링합니다 — SciChart의 리샘플링 접근 방식과 유사합니다. 그러나 SciChart(원시 double을 평면 배열에 저장)와 달리 DevExpress는 24바이트 헤더가 있는 래핑된 객체를 저장하여 포인트당 메모리 비용이 약 6배 높습니다. DevExpress의 테스트된 상한은 5,000만입니다. 1억은 발표된 벤치마크에서 테스트되지 않은 영역입니다.

리샘플링의 대가

SciChart와 DevExpress 모두 실용적인 엔지니어링 절충으로 리샘플링을 사용합니다: 전체를 렌더링하는 대신 대표적인 데이터 서브셋을 표시합니다. 1920픽셀 너비의 차트에는 최대 1,920개의 수평 픽셀 열이 있습니다. 1억 포인트를 1,920열에 렌더링하면 ~52,083 포인트가 각 픽셀을 경쟁합니다. SciChart의 리샘플러는 빈당 min, max 값을 선택하여 약 3,840개의 대표 포인트를 생성합니다 — 데이터의 시각적 엔벨로프를 보존하기에 충분합니다. DevExpress의 AllowResample도 유사한 뷰포트 제한 접근 방식을 사용합니다.

개요 디스플레이("전체 데이터셋을 보여줘")에서는 종종 무손실 렌더링과 시각적으로 구별할 수 없습니다. 문제는 정밀도가 중요할 때 나타납니다: 과학 데이터의 이상 감지, 신호 처리의 정확한 피크 식별, 또는 모든 샘플이 검증 가능해야 하는 의료/제약 기록의 규제 준수. 포인트 47,291,033에서 1샘플 과도 현상이 발생했다면, 52,083 포인트를 픽셀 열당 2개의 대표로 줄이는 리샘플러가 해당 특정 포인트를 선택할 수도 있고 아닐 수도 있습니다.

ProEssentials는 Filter2D3D GPU Compute Shader로 근본적으로 다른 접근 방식을 취합니다. 1억 포인트를 화면 너비 대표 소수로 공격적으로 줄이는 대신, Filter2D3D 셰이더는 GPU에서 보수적이고 무손실인 min/max 사전 필터 패스를 수행하며 — 결과는 항상 최소 500,000 포인트를 유지합니다. 논리는 간단합니다: 필터링 셰이더와 최종 렌더링 셰이더 모두 GPU에서 마이크로초 단위로 실행되므로 데이터 폐기에 공격적일 이유가 없습니다. 필터는 각 필터링 윈도우 내의 모든 min과 max를 보존하므로 과도 현상, 스파이크, 이상은 절대 폐기되지 않습니다. 근본적으로 무손실입니다 — 렌더링된 이미지는 전체 데이터셋에서 생성된 것과 동일합니다. LightningChart도 DirectX 파이프라인을 통해 무손실로 렌더링하지만 배열 복사(~400MB 오버헤드)와 연속 렌더링 루프가 필요합니다. ProEssentials는 제로 메모리 오버헤드와 온디맨드 렌더링으로 동일한 무손실 결과를 달성합니다.

1억 포인트 그리기의 비용

4개 라이브러리가 1억 포인트 렌더링을 시도할 수 있지만, 해당 규모에서 테스트된 것은 3개뿐입니다. 각각의 비용입니다 — 라이선스 모델을 포함하여, 1억 포인트를 처리할 수 있지만 5년간 $288,750이 드는 라이브러리와 한 번 $11,999인 라이브러리는 다른 제안이기 때문입니다:

ProEssentials는 제로 카피 데이터 로딩, 무손실 GPU Compute Shader 필터링, 온디맨드 프레임 모델, 영구 라이선스, 무료 무제한 지원을 결합하는 유일한 라이브러리입니다 — 데이터셋을 처리할 수 있는 다른 라이브러리의 구독 비용의 일부입니다.

결론

4개 라이브러리가 WPF에서 1억 포인트를 시도할 수 있습니다. ProEssentials만이 제로 메모리 오버헤드, 무손실 GPU 필터링, 온디맨드 렌더링으로 — 15줄의 코드로 해냅니다. SciChart는 리샘플링으로 규모를 처리합니다(빠르지만 손실 있음). LightningChart는 특수 시리즈 유형으로 처리합니다(무손실이지만 배열 복사, Non-Bindable 에디션, 연속 GPU 필요). DevExpress는 AllowResample로 시도할 수 있습니다(리샘플링이지만 2.4GB 객체 오버헤드 — 자체 벤치마크에서 5,000만 이상 미테스트).

Syncfusion은 이 시나리오를 위해 설계되지 않았습니다. 객체별 포인트 아키텍처가 1억 훨씬 아래에서 메모리 한계에 도달하며, 자체 포럼에서 1,600만 포인트에서 메모리 부족 충돌이 문서화되어 있습니다. DevExpress도 동일한 객체별 포인트 병목이 있지만 뷰포트 리샘플링으로 부분적으로 완화합니다 — 초기 할당이 성공하는 경우. 두 라이브러리 모두 100만 포인트 미만의 데이터셋을 가진 비즈니스 대시보드에서 뛰어나며, 전용 차트 라이브러리가 제공하지 않는 광범위한 UI 컨트롤 제품군의 가치를 제공합니다.

애플리케이션이 1억 포인트를 표시해야 한다면 — 센서 데이터, 신호 처리, 과학적 수집, 산업 모니터링 — 위의 코드가 각 라이브러리에 정확히 무엇이 필요한지 보여줍니다. 복사하고, 실행하고, 측정하세요. 숫자가 스스로 말합니다.

GPU 아키텍처 심층 분석

Compute Shader, 온디맨드 렌더링, 제로 카피 데이터 로딩이 내부에서 어떻게 작동하는지.

AI 코드 지원

pe_query.py가 컴파일된 DLL 바이너리에 대해 모든 속성 경로를 검증합니다 — 환각된 API 호출 없음.

가격 및 지원 비교

5개 라이브러리 모두의 10명 개발자 5년 TCO. 영구 vs 구독 라이선스.

출처 및 참고 문헌

이 글의 모든 경쟁사 코드 예제는 공식 문서, 공개 GitHub 저장소, 공급업체 포럼 게시물에서 구성되었습니다. API 이름, 메서드 시그니처, 아키텍처 주장은 아래 나열된 출처에 대해 검증되었습니다. 링크는 2026년 2월 기준입니다.