fix: WithCreate receives denormalized doubles; replace sample wrapper classes with direct PolylineEncoder/Decoder usage

Agent-Logs-Url: https://github.com/petesramek/polyline-algorithm-csharp/sessions/76e69a37-a3c2-450f-8078-46133933fc61

Co-authored-by: petesramek <2333452+petesramek@users.noreply.github.com>

Author: Copilot

benchmarks/PolylineAlgorithm.Benchmarks/PolylineDecoderBenchmark.cs

@@ -57,7 +57,7 @@ public class PolylineDecoderBenchmark {
         FormatterBuilder<(double Latitude, double Longitude), T>.Create()
             .AddValue("lat", static c => c.Latitude)
             .AddValue("lon", static c => c.Longitude)
-            .WithCreate(static v => (v[0] / 1e5, v[1] / 1e5))
+            .WithCreate(static v => (v[0], v[1]))
             .ForPolyline(write, read)
             .Build();
 

samples/PolylineAlgorithm.NetTopologySuite.Sample/NetTopologyPolylineDecoder.cs

@@ -4,10 +4,27 @@
 //
 
 using NetTopologySuite.Geometries;
-using PolylineAlgorithm.NetTopologySuite.Sample;
+using PolylineAlgorithm;
 
 public class Program {
     public static void Main(string[] args) {
+        // Build a formatter for NetTopologySuite's Point type.
+        // NTS convention: Y = latitude, X = longitude.
+        PolylineFormatter<Point, string> formatter =
+            FormatterBuilder<Point, string>.Create()
+                .AddValue("lat", static p => p.Y)
+                .AddValue("lon", static p => p.X)
+                // The formatter automatically denormalizes scaled values, so v[0] = latitude, v[1] = longitude.
+                .WithCreate(static v => new Point(x: v[1], y: v[0]))
+                .ForPolyline(
+                    static m => m.IsEmpty ? string.Empty : new string(m.Span),
+                    static s => s.AsMemory())
+                .Build();
+
+        PolylineOptions<Point, string> options = new(formatter);
+        PolylineEncoder<Point, string> encoder = new(options);
+        PolylineDecoder<string, Point> decoder = new(options);
+
         // Sample route: Seattle → Bellevue → Redmond
         var points = new Point[]
         {
@@ -16,9 +33,6 @@ public static void Main(string[] args) {
             new(x: -122.1215, y: 47.6740),  // Redmond
         };
 
-        var encoder = new NetTopologyPolylineEncoder();
-        var decoder = new NetTopologyPolylineDecoder();
-
         // Encode
         string encoded = encoder.Encode(points);
 

samples/PolylineAlgorithm.NetTopologySuite.Sample/NetTopologyPolylineEncoder.cs

@@ -3,10 +3,34 @@
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 //
 
+using PolylineAlgorithm;
 using PolylineAlgorithm.SensorData.Sample;
+using System;
 
 public static class Program {
+    // 2020-01-01 00:00:00 UTC in Unix seconds. Used as the delta-encoding baseline for timestamps
+    // so that the first absolute delta stays within the int32 safe range of the polyline algorithm.
+    private const long TimestampBaseEpoch = 1_577_836_800L;
+
     public static void Main(string[] args) {
+        // Build a formatter for SensorReading: timestamp (Unix seconds, precision 0) + temperature.
+        // SetBaseline keeps the first timestamp delta small; the formatter adds it back when decoding.
+        PolylineFormatter<SensorReading, string> formatter =
+            FormatterBuilder<SensorReading, string>.Create()
+                .AddValue("timestamp", static r => (double)r.Timestamp.ToUnixTimeSeconds(), precision: 0)
+                .SetBaseline(TimestampBaseEpoch)
+                .AddValue("temperature", static r => r.Temperature, precision: 5)
+                // The formatter automatically denormalizes: v[0] = Unix seconds, v[1] = temperature.
+                .WithCreate(static v => new SensorReading(
+                    DateTimeOffset.FromUnixTimeSeconds((long)v[0]),
+                    v[1]))
+                .ForPolyline(static m => new string(m.Span), static s => s.AsMemory())
+                .Build();
+
+        PolylineOptions<SensorReading, string> options = new(formatter);
+        PolylineEncoder<SensorReading, string> encoder = new(options);
+        PolylineDecoder<string, SensorReading> decoder = new(options);
+
         // Sample temperature readings from a sensor over six seconds
         var readings = new SensorReading[]
         {
@@ -19,9 +43,6 @@ public static void Main(string[] args) {
             new(DateTimeOffset.UtcNow.AddSeconds(6),  22.3),
         };
 
-        var encoder = new SensorDataEncoder();
-        var decoder = new SensorDataDecoder();
-
         // Encode
         string encoded = encoder.Encode(readings);