最新的图像算子集成到图像工具箱

XplorePlane/Services/ImageProcessing/ImageProcessingService.cs

@@ -1,12 +1,15 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.Loader;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows.Media.Imaging;
 using XP.Common.Logging.Interfaces;
 using XP.ImageProcessing.Core;
-using XP.ImageProcessing.Processors;
 
 namespace XplorePlane.Services
 {
@@ -18,40 +21,180 @@ namespace XplorePlane.Services
         public ImageProcessingService(ILoggerService logger)
         {
             _logger = logger?.ForModule<ImageProcessingService>() ?? throw new ArgumentNullException(nameof(logger));
-            _processorRegistry = new ConcurrentDictionary<string, ImageProcessorBase>();
-            RegisterBuiltInProcessors();
+            _processorRegistry = new ConcurrentDictionary<string, ImageProcessorBase>(StringComparer.OrdinalIgnoreCase);
+            DiscoverProcessors();
         }
 
-        private void RegisterBuiltInProcessors()
+        private void DiscoverProcessors()
         {
-            // 8-bit processors
-            _processorRegistry["GaussianBlur"] = new GaussianBlurProcessor();
-            _processorRegistry["Threshold"] = new ThresholdProcessor();
-            _processorRegistry["Division"] = new DivisionProcessor();
-            _processorRegistry["Contrast"] = new ContrastProcessor();
-            _processorRegistry["Gamma"] = new GammaProcessor();
-            _processorRegistry["Morphology"] = new MorphologyProcessor();
-            _processorRegistry["Contour"] = new ContourProcessor();
-            _processorRegistry["ShockFilter"] = new ShockFilterProcessor();
-            _processorRegistry["BandPassFilter"] = new BandPassFilterProcessor();
+            var assemblies = LoadCandidateAssemblies().ToList();
+            var discoveredCount = 0;
 
-            _logger.Info("Registered {Count} built-in image processors", _processorRegistry.Count);
+            foreach (var assembly in assemblies)
+            {
+                foreach (var processorType in GetProcessorTypes(assembly))
+                {
+                    if (!TryCreateProcessor(processorType, out var processor))
+                        continue;
+
+                    var key = GetProcessorKey(processorType);
+                    RegisterProcessorInternal(key, processor, discovered: true);
+                    discoveredCount++;
+                }
+            }
+
+            _logger.Info(
+                "Discovered {ProcessorCount} image processors from {AssemblyCount} assemblies",
+                discoveredCount,
+                assemblies.Count);
         }
 
-        public IReadOnlyList<string> GetAvailableProcessors() => new List<string>(_processorRegistry.Keys).AsReadOnly();
+        private IReadOnlyList<Assembly> LoadCandidateAssemblies()
+        {
+            var assemblies = AppDomain.CurrentDomain.GetAssemblies()
+                .Where(a => !a.IsDynamic)
+                .ToList();
+
+            var loadedNames = new HashSet<string>(
+                assemblies.Select(a => a.GetName().Name ?? string.Empty),
+                StringComparer.OrdinalIgnoreCase);
+
+            foreach (var path in EnumerateProcessorAssemblyPaths())
+            {
+                var assemblyName = Path.GetFileNameWithoutExtension(path);
+                if (string.IsNullOrWhiteSpace(assemblyName) || loadedNames.Contains(assemblyName))
+                    continue;
+
+                try
+                {
+                    var assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(Path.GetFullPath(path));
+                    loadedNames.Add(assembly.GetName().Name ?? assemblyName);
+                    assemblies.Add(assembly);
+                    _logger.Debug("Loaded processor assembly from {Path}", path);
+                }
+                catch (Exception ex)
+                {
+                    _logger.Error(ex, "Failed to load processor assembly from {Path}", path);
+                }
+            }
+
+            return assemblies;
+        }
+
+        private static IEnumerable<string> EnumerateProcessorAssemblyPaths()
+        {
+            var baseDirectory = AppContext.BaseDirectory;
+            var candidateDirectories = new[]
+            {
+                baseDirectory,
+                Path.Combine(baseDirectory, "Processors"),
+                Path.Combine(baseDirectory, "Plugins"),
+                Path.Combine(baseDirectory, "Libs", "ImageProcessing")
+            };
+
+            var paths = new List<string>();
+
+            foreach (var directory in candidateDirectories.Distinct(StringComparer.OrdinalIgnoreCase))
+            {
+                if (!Directory.Exists(directory))
+                    continue;
+
+                if (string.Equals(directory, baseDirectory, StringComparison.OrdinalIgnoreCase))
+                {
+                    var processorDll = Path.Combine(directory, "XP.ImageProcessing.Processors.dll");
+                    if (File.Exists(processorDll))
+                        paths.Add(processorDll);
+                }
+                else
+                {
+                    paths.AddRange(Directory.GetFiles(directory, "*.dll", SearchOption.TopDirectoryOnly));
+                }
+            }
+
+            return paths.Distinct(StringComparer.OrdinalIgnoreCase);
+        }
+
+        private static IEnumerable<Type> GetProcessorTypes(Assembly assembly)
+        {
+            try
+            {
+                return assembly
+                    .GetTypes()
+                    .Where(type => type is { IsClass: true, IsAbstract: false }
+                                   && typeof(ImageProcessorBase).IsAssignableFrom(type)
+                                   && type.GetConstructor(Type.EmptyTypes) != null);
+            }
+            catch (ReflectionTypeLoadException ex)
+            {
+                return ex.Types
+                    .Where(type => type != null
+                                   && type.IsClass
+                                   && !type.IsAbstract
+                                   && typeof(ImageProcessorBase).IsAssignableFrom(type)
+                                   && type.GetConstructor(Type.EmptyTypes) != null)!;
+            }
+        }
+
+        private static string GetProcessorKey(Type processorType)
+        {
+            const string suffix = "Processor";
+            return processorType.Name.EndsWith(suffix, StringComparison.OrdinalIgnoreCase)
+                ? processorType.Name[..^suffix.Length]
+                : processorType.Name;
+        }
+
+        private bool TryCreateProcessor(Type processorType, out ImageProcessorBase processor)
+        {
+            try
+            {
+                processor = (ImageProcessorBase)Activator.CreateInstance(processorType)!;
+                return true;
+            }
+            catch (Exception ex)
+            {
+                processor = null;
+                _logger.Error(ex, "Failed to create processor instance for {ProcessorType}", processorType.FullName);
+                return false;
+            }
+        }
+
+        private void RegisterProcessorInternal(string name, ImageProcessorBase processor, bool discovered)
+        {
+            if (string.IsNullOrWhiteSpace(name))
+                throw new ArgumentException("Processor name cannot be empty", nameof(name));
+            if (processor == null)
+                throw new ArgumentNullException(nameof(processor));
+
+            _processorRegistry.AddOrUpdate(
+                name,
+                processor,
+                (_, _) => processor);
+
+            if (discovered)
+                _logger.Debug("Discovered processor: {ProcessorName}", name);
+            else
+                _logger.Info("Registered processor: {ProcessorName}", name);
+        }
+
+        public IReadOnlyList<string> GetAvailableProcessors()
+        {
+            return _processorRegistry.Keys
+                .OrderBy(key => ProcessorUiMetadata.GetCategoryOrder(ProcessorUiMetadata.Get(key).Category))
+                .ThenBy(key => GetProcessorDisplayName(key), StringComparer.CurrentCultureIgnoreCase)
+                .ToList()
+                .AsReadOnly();
+        }
 
         public void RegisterProcessor(string name, ImageProcessorBase processor)
         {
-            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Processor name cannot be empty", nameof(name));
-            if (processor == null) throw new ArgumentNullException(nameof(processor));
-            _processorRegistry[name] = processor;
-            _logger.Info("Registered processor: {ProcessorName}", name);
+            RegisterProcessorInternal(name, processor, discovered: false);
         }
 
         public IReadOnlyList<ProcessorParameter> GetProcessorParameters(string processorName)
         {
             if (_processorRegistry.TryGetValue(processorName, out var processor))
                 return processor.GetParameters().AsReadOnly();
+
             throw new ArgumentException($"Processor not registered: {processorName}", nameof(processorName));
         }
 
@@ -59,13 +202,15 @@ namespace XplorePlane.Services
         {
             if (_processorRegistry.TryGetValue(processorName, out var processor))
                 return processor;
+
             throw new ArgumentException($"Processor not registered or is 16-bit only: {processorName}", nameof(processorName));
         }
 
         public string GetProcessorDisplayName(string processorName)
         {
-            if (_processorRegistry.TryGetValue(processorName, out var p))
-                return string.IsNullOrWhiteSpace(p.Name) ? processorName : p.Name;
+            if (_processorRegistry.TryGetValue(processorName, out var processor))
+                return string.IsNullOrWhiteSpace(processor.Name) ? processorName : processor.Name;
+
             return processorName;
         }
 
@@ -81,7 +226,6 @@ namespace XplorePlane.Services
             if (!_processorRegistry.TryGetValue(processorName, out var processor))
                 throw new ArgumentException($"Processor not registered: {processorName}", nameof(processorName));
 
-            // Extract pixels on the UI thread (BitmapSource / FormatConvertedBitmap are DependencyObjects)
             var rawPixels = ImageConverter.ExtractGray8Pixels(source, out int imgWidth, out int imgHeight);
 
             return await Task.Run(() =>
@@ -103,7 +247,7 @@ namespace XplorePlane.Services
                     progress?.Report(0.9);
 
                     var result = ImageConverter.ToBitmapSource(processedEmgu);
-                    result.Freeze(); // must freeze before crossing thread boundary
+                    result.Freeze();
                     progress?.Report(1.0);
 
                     return result;
@@ -131,7 +275,8 @@ namespace XplorePlane.Services
                 if (processor is IDisposable disposable)
                     disposable.Dispose();
             }
+
             _processorRegistry.Clear();
         }
     }
-}
+}