Normal,

            High,

            Excessive

        }

        private static ReactionScannerService? s_instance;

        public static ReactionScannerService Instance => s_instance ??= new ReactionScannerService();

        // Current Status

        public bool IsCaptured { get; private set; }

        public PaintColor RecordedColor {

            get => _recordedColor;

            private set => _recordedColor.Set(value);

        }

        private int _pixelMultiplier = 1;

        private bool _firstRun   = true;

        private int _lastSwatchX = -1;

        private int _lastSwatchY = -1;

        private int _screenX     = 0;

        public void RefreshFromSettings()

        {

            SettingsService.Get(SettingKey.PixelMultiplier, out _pixelMultiplier, Constants.DefaultPixelMultiplier);

            SettingsService.Get(SettingKey.ScreenX, out _screenX, Constants.DefaultScreenX);

            SettingsService.Get(SettingKey.ScreenY, out _screenY, Constants.DefaultScreenY);

        private void UpdateSwatchSizes()

        {

        }

        public void CancelScan()

        {

            // 1.) Check if the top pixel is a dark pixel.

            if (!PixelColor.IsDark(pixels.ColorAt(x, y))) return false;

            // 2.) grab the swatch color 2 down from top border

            // Scan the column from 2 below the top to 3 above the bottom to ensure the color matches

            {

                if (!pixels.DoesPixelMatch(x, y + i, ColorMatcher.IsMatch)) return false;

            }

        private bool IsPossibleSwatchUpperLeft(Pixels pixels, int x, int y)

        {

            bool result = true;

            int swatchSolidBottomY = swatchSolidTopY + swatchSolidHeight - 1;

            Color swatchColor = pixels.ColorAt(swatchSolidLeftX, swatchSolidTopY);

            ColorMatcher.Color = swatchColor;

                // Box corners test failed

                WriteLog(LogVerbosity.High, "Failed to find left edge for potential swatch of color {2}, {3}, {4} at {0}, {1}", x, y, swatchColor.R, swatchColor.G, swatchColor.B);

                return false;

            }

            // scan down the right and left sides

            {

                result &= pixels.DoesPixelMatch(swatchSolidLeftX, swatchSolidTopY + yOff, ColorMatcher.IsMatch);

                if (!result)

                {

                }

            }

            if (!result)

            {

                return false;

            }

            {

                result &= pixels.DoesPixelMatch(swatchSolidLeftX + xOff, swatchSolidTopY, ColorMatcher.IsMatch);

                if (!result)

                {

                }

            }

            if (!result)

            {

                return false;

            }

            // test the left edge for dark pixels -- the bottom-most pixel is bright now

            int i = 0;

            {

                result &= pixels.DoesPixelMatch(x, y + i, PixelColor.IsDark);

            }

            if (!result)

            {

                // No dark border on the left side

                WriteLog(LogVerbosity.Normal, "Failed to find left border for potential swatch of color {2}, {3}, {4} at {0}, {1}", x, y, swatchColor.R, swatchColor.G, swatchColor.B);

                return false;

            }

            bool borderError = false;

            {

                bool isBorder = pixels.DoesPixelMatch(x + i, y, PixelColor.IsDark);

                result &= isBorder;

                if (!isBorder)

                    WriteLog(LogVerbosity.Normal, "Probable swatch at {0},{1} failed upper border test at {2},{3}", x, y, x + i, y);

                    borderError = true;

                }

                // The row just above is shaded, so check 2 above

                if (y > 1)

                {

                }

                else

                {

                }

                if (y < pixels.Height)

                {

                }

                else

                {

                }

            }

            {

                {

                }

            }

            return result;

        private bool TestPosition(int x, int y, Pixels pixels, ref PaintColor reactedColor)

        {

            // Check 4 corners of solid area and left/right solid bar areas

            if (foundSwatch)

            {

                WriteLog(LogVerbosity.Normal, "Found probable swatch at {0},{1} - checking border slices", x, y);

                int borderXOffset = 0;

                {

                    foundSwatch &= IsPossibleSwatchSlice(pixels, x + borderXOffset, y);

                    if (!foundSwatch)

                    {

                    }

                }

            }

            // WE FOUND THE SWATCH!

            // Now we know where the color bars are.

            int redPixelCount = pixels.LengthOfColorAt(x, y + _redBarSpacing, PixelColor.IsRed);

            int greenPixelCount = pixels.LengthOfColorAt(x, y + _greenBarSpacing, PixelColor.IsGreen);

            int bluePixelCount = pixels.LengthOfColorAt(x, y + _blueBarSpacing, PixelColor.IsBlue);

            WriteLog(LogVerbosity.Low, "Found the color swatch at {0}, {1}. Color={2} Red={3}px Green={4}px Blue={5}px", x, y, reactedColor, redPixelCount, greenPixelCount, bluePixelCount);

            return true;

        }

                Debug.WriteLine("Scan starting at [" + _screenX + ", " + _screenY + "]");

                g.CopyFromScreen(_screenX, _screenY, 0, 0, _targetBitmap.Size, CopyPixelOperation.SourceCopy);

            }

            Pixels pixels = new(_targetBitmap, _pixelMultiplier);

            IsCaptured = false;

            SettingsService.Get("Log.Verbosity", out var verbosityIdx, 1);

            _logVerbosity = (LogVerbosity)verbosityIdx;

            SettingsService.Get("ScanArea.Min.X", out var startX, 0);

            SettingsService.Get("ScanArea.Min.Y", out var startY, 0);

            SettingsService.Get("ScanArea.Max.X", out var endX,   _targetBitmap.Width);

            SettingsService.Get("ScanArea.Max.Y", out var endY,   _targetBitmap.Height);

            startX = Math.Max(2, Math.Min(startX, _targetBitmap.Width - 2));

            startY = Math.Max(2, Math.Min(startY, _targetBitmap.Height - 2));

            endY = Math.Min(_targetBitmap.Height - 2, Math.Max(2, endY)) - (_blueBarSpacing + 10); // + patchTestSize;

            int xSpan = endX - startX;

            int ySpan = endY - startY;

            int total = xSpan * ySpan;

                    if (!pixels.IsSolidPatchAt(roughX, roughY, patchTestSize, patchTestSize)) continue;

                    Color patchColor = pixels.ColorAt(roughX, roughY);

                    WriteLog(LogVerbosity.Excessive, "Found a solid patch of {2},{3},{4} at {0}, {1}", roughX, roughY, patchColor.R, patchColor.G, patchColor.B);

                    {

                        {

                            WriteLog(LogVerbosity.Excessive, "Searching for potential swatch at {0},{1} after found square at {2},{3}", x, y, roughX, roughY);

                            if (!TestPosition(x, y, pixels, ref reactedColor)) continue;

            int b = reactedColor.Blue  - expectedColor.Blue  - reaction1.Blue  - reaction2.Blue;

            return new Reaction(r, g, b);

        }

        public static Reaction CalculateReaction(PaintColor expectedColor, PaintColor reactedColor)

        {

            // A 2-reagent reaction.

            int r = reactedColor.Red   - expectedColor.Red;

namespace DesertPaintCodex.Services

{

    public static class SettingKey

    {

        public const string PixelMultiplier = "pixelmultiplier";

        public const string ScreenIndex     = "screenindex";

        public const string ScreenX         = "screenx";

        public const string ScreenY         = "screeny";

namespace DesertPaintCodex.Util

{

    public static class Constants

    {

        public static int DefaultPixelMultiplier = 1;

        public static int DefaultScreenWidth = 1920;

        public static int DefaultScreenHeight = 1080;

        public static int DefaultScreenX = 0;

                return _stubReactionTest;

            }

        }

    }

}

namespace DesertPaintCodex.Util

{

    public class PixelColor

    {

        public static bool IsMatch(Color colorA, Color colorB)

        {

            return ((Math.Abs(colorA.R - colorB.R) <= ColorTolerance) &&

        {

            return (color.R < 0x47) && (color.G < 0x47) && (color.B < 0x47);

        }

        {

        }

        public static bool IsRed(Color color)

        {

        }

        public static bool IsGreen(Color color)

        {

        }

        public static bool IsBlue(Color color)

        {

        }

    }

}

            _testView.ReactionTest = GetSelectedReactionTest();

            TestView.SaveReaction.Subscribe(_ => OnSaveReaction());

            TestView.ClearReaction.Subscribe(_ => OnClearReaction());

        }

        private ReactionTest GetSelectedReactionTest()

        {

            if (itemIndex < 0) return Constants.StubReactionTest;

            var list = _testLists[SelectedList];

            return (itemIndex >= list.Count) ? Constants.StubReactionTest : list[itemIndex];

        }

        private void OnSaveReaction()

        {

            ReactionTest test = TestView.ReactionTest;

                SelectedRemainingTest = 0;

            }

        }

        private static void InsertTestIntoList(ReactionTest test, IList<ReactionTest> list)

        {

            int i;

            for (i = 0; i < list.Count; i++)

            ShowScreenSettingsDialog = new Interaction<ScreenSettingsViewModel, Unit>();

            SaveReaction = ReactiveCommand.Create(() => ReactionTest.SaveReaction());

            ClearReaction = ReactiveCommand.Create(() => ReactionTest.ClearReaction());

        }

        private void UpdateDerivedState()

        {

            Debug.WriteLine("Analyze");

            try

            {

                await ReactionTest.StartScan();

            }

            catch (OperationCanceledException)

            {

                Debug.WriteLine("Scan canceled.");

        public async Task ShowClipInfo()

        {

            await ShowInfoBox("Clipped Reactions", "The Pigment Lab is only capable of displaying color channel values in the 0-255 range. However, sometimes, your reactions will push one or more channels outside of that range. When that happens, the value will be clamped either to 0 or 255. In this case, we say that the reaction was \"Clipped.\"\n\nThis is nothing to panic about, though. We solve this issue by using a third (buffer) reagent to offset the extreme value, so that it falls within measurable range, similar to how we test Catalyst+Catalyst reactions. Desert Paint Codex will automatically do the math for this, but it does move clipped reactions towards the end of your test list, because you'll want any reactions between the buffer reagent and your two test reagents already known, prior to running your buffered test.");

        }

        public Interaction<ScreenSettingsViewModel, Unit> ShowScreenSettingsDialog { get; }

        public ReactiveCommand<Unit, Unit> ClearReaction { get; }

        public ReactiveCommand<Unit, Unit> SaveReaction { get; }

    }

}



using Avalonia.Platform;

using DesertPaintCodex.Models;

using DesertPaintCodex.Services;

using ReactiveUI;

using System.Collections.Generic;

using System.Collections.ObjectModel;

using System.Reactive;

using Avalonia;

using Avalonia.Controls.ApplicationLifetimes;

using DesertPaintCodex.Util;

namespace DesertPaintCodex.ViewModels

{

    public class ScreenSettingsViewModel : ViewModelBase

    {

        public ObservableCollection<ScreenMetrics> Screens { get; } = new();

        private int _pixeMultiplier;

        public int PixelMultiplier { get => _pixeMultiplier; private set => this.RaiseAndSetIfChanged(ref _pixeMultiplier, value); }

        private int _screenIndex;

        {

            if (Application.Current.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)

            {

                IScreenImpl screen = desktop.MainWindow.PlatformImpl.Screen;

                IReadOnlyList<Screen> screens = screen.AllScreens;

                for (int i = 0; i < screens.Count; i++)

                {

                    Screens.Add(new ScreenMetrics(screens[i].Bounds, screens[i].Primary));

                }

                SettingsService.Get(SettingKey.PixelMultiplier, out _pixeMultiplier, Constants.DefaultPixelMultiplier);

                SettingsService.Get(SettingKey.ScreenIndex,     out _screenIndex, 0);

                _screenIndex = System.Math.Min(_screenIndex, screens.Count - 1); // In case the user has fewer screens than last time.

                Save = ReactiveCommand.Create(() => {

                    SettingsService.Set(SettingKey.PixelMultiplier, _pixeMultiplier);

                    SettingsService.Set(SettingKey.ScreenIndex,     _screenIndex);

                    SettingsService.Set(SettingKey.ScreenX,         screens[_screenIndex].Bounds.X);

                    SettingsService.Set(SettingKey.ScreenY,         screens[_screenIndex].Bounds.Y);

            }

            else

            {

                // Placeholder stuff.

                Screens.Add(new ScreenMetrics(new Avalonia.PixelRect(0, 0, 1920, 1080), true));

                Screens.Add(new ScreenMetrics(new Avalonia.PixelRect(1920, 0, 1920, 1080), false));

                PixelMultiplier       = 1;

                ScreenIndex           = 0;

                Save = ReactiveCommand.Create(() => { });

using System.Reactive;

using ReactiveUI;

using System.Collections.Generic;

using System.Diagnostics;

using DesertPaintCodex.Services;

namespace DesertPaintCodex.ViewModels

{

    public class SelectProfileViewModel : ViewModelBase

    {

        private string? _selectedItem;

        public string? SelectedItem { get => _selectedItem; set => this.RaiseAndSetIfChanged(ref _selectedItem, value); }

        public SelectProfileViewModel()

        {

            var okEnabled = this.WhenAnyValue(

                x => x.SelectedItem,

                x => !string.IsNullOrWhiteSpace(x));

        }

        private void ShowSelectProfile()

        {

            ProfileActivity = _selectProfileVM;

        }

        private void ShowCreateProfile()

        {

            ProfileActivity = _createProfileVM;

        }

    <DockPanel Classes="Activity">

        <TabControl DockPanel.Dock="Left" Width="318" Classes="ListFilter" SelectedIndex="{Binding SelectedList}">

            <TabItem Header="Pending Tests">

            </TabItem>

            <TabItem Header="Completed Tests">

            </TabItem>

        </TabControl>

        <views:ReactionTestView DataContext="{Binding TestView}"/>

using Avalonia.ReactiveUI;

using DesertPaintCodex.ViewModels;

namespace DesertPaintCodex.Views

{

    public class ExperimentLogView : ReactiveUserControl<ExperimentLogViewModel>

    {

        public ExperimentLogView()

        {

            InitializeComponent();

        }

        private void InitializeComponent()

        {

            AvaloniaXamlLoader.Load(this);

        }

    }

}

    <Button DockPanel.Dock="Bottom" Command="{Binding Save}">Ok</Button>

    <Grid DockPanel.Dock="Bottom" ColumnDefinitions="*,12,80,12,24" RowDefinitions="Auto,30,Auto" Margin="0, 0, 0, 30">