IDS camera added

Hawkeye.VisionBuilder.UI.Sources.IDS/Hawkeye.VisionBuilder.UI.Sources.IDS.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\VisionBuilder.UI.Common\VisionBuilder.UI.Common.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Reference Include="uEyeDotNet">
+      <HintPath>uEyeDotNet.dll</HintPath>
+    </Reference>
+  </ItemGroup>
+
+</Project>

Hawkeye.VisionBuilder.UI.Sources.IDS/IDSImageSource.cs

@@ -0,0 +1,228 @@
+using OpenCvSharp;
+using Serilog;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using uEye.Defines;
+using VisionBuilder.UI.Common;
+using VisionBuilder.UI.Common.RecipeProcessing;
+using Point = System.Drawing.Point;
+
+namespace Inspectron.Camera.UEye
+{
+
+    public class IDSImageSource : IImageSource, IVisionBuilderModule
+    {
+        private readonly IDSImageSourceSettings _settings;
+        private uEye.Camera _camera = null;
+
+
+        int cameraIdx;
+
+        
+
+        public IDSImageSource(IDSImageSourceSettings settings)
+        {
+            _settings = settings;
+            _camera = new uEye.Camera();
+            cameraIdx = _settings.CameraId;
+            System.AppDomain.CurrentDomain.ProcessExit += AppDomain_ProcessExit;
+        }
+
+        private void AppDomain_ProcessExit(object sender, EventArgs e)
+        {
+            Close();
+        }
+
+        private Mat MemoryToImage(int idx)
+        {
+            uEye.Defines.ColorMode mode;
+            _camera.PixelFormat.Get(out mode);
+            int channels = 0;
+
+            if (mode == uEye.Defines.ColorMode.Mono8)
+            {
+                channels = 1;
+            }
+            else if (mode == uEye.Defines.ColorMode.BGR8Packed || mode == uEye.Defines.ColorMode.RGB8Packed)
+            {
+                channels = 3;
+            }
+            else if (mode == uEye.Defines.ColorMode.BGRA8Packed)
+            {
+                channels = 3;
+            }
+            else
+            {
+                throw new Exception("unknown image format");
+            }
+
+            var size = new uEye.Types.Size<int>();
+            _camera.Memory.GetSize(idx, out size);
+            int pitch;
+            _camera.Memory.GetPitch(idx, out pitch);
+
+            Byte[] u8img;
+            _camera.Memory.CopyToArray(idx, out u8img);
+            //Console.WriteLine($"Image size: {size.Width}x{size.Height}, channels: {channels}({mode}), data size: {u8img.Length}, pitch: {pitch}");
+            //Console.ReadLine();
+            Mat mat = new Mat(size.Height,pitch, MatType.CV_8UC(channels));
+            mat.SetArray(u8img);
+            return mat;
+        }
+
+        public void Open()
+        {
+            if (_camera.IsOpened)
+                return;
+
+            uEye.Defines.Status statusRet = 0;
+
+            // Open _camera
+            statusRet = _camera.Init(cameraIdx);
+            if (statusRet != uEye.Defines.Status.Success)
+            {
+                throw new Exception("_camera initializing failed: "+statusRet);
+            }
+            uEye.Types.SensorInfo info = new uEye.Types.SensorInfo();
+            _camera.Information.GetSensorInfo(out info);
+            Console.WriteLine($"Camera {cameraIdx} opened: {info.SensorName} ({info.SensorID})");
+            _camera.Parameter.Load();
+            Console.WriteLine($"Camera {cameraIdx} parameters loaded");
+
+            _camera.Trigger.Set(uEye.Defines.TriggerMode.Continuous);
+
+            statusRet = _camera.Memory.Allocate();
+            Console.WriteLine("Memory allocated");
+            if (statusRet != uEye.Defines.Status.Success)
+            {
+                throw new Exception("Allocate Memory failed");
+
+            }
+            _camera.EventFrame += onFrameEvent;
+            try
+            {
+                _camera.Device.Feature.ShutterMode.Set(uEye.Defines.Shuttermode.Global);
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine(e.Message);
+            }
+        }
+
+        public void Close()
+        {
+            if (!_camera.IsOpened)
+                return;
+
+            uEye.Defines.Status statusRet;
+            statusRet = _camera.Exit();
+
+            if (statusRet != uEye.Defines.Status.Success)
+            {
+                throw new Exception("failed to close camera");
+            }
+        }
+
+
+
+        public void LoadParameters(string parameters_file)
+        {
+            uEye.Defines.Status statusRet = 0;
+
+            Int32[] memList;
+            statusRet = _camera.Memory.GetList(out memList);
+            if (statusRet != uEye.Defines.Status.Success)
+            {
+                throw new Exception("Get memory list failed: " + statusRet);
+            }
+
+            statusRet = _camera.Memory.Free(memList);
+            if (statusRet != uEye.Defines.Status.Success)
+            {
+                throw new Exception("Free memory list failed: " + statusRet);
+            }
+
+            statusRet = _camera.Parameter.Load(parameters_file);
+            if (statusRet != uEye.Defines.Status.Success)
+            {
+                throw new Exception("Loading parameter failed: " + statusRet);
+            }
+
+            uEye.Types.Size<int> t = new uEye.Types.Size<int>();
+
+
+            statusRet = _camera.Memory.Allocate();
+            if (statusRet != uEye.Defines.Status.SUCCESS)
+            {
+                throw new Exception("Allocate Memory failed");
+            }
+        }
+
+        public void SaveParameters(string parameters_file)
+        {
+            uEye.Defines.Status statusRet = 0;
+
+            statusRet = _camera.Parameter.Save(parameters_file);
+            if (statusRet != uEye.Defines.Status.SUCCESS)
+            {
+                throw new Exception("failed to save Parameters");
+            }
+        }
+        
+
+
+
+        private void onFrameEvent(object sender, EventArgs e)
+        {
+            try
+            {
+                uEye.Camera camera = sender as uEye.Camera;
+                int s32MemId;
+                int active = (int)camera.Memory.GetActive(out s32MemId);
+                int num1 = (int)camera.Memory.Lock(s32MemId);
+                var image = this.MemoryToImage(s32MemId);
+                int num2 = (int)camera.Memory.Unlock(s32MemId);
+
+                if (!_channel.Writer.TryWrite(image))
+                {
+                    Log.Warning("Image channel is full, dropping image");
+                }
+            }
+            catch (TaskCanceledException ex)
+            {
+                int num = (int)(sender as uEye.Camera).Acquisition.Stop();
+                
+            }
+        }
+
+        
+
+
+
+        private Channel<Mat> _channel = Channel.CreateBounded<Mat>(new BoundedChannelOptions(1)
+        {
+            FullMode = BoundedChannelFullMode.DropOldest,
+            SingleReader = true,
+            SingleWriter = true,
+            AllowSynchronousContinuations = true
+        });
+        public async Task<Mat> GetImage(CancellationToken token)
+        {
+            return await _channel.Reader.ReadAsync(token);
+        }
+
+        public void InitializeModule()
+        {
+            Open();
+            if(!(string.IsNullOrEmpty(_settings.CameraFile)))
+                LoadParameters(_settings.CameraFile);
+            _camera.Trigger.Set(uEye.Defines.TriggerMode.Continuous);
+            _camera.Acquisition.Capture();
+        }
+    }
+}

