generate_interface.sh

#!/bin/bash

# Target file
INTERFACE_FILE="neoapi.i"

# SDK Path (default to Baumer_neoAPI_1.5.0_lin_x86_64_cpp if not provided)
SDK_PATH="${1:-Baumer_neoAPI_1.5.0_lin_x86_64_cpp}"

if [ ! -d "$SDK_PATH" ]; then
    echo "Error: SDK path $SDK_PATH does not exist."
    exit 1
fi

INCLUDE_DIR="$SDK_PATH/include/neoapi"

echo "Generating $INTERFACE_FILE (Adding CamBase Extensions and Collection Support)..."

cat <<EOF > "$INTERFACE_FILE"
%module(directors="1") neoapi_csharp

%{
#include "neoapi/neoapi.hpp"
using namespace NeoAPI;
%}

// Handle export macro
#define NEOAPI_CPP_DECL

// Standard templates
%include <std_string.i>
%include <std_vector.i>
%include <stdint.i>

// Enable SWIG Directors for callback classes
%feature("director") NeoAPI::NeoEventCallback;
%feature("director") NeoAPI::NeoImageCallback;
%feature("director") NeoAPI::NeoTraceCallback;

// Enable naturalvar for feature types
%feature("naturalvar") NeoAPI::BaseFeature;
%feature("naturalvar") NeoAPI::IntegerFeature;
%feature("naturalvar") NeoAPI::DoubleFeature;
%feature("naturalvar") NeoAPI::StringFeature;
%feature("naturalvar") NeoAPI::BoolFeature;
%feature("naturalvar") NeoAPI::CommandFeature;
%feature("naturalvar") NeoAPI::EnumerationFeature;

// Nodefaultctor for feature types
%nodefaultctor NeoAPI::BaseFeature;
%nodefaultctor NeoAPI::IntegerFeature;
%nodefaultctor NeoAPI::DoubleFeature;
%nodefaultctor NeoAPI::StringFeature;
%nodefaultctor NeoAPI::BoolFeature;
%nodefaultctor NeoAPI::CommandFeature;
%nodefaultctor NeoAPI::EnumerationFeature;
%nodefaultctor NeoAPI::Feature;
%nodefaultctor NeoAPI::FeatureList;

// Global Renames
%rename(GetIsConnected) NeoAPI::CamBase::IsConnected;
%rename(GetIsStreaming) NeoAPI::CamBase::IsStreaming;
%rename(_Connect) NeoAPI::CamBase::Connect;
%rename(_Disconnect) NeoAPI::CamBase::Disconnect;
%rename(Getf) NeoAPI::CamBase::f;
%rename(Getf) NeoAPI::Cam::f;
%rename(GetIsConnectable) NeoAPI::CamInfo::IsConnectable;

// Feature Renames - Applying correctly to NeoAPI namespace
%rename(GetIsReadable) NeoAPI::BaseFeature::IsReadable;
%rename(GetIsWritable) NeoAPI::BaseFeature::IsWritable;
%rename(GetIsAvailable) NeoAPI::BaseFeature::IsAvailable;

// Rename IsSelector for Derived classes where it works
%rename(GetIsSelector) IsSelector;

%rename(GetIsDone) NeoAPI::CommandFeature::IsDone;

// Iterator Renames
%rename(GetFeature) NeoAPI::FeatureListIterator::operator*;
%rename(operator_increment) NeoAPI::FeatureListIterator::operator++;
%rename(op_Equal) NeoAPI::FeatureListIterator::operator==;
%rename(op_NotEqual) NeoAPI::FeatureListIterator::operator!=;

// Ensure Getf and friends are explicitly defined in CamBase if not already
%extend NeoAPI::CamBase {
    // Note: If f() only exists in Cam in this version, we'll need to handle it.
    // But since we want it in the base class property f, we'll try to extend it.
}

// Explicitly extend CommandFeature for IsDone
%extend NeoAPI::CommandFeature {
    bool GetIsDone() {
        return \$self->IsDone();
    }
}

// Extend CPixelFormat to have a Get method returning PixelFormat enum
%extend NeoAPI::CPixelFormat {
    NeoAPI::PixelFormat Get() {
        return (NeoAPI::PixelFormat)(*(\$self));
    }
    void Set(NeoAPI::PixelFormat value) {
        *(\$self) = value;
    }
}

// Typemap for injecting C# code
%typemap(cscode) NeoAPI::CamBase %{
  public bool IsConnected { get { return GetIsConnected(); } }
  public bool IsStreaming { get { return GetIsStreaming(); } }
  public static string LibraryVersion { get { return GetLibraryVersion(); } }

  public void EnableImageCallback() { EnableImageCallback(ImageCallback); }
  public void EnablePnPEventCallback() { EnablePnPEventCallback(PnPEventCallback); }

  protected NeoImageCallbackHandler image_callback_ = new NeoImageCallbackHandler();
  public NeoImageCallbackHandler ImageCallback { get { return image_callback_; } }

  protected NeoEventCallbackHandler pnp_event_callback_ = new NeoEventCallbackHandler();
  public NeoEventCallbackHandler PnPEventCallback { get { return pnp_event_callback_; } }

  protected System.Collections.Generic.Dictionary<string, NeoEventCallbackHandler> device_event_callbacks_ = new System.Collections.Generic.Dictionary<string, NeoEventCallbackHandler>();
  public NeoEventCallbackHandler DeviceEventCallback { get { if(!device_event_callbacks_.ContainsKey("")) {device_event_callbacks_[""] = new NeoEventCallbackHandler();} return device_event_callbacks_[""]; } }
  public void EnableEventCallback(string name = "") { if(!device_event_callbacks_.ContainsKey(name)) {device_event_callbacks_[name] = new NeoEventCallbackHandler();} EnableEventCallback(device_event_callbacks_[name], new NeoString(name)); }

  private object parentReference;
  internal void addReference(object parent) {
    parentReference = parent;
  }

  public virtual CamBase Connect(NeoString identifier) {
    CamBase ret = _Connect(identifier);
    if (neoapi_csharpPINVOKE.SWIGPendingException.Pending) throw neoapi_csharpPINVOKE.SWIGPendingException.Retrieve();
    ret.addReference(this);
    return ret;
  }

  public virtual CamBase Connect() {
    CamBase ret = _Connect();
    if (neoapi_csharpPINVOKE.SWIGPendingException.Pending) throw neoapi_csharpPINVOKE.SWIGPendingException.Retrieve();
    ret.addReference(this);
    return ret;
  }

  public virtual CamBase Disconnect() {
    CamBase ret = _Disconnect();
    if (neoapi_csharpPINVOKE.SWIGPendingException.Pending) throw neoapi_csharpPINVOKE.SWIGPendingException.Retrieve();
    ret.addReference(this);
    return ret;
  }

  // Fallback property f if Getf exists in derived Cam
  public FeatureAccess f {
    get {
        if (this is Cam cam) return cam.Getf();
        throw new System.NotImplementedException("FeatureAccess is only available on Cam instance");
    }
  }

  public System.Collections.Generic.List<string> AvailableChunks {
    get {
        var result = new System.Collections.Generic.List<string>();
        var list = GetAvailableChunks();
        uint sz = list.size();
        for (uint i = 0; i < sz; ++i) result.Add(list.GetAt(i).ToString());
        return result;
    }
  }

  public System.Collections.Generic.List<string> AvailableEvents {
    get {
        var result = new System.Collections.Generic.List<string>();
        var list = GetAvailableEvents();
        uint sz = list.size();
        for (uint i = 0; i < sz; ++i) result.Add(list.GetAt(i).ToString());
        return result;
    }
  }

  public System.Collections.Generic.List<string> EnabledEvents {
    get {
        var result = new System.Collections.Generic.List<string>();
        var list = GetEnabledEvents();
        uint sz = list.size();
        for (uint i = 0; i < sz; ++i) result.Add(list.GetAt(i).ToString());
        return result;
    }
  }
%}

%typemap(cscode) NeoAPI::CamInfo %{
  public string Id { get { return GetId(); } }
  public string ModelName { get { return GetModelName(); } }
  public string SerialNumber { get { return GetSerialNumber(); } }
  public string TLType { get { return GetTLType(); } }
  public string VendorName { get { return GetVendorName(); } }
  public string USB3VisionGUID { get { return GetUSB3VisionGUID(); } }
  public string USBPortID { get { return GetUSBPortID(); } }
  public string GevIpAddress { get { return GetGevIpAddress(); } }
  public string GevSubnetMask { get { return GetGevSubnetMask(); } }
  public string GevGateway { get { return GetGevGateway(); } }
  public string GevMACAddress { get { return GetGevMACAddress(); } }
  public bool IsConnectable { get { return GetIsConnectable(); } }
%}

// Rename methods to avoid name conflicts with properties
%rename(GetIsEmpty) NeoAPI::Image::IsEmpty;
%rename(GetIsLastImage) NeoAPI::Image::IsLastImage;
%rename(_GetAvailablePixelFormats) NeoAPI::Image::GetAvailablePixelFormats;
%rename(_GetChunkList) NeoAPI::Image::GetChunkList;
%rename(_IsSegmentShared) NeoAPI::ImageInfo::IsSegmentShared;

// Ergonomic properties and methods for ImageInfo
%typemap(cscode) NeoAPI::ImageInfo %{
  /// <summary>
  /// The height of the image in pixel, returns zero as long the image is not filled with data
  /// </summary>
  public ulong Height { get { return GetHeight(); } }

  /// <summary>
  /// The y offset in pixel
  /// </summary>
  public ulong YOffset { get { return GetYOffset(); } }

  /// <summary>
  /// The number of extra bytes transmitted at the end of the image
  /// </summary>
  public ulong YPadding { get { return GetYPadding(); } }

  /// <summary>
  /// The width of the image in pixel, returns zero as long the image is not filled with data
  /// </summary>
  public ulong Width { get { return GetWidth(); } }

  /// <summary>
  /// The x offset in pixel
  /// </summary>
  public ulong XOffset { get { return GetXOffset(); } }

  /// <summary>
  /// The the number of extra bytes transmitted at the end of each line
  /// </summary>
  public ulong XPadding { get { return GetXPadding(); } }

  /// <summary>
  /// The pixelformat of the image, returns an empty string as long the image is not filled with data
  /// </summary>
  public string PixelFormat { get { return GetPixelFormat(); } }

  /// <summary>
  /// Get the whole size of the image in bytes
  /// </summary>
  public ulong Size { get { return GetSize(); } }

  /// <summary>
  /// The group id of the image
  /// </summary>
  public ulong GroupID { get { return GetGroupID(); } }

  /// <summary>
  /// The source id of the image
  /// </summary>
  public ulong SourceID { get { return GetSourceID(); } }

  /// <summary>
  /// The region id of the image
  /// </summary>
  public ulong RegionID { get { return GetRegionID(); } }

  /// <summary>
  /// give information if the memory segment in a buffer is shared with other components
  /// </summary>
  public bool IsSegmentShared { get { return _IsSegmentShared(); } }

  /// <summary>
  /// The image data offset related to the begin of the memory segment in the buffer
  /// </summary>
  public ulong SegmentOffset { get { return GetSegmentOffset(); } }

  /// <summary>
  /// The whole size of the memory segment in the buffer
  /// </summary>
  public ulong SegmentSize { get { return GetSegmentSize(); } }

  /// <summary>
  /// The index of the memory segment in the buffer
  /// </summary>
  public uint SegmentIndex { get { return GetSegmentIndex(); } }

  /// <summary>
  /// Get compression method of the image
  /// </summary>
  public NeoImageCompression Compression { get { return GetCompression(); } }
%}

// Ergonomic properties and methods for Image
%typemap(cscode) NeoAPI::Image %{
  /// <summary>
  /// Check if the image is empty or filled with data
  /// </summary>
  public bool IsEmpty { get { return GetIsEmpty(); } }

  /// <summary>
  /// gives information if this image is the last image in a buffer
  /// </summary>
  public bool IsLastImage { get { return GetIsLastImage(); } }

  /// <summary>
  /// Get the Index of the image inside the buffer, returns zero as long the image is not filled with data
  /// </summary>
  public ulong ImageIndex { get { return GetImageIndex(); } }

  /// <summary>
  /// Get the ID of the buffer, returns zero as long the image is not filled with data
  /// </summary>
  public ulong BufferID { get { return GetBufferID(); } }

  /// <summary>
  /// Get the timestamp of the image, returns zero as long the image is not filled with data
  /// </summary>
  public ulong Timestamp { get { return GetTimestamp(); } }

  /// <summary>
  /// Get a pointer to the image data, returns nullptr as long as the image is not filled with data.
  /// </summary>
  public global::System.IntPtr ImageData {
    get {
        return neoapi_csharpPINVOKE.Image_GetImageData(swigCPtr);
    }
  }

  /// <summary>
  /// Get a list with available PixelFormats for Convert
  /// </summary>
  /// <returns>list of available PixelFormats</returns>
  public System.Collections.Generic.List<string> GetAvailablePixelFormats() {
    System.Collections.Generic.List<string> result = new System.Collections.Generic.List<string>();
    NeoStringList list = _GetAvailablePixelFormats();
    uint sz = list.size();
    for (uint i = 0; i < sz; ++i) result.Add(list.GetAt(i));
    return result;
  }

  /// <summary>
  /// Get a list of all available chunk features of the image
  /// </summary>
  /// <returns>A list of available chunk features</returns>
  public System.Collections.Generic.Dictionary<string, Feature> GetChunkList() {
    System.Collections.Generic.Dictionary<string, Feature> result = new System.Collections.Generic.Dictionary<string, Feature>();
    FeatureList list = _GetChunkList();
    foreach (Feature f in list) {
        result.Add(f.GetName(), f);
    }
    return result;
  }

  /// <summary>
  /// Get access to a object inherited by NeoAPI.BufferBase and used by this image.
  /// </summary>
  /// <returns>UserBuffer object</returns>
  protected BufferBase user_buffer_ = null;
  public T GetUserBuffer<T>() where T : class {
    return user_buffer_ as T;
  }

  private object parentReference;
  internal void addReference(object parent) {
    parentReference = parent;
  }
%}

%typemap(cscode) NeoAPI::CamInfoList %{
    protected System.Collections.Generic.List<CamInfo> cam_info_list_ = null;
    public System.Collections.ObjectModel.ReadOnlyCollection<CamInfo> List
    {
        get
        {
            if(cam_info_list_ == null) {
                cam_info_list_ = new System.Collections.Generic.List<CamInfo>();
                uint list_size = size();
                for (uint index = 0; index < list_size; index++)
                {
                    cam_info_list_.Add(IndexToCamInfo(index));
                }
            }
            return cam_info_list_.AsReadOnly();
        }
    }

    public System.Collections.Generic.IEnumerator<CamInfo> GetEnumerator()
    {
        return List.GetEnumerator();
    }

    public CamInfo this[int index]
    {
        get { return List[index]; }
    }
%}

// NeoString support
%typemap(cscode) NeoAPI::NeoString %{
  public override string ToString() {
    return c_str();
  }

  public static implicit operator string(NeoString s) {
    return s?.c_str();
  }

  public static implicit operator NeoString(string s) {
    return new NeoString(s);
  }
%}

// Feature Feature Properties
%typemap(cscode) NeoAPI::BaseFeature %{
  public bool IsReadable { get { return GetIsReadable(); } }
  public bool IsWritable { get { return GetIsWritable(); } }
  public bool IsAvailable { get { return GetIsAvailable(); } }
  // IsSelector removed from BaseFeature to avoid issues
  public string Name { get { return GetName(); } }
  public string DisplayName { get { return GetDisplayName(); } }
  public string Description { get { return GetDescription(); } }
  public string ToolTip { get { return GetToolTip(); } }
  public string Visibility { get { return GetVisibility(); } }
  public string Interface { get { return GetInterface(); } }
%}

%typemap(cscode) NeoAPI::DoubleFeature %{
  public double Value { get { return Get(); } set { Set(value); } }
  public double Min { get { return GetMin(); } }
  public double Max { get { return GetMax(); } }
  public double Inc { get { return GetInc(); } }
  public ulong Precision { get { return GetPrecision(); } }
  public string ValueString { get { return GetString(); } }
  public string Unit { get { return GetUnit(); } }
  public string Representation { get { return GetRepresentation(); } }
%}

%typemap(cscode) NeoAPI::IntegerFeature %{
  public long Value { get { return Get(); } set { Set(value); } }
  public long Min { get { return GetMin(); } }
  public long Max { get { return GetMax(); } }
  public long Inc { get { return GetInc(); } }
  public string ValueString { get { return GetString(); } }
  public string Unit { get { return GetUnit(); } }
  public string Representation { get { return GetRepresentation(); } }
  public bool IsSelector { get { return GetIsSelector(); } }
%}

%typemap(cscode) NeoAPI::BoolFeature %{
  public bool Value { get { return Get(); } set { Set(value); } }
  public string ValueString { get { return GetString(); } }
%}

%typemap(cscode) NeoAPI::StringFeature %{
  public string Value { get { return GetString(); } set { SetString(value); } }
  public long MaxStringLength { get { return GetMaxStringLength(); } }
%}

%typemap(cscode) NeoAPI::EnumerationFeature %{
  public long ValueInt { get { return GetInt(); } set { SetInt(value); } }
  public string ValueString { get { return GetString(); } set { SetString(value); } }
  public FeatureList EnumValueList { get { return GetEnumValueList(); } }
  public bool IsSelector { get { return GetIsSelector(); } }
%}

%typemap(cscode) NeoAPI::CommandFeature %{
  public bool IsDone { get { return GetIsDone(); } }
%}

%typemap(cscode) NeoAPI::CPixelFormat %{
  public PixelFormat Value { get { return Get(); } set { Set(value); } }
%}

%typemap(csinterfaces) NeoAPI::FeatureList "global::System.Collections.Generic.IEnumerable<Feature>, global::System.Collections.IEnumerable";

%typemap(cscode) NeoAPI::FeatureList %{
  public System.Collections.Generic.IEnumerator<Feature> GetEnumerator() {
    for (FeatureListIterator it = begin(); !it.op_Equal(end()); it.operator_increment()) {
      yield return it.GetFeature();
    }
  }
  System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => GetEnumerator();
%}

// Extensions
%extend NeoAPI::CamInfoList {
    NeoAPI::CamInfo IndexToCamInfo(uint32_t index) {
        return (*\$self)[(size_t)index];
    }
}

%extend NeoAPI::NeoStringList {
    NeoAPI::NeoString GetAt(uint32_t index) {
        return (*\$self)[(size_t)index];
    }
}

// Inclusions
%include "neoapi/neoapi_common.hpp"
%include "neoapi/neoapi_feature.hpp"
%include "neoapi/neoapi_image_info.hpp"
%include "neoapi/neoapi_image.hpp"
%include "neoapi/neoapi_event.hpp"
%include "neoapi/neoapi_featureaccess.hpp"
%include "neoapi/neoapi_trace.hpp"
%include "neoapi/neoapi_camera.hpp"
%include "neoapi/neoapi_camera_info.hpp"
%include "neoapi/neoapi_image_converter.hpp"
%include "neoapi/neoapi.hpp"
EOF

# Create the extra event handler classes
echo "Generating extra_handlers.cs..."
cat <<EOF > extra_handlers.cs
namespace NeoAPI_Linux {
  public class ImageEventArgs : System.EventArgs {
    public Image Image { get; set; }
  }

  public class NeoImageCallbackHandler : NeoImageCallback {
    public override void ImageCallback(Image image) {
      System.EventHandler<ImageEventArgs> handler = Handler;
      if (handler != null) {
        ImageEventArgs args = new ImageEventArgs();
        args.Image = image;
        handler(this, args);
      }
    }
    public event System.EventHandler<ImageEventArgs> Handler;
  }

  public class NeoEventEventArgs : System.EventArgs {
    public NeoEvent Event { get; set; }
  }

  public class NeoEventCallbackHandler : NeoEventCallback {
    public override void EventCallback(NeoEvent neoevent) {
      System.EventHandler<NeoEventEventArgs> handler = Handler;
      if (handler != null) {
        NeoEventEventArgs args = new NeoEventEventArgs();
        args.Event = neoevent;
        handler(this, args);
      }
    }
    public event System.EventHandler<NeoEventEventArgs> Handler;
  }
}
EOF

echo "Done! $INTERFACE_FILE and extra_handlers.cs have been generated."