# Using EGrabberBridge

This code snippet shows how to go from an EGrabber buffer to an EGrabberImageBW8, compatible with eVision processing.

## C++

```cpp
#include <EGrabber.h>
#include <FormatConverter.h>
#include <eVision/EasyImage/EasyImage.h>
#include <eVision/EGrabberBridge.h>
```

```cpp
using namespace eVision;
using namespace Euresys;

// Construct the EGrabber objects.
// The FormatConverter is optional and will automatically convert the EGenTL buffer to
// the chosen eVision image type
// WARNING: EGrabberCallbackOnDemand and FormatConverter are using an EGenTL instance, you must dispose them before disposing it.
EGenTL genTL;
EGrabber<CallbackOnDemand> grabber(genTL);

// Allocate one buffer
grabber.reallocBuffers(1);

//...

// Start the grabber acquisition of one buffer
grabber.start(1);

// Get the acquired buffer
ScopedBuffer buffer(grabber);

// Convert the ScopedBuffer to an eVision data container
EGrabberBridge::EGrabberImageBW8 image(buffer.getInfo());

// Stop the grabber
grabber.stop();

// Use the EGrabberImageBW8 as an eVision EImage Object
// Here an inversion of the image is performed
EImageBW8 invertedImage(image.GetWidth(), image.GetHeight());
EasyImage::Oper(EArithmeticLogicOperation_Invert, &image, &invertedImage);
```

## C#

```cs
using Euresys;
using Euresys.EGrabber;
using eVision;
using System;
```

```cs
// Construct the EGrabber objects.
// WARNING: EGrabber is using an EGenTL instance,
// you must dispose of EGenTL before disposing of EGrabber.
Euresys.EGrabber.EGenTL genTL = new Euresys.EGrabber.EGenTL();
EGrabber grabber = new EGrabber(genTL);

// Allocate one buffer
grabber.ReallocBuffers(1);

//....

// Start the grabber acquisition of one buffer
grabber.Start(1);

// Get the acquired buffer
using (Euresys.EGrabber.ScopedBuffer buffer = new Euresys.EGrabber.ScopedBuffer(grabber))
{
  // Convert the ScopedBuffer to an eVision data container
  ulong width = (ulong)buffer.GetInfo<SizeT>(BUFFER_INFO_CMD.BUFFER_INFO_WIDTH);
  ulong height = (ulong)buffer.GetInfo<SizeT>(BUFFER_INFO_CMD.BUFFER_INFO_HEIGHT);
  IntPtr ptr = buffer.GetInfo<IntPtr>(BUFFER_INFO_CMD.BUFFER_INFO_BASE);
  ulong pitch = (ulong)buffer.GetInfo<SizeT>(BUFFER_INFO_CMD.BUFFER_INFO_CUSTOM_LINE_PITCH);

  EImageBW8 image = new EImageBW8();
  image.UseExternalBuffer((int)width, (int)height, ptr, (int)pitch);

  // Here the image is inverted
  EImageBW8 invertedImage = new EImageBW8(image.Width, image.Height);
  EasyImage.Oper(EArithmeticLogicOperation.Invert, image, invertedImage);
}
```

## Python

```py
import eVision
import egrabber
import egentl

# Construct the EGrabber objects.
genTL = egentl.EGenTL()
grabber = egrabber.EGrabber(genTL)

# Allocate one buffer
grabber.realloc_buffers(1)

# ...

# Start the grabber acquisition of one buffer
grabber.start(1)

# Get the acquired buffer
with egrabber.Buffer(grabber) as buffer:
    # Convert the ScopedBuffer to an eVision data container
    w = buffer.get_info(egrabber.BUFFER_INFO_WIDTH, egrabber.INFO_DATATYPE_SIZET)
    h = buffer.get_info(egrabber.BUFFER_INFO_HEIGHT, egrabber.INFO_DATATYPE_SIZET)
    ptr = buffer.get_info(egrabber.BUFFER_INFO_BASE, egrabber.INFO_DATATYPE_PTR)
    pitch = buffer.get_info(egrabber.BUFFER_INFO_CUSTOM_LINE_PITCH, egrabber.INFO_DATATYPE_SIZET)

    image = eVision.EImageBW8()
    image.UseExternalBuffer(w, h, ptr, pitch)

    # Here an inversion to the image is performed
    inverted_image = eVision.EImageBW8(image.Width, image.Height)
    eVision.EasyImage.Oper(eVision.EArithmeticLogicOperation.Invert, image, inverted_image)
```