public class ChartViewModel : BindableObject
{
    private string _chartTitle;
    private bool _rangeSyncOnZoomExtents;
 
    public ObservableCollection<IAxisViewModel> XAxes { get; }
        = new ObservableCollection<IAxisViewModel>();
    public ObservableCollection<IAxisViewModel> YAxes { get; }
        = new ObservableCollection<IAxisViewModel>();
    public ObservableCollection<IRenderableSeriesViewModel> RenderableSeries { get; }
        = new ObservableCollection<IRenderableSeriesViewModel>();
 
    public string ChartTitle
    {
        get => _chartTitle;
        set { _chartTitle = value; OnPropertyChanged("ChartTitle"); }
    }
 
    public bool RangeSyncOnZoomExtents
    {
        get => _rangeSyncOnZoomExtents;
        set
        {
            if (_rangeSyncOnZoomExtents != value)
            {
                _rangeSyncOnZoomExtents = value;
                OnPropertyChanged("RangeSyncOnZoomExtents");
 
                foreach (var axis in XAxes)
                    if (axis is AxisBaseViewModel vm)
                        vm.RangeSyncSourceOnZoomExtents = value;
 
                foreach (var axis in YAxes)
                    if (axis is AxisBaseViewModel vm)
                        vm.RangeSyncSourceOnZoomExtents = value;
            }
        }
    }
}

public class MainViewModel : BindableObject
{
    public ChartViewModel CelsiusChart { get; }
    public ChartViewModel FahrenheitChart { get; }
 
    public MainViewModel()
    {
        CelsiusChart = BuildCelsiusChart();
        FahrenheitChart = BuildFahrenheitChart();
 
        CelsiusChart.RenderableSeries.ZoomExtentsWhenReady();
        FahrenheitChart.RenderableSeries.ZoomExtentsWhenReady();
    }
 
    private ChartViewModel BuildCelsiusChart()
    {
        var chart = new ChartViewModel { ChartTitle = "Temperature (\u00b0C)" };
 
        // X axis \u2014 synced via "TimeGroup" (no transform, same time unit)
        chart.XAxes.Add(new NumericAxisViewModel
        {
            AxisTitle = "Time (s)",
            AutoRange = AutoRange.Once,
            RangeSyncGroupId = "TimeGroup"
        });
 
        // Y axis \u2014 synced via "TempGroup" (no transform = identity,
        // this axis's range IS the canonical group range)
        chart.YAxes.Add(new NumericAxisViewModel
        {
            AxisTitle = "\u00b0C",
            AutoRange = AutoRange.Once,
            RangeSyncGroupId = "TempGroup"
        });
 
        // Make this chart the authoritative source on ZoomExtents
        chart.RangeSyncOnZoomExtents = true;
 
        // Sample data: temperature oscillating around 20 \u00b0C
        var ds = new XyDataSeries<double, double> { SeriesName = "Sensor (\u00b0C)" };
        for (int i = 0; i < 500; i++)
        {
            double x = i * 0.1;
            ds.Append(x, 20 + 10 * Math.Sin(x * 0.5) + 5 * Math.Sin(x * 1.3));
        }
 
        chart.RenderableSeries.Add(new LineRenderableSeriesViewModel
        {
            DataSeries = ds,
            Stroke = Color.FromRgb(0x50, 0xC7, 0xE0),
            StrokeThickness = 2
        });
 
        return chart;
    }
 
    private ChartViewModel BuildFahrenheitChart()
    {
        var chart = new ChartViewModel { ChartTitle = "Temperature (\u00b0F)" };
 
        // X axis \u2014 same sync group, no transform
        chart.XAxes.Add(new NumericAxisViewModel
        {
            AxisTitle = "Time (s)",
            AutoRange = AutoRange.Once,
            RangeSyncGroupId = "TimeGroup"
        });
 
        // Y axis \u2014 same sync group, with a transform.
        // CelsiusFahrenheitTransform converts:
        //   ToGroupRange:   F \u2192 C  (broadcast to group when this axis changes)
        //   FromGroupRange: C \u2192 F  (update this axis when the group changes)
        chart.YAxes.Add(new NumericAxisViewModel
        {
            AxisTitle = "\u00b0F",
            AutoRange = AutoRange.Once,
            RangeSyncGroupId = "TempGroup",
            RangeSyncTransform = new CelsiusFahrenheitTransform()
        });
 
        // Same signal in Fahrenheit: F = C \u00d7 9/5 + 32
        var ds = new XyDataSeries<double, double> { SeriesName = "Sensor (\u00b0F)" };
        for (int i = 0; i < 500; i++)
        {
            double x = i * 0.1;
            double celsius = 20 + 10 * Math.Sin(x * 0.5) + 5 * Math.Sin(x * 1.3);
            ds.Append(x, celsius * 9.0 / 5.0 + 32);
        }
 
        chart.RenderableSeries.Add(new LineRenderableSeriesViewModel
        {
            DataSeries = ds,
            Stroke = Color.FromRgb(0xF4, 0x84, 0x20),
            StrokeThickness = 2
        });
 
        return chart;
    }
}

public class CelsiusFahrenheitTransform : IRangeSyncTransform
{
    /// Convert axis range (Fahrenheit) to group range (Celsius).
    public IRange ToGroupRange(IRange axisRange)
    {
        if (axisRange is DoubleRange r)
        {
            return new DoubleRange(
                (r.Min - 32) * 5.0 / 9.0,
                (r.Max - 32) * 5.0 / 9.0);
        }
        return axisRange;
    }
 
    /// Convert group range (Celsius) to axis range (Fahrenheit).
    public IRange FromGroupRange(IRange groupRange)
    {
        if (groupRange is DoubleRange r)
        {
            return new DoubleRange(
                r.Min * 9.0 / 5.0 + 32,
                r.Max * 9.0 / 5.0 + 32);
        }
        return groupRange;
    }
}