Hawkeye.VisionBuilder.UI.Sources.IDS/IDSImageSourceSettings.cs

@@ -0,0 +1,40 @@
+using System.Text;
+using Inspectron.Settings;
+using Inspectron.Settings.Attributes;
+using VisionBuilder.UI.Common;
+
+namespace Inspectron.Camera.UEye;
+
+public class IDSImageSourceSettings:ISettings
+{
+    public string CameraName { get; }
+
+    public IDSImageSourceSettings(string cameraName)
+    {
+        CameraName = cameraName;
+    }
+
+    [SettingPreview(typeof(IDSImageSourceSettings), nameof(CameraIdsPreview))]
+    public int CameraId { get; set; } = 0;
+
+    [File("*.ini")] public string CameraFile { get; set; } = "";
+
+    public void RegisterSettings(InspectronSettings settings)
+    {
+        settings.RegisterSimple(this, () => CameraId, $"{CameraName}/Sources/IDS", nameof(CameraId));
+        settings.RegisterSimple(this, () => CameraFile, $"{CameraName}/Sources/IDS", nameof(CameraFile));
+        
+    }
+
+    public static string CameraIdsPreview(int _)
+    {
+        uEye.Info.Camera.GetCameraList(out var cameraList);
+        StringBuilder sb = new StringBuilder();
+        foreach (var camera in cameraList)
+        {
+            sb.AppendLine($"Camera ID: {camera.CameraID}, Name: {camera.SerialNumber}");
+        }
+
+        return sb.ToString();
+    }
+}