Low,

            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;

        private int _screenY     = 0;

            Debug.Assert(_targetBitmap != null);

        }

        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);

            SettingsService.Get(SettingKey.ScreenWidth,  out int screenWidth, Constants.DefaultScreenWidth);

            SettingsService.Get(SettingKey.ScreenHeight, out int screenHeight, Constants.DefaultScreenHeight);

            UpdateSwatchSizes();

        }

        private void UpdateSwatchSizes()

        {

        }

        public void CancelScan()

        {

            _canceler?.Cancel();

        }

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

        {

            // 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

            for (int i = 2; i < (_swatchHeight-3); ++i)

            {

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

            }

        }

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

        {

            bool result = true;

            int swatchSolidRightX = swatchSolidLeftX + swatchSolidWidth - 1;

            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)

                {

                    testColor = pixels.ColorAt(swatchSolidLeftX, swatchSolidTopY + yOff);

                    break;

                    testColor = pixels.ColorAt(swatchSolidRightX, swatchSolidTopY + yOff);

                    break;

                }

            }

            if (!result)

            {

                return false;

            }

            {

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

                if (!result)

                {

                    testColor = pixels.ColorAt(swatchSolidLeftX + xOff, swatchSolidTopY);

                    break;

                    testColor = pixels.ColorAt(swatchSolidLeftX + xOff, swatchSolidBottomY);

                    break;

                }

            }

            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)

                    {

                        WriteLog(LogVerbosity.Normal, "Failed slice test at {0},{1}", x + borderXOffset, y);

                        break;

                        WriteLog(LogVerbosity.Normal, "Failed slice test at {0},{1}", x + _swatchWidth - borderXOffset, y);

                        break;

                    }

                }

            }

            // 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;

        }

        public async Task<bool> CaptureReactionAsync(IProgress<float> progress)

        {

            using (var g = Graphics.FromImage(_targetBitmap))

            {

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

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

            }

            Pixels pixels = new(_targetBitmap, _pixelMultiplier);

            IsCaptured = false;

            if (!_firstRun)

            {

                _firstRun = true;

            }

            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;

            for (int roughX = startX; roughX < endX ; roughX += patchTestSize)

                    cancellToken.ThrowIfCancellationRequested();

                    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;

                            RecordedColor = reactedColor;

            int g = reactedColor.Green - expectedColor.Green - reaction1.Green - reaction2.Green;

            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;

            int g = reactedColor.Green - expectedColor.Green;

            int b = reactedColor.Blue  - expectedColor.Blue;

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";

        public const string ScreenWidth     = "screenwidth";

        public const string ScreenHeight    = "screenheight";

using DesertPaintCodex.Models;

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;

        public static int DefaultScreenY = 0;

                }

                return _stubReactionTest;

            }

        }

    }

}

using DesertPaintCodex.Services;

namespace DesertPaintCodex.Util

{

    public class PixelColor

    {

        public static bool IsMatch(Color colorA, Color colorB)

        {

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

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

                (Math.Abs(colorA.B - colorB.B) <= ColorTolerance));

        public static bool IsDark(Color color)

        {

            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)

        {

        }

    }

}

                .Subscribe(_ => _testView.ReactionTest = GetSelectedReactionTest());

            _testView.ReactionTest = GetSelectedReactionTest();

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

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

        }

        private ReactionTest GetSelectedReactionTest()

        {

            int itemIndex = (SelectedList == 0) ? SelectedRemainingTest : SelectedCompletedTest;

            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;

            int oldPos = RemainingTests.IndexOf(test);

            // Move test to Completed Tests.

            if (RemainingTests.Count == 1)

            {

                SelectedRemainingTest = 0;

            }

        }

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

        {

            int i;

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

            {

                if (test.CompareTo(list[i]) < 0) break;

            this.WhenAnyValue(x => x.ReactionTest)

                .Subscribe(_ => UpdateDerivedState());

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

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

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

        }

        private void UpdateDerivedState()

        {

            // There are more "reactive" ways to pull this off, but I don't have time to figure out all those recipes

            // right now.

        public async void Analyze()

        {

            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;

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

        public ScreenSettingsViewModel()

        {

            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);

                    SettingsService.Set(SettingKey.ScreenWidth,     screens[_screenIndex].Bounds.Width);

                    SettingsService.Set(SettingKey.ScreenHeight,    screens[_screenIndex].Bounds.Height);

                    ReactionScannerService.Instance.RefreshFromSettings();

                });

            }

            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));

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

                ShowCreateProfile();

            }

        }

        private void ShowSelectProfile()

        {

                _selectProfileVM = new SelectProfileViewModel();

                _selectProfileVM.NewProfile.Subscribe(_ => ShowCreateProfile());

                Observable.Merge(_selectProfileVM.Ok, _selectProfileVM.Cancel)

                    .Take(1)

                    .InvokeCommand(FinishWelcome);

            ProfileActivity = _selectProfileVM;

        }

        private void ShowCreateProfile()

        {

                _createProfileVM = new CreateProfileViewModel();

                Observable.Merge(_createProfileVM.Ok, _createProfileVM.Cancel).Subscribe(_ => ShowSelectProfile());

            ProfileActivity = _createProfileVM;

        }