# Using EGrabberBridge with Format Conversion

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

## 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);
FormatConverter converter(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(converter, 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.EGrabber;
using eVision;
```

```cs
// Construct the EGrabber objects.
// WARNING: EGrabber is using an EGenTL instance,
// you must dispose of EGenTL before disposing of EGrabber.
EGenTL genTL = new 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 (ScopedBuffer buffer = new ScopedBuffer(grabber))
{
  // Convert the ScopedBuffer to a ConvertedBuffer
  ConvertedBuffer converted = buffer.Convert("Mono8");

  EImageBW8 image = new EImageBW8();
  image.UseExternalBuffer(converted.Width, converted.Height, converted.Pixels, converted.LinePitch);

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

## Python

```py
import ctypes
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 Buffer to a ConvertedBuffer
    converted = buffer.convert('Mono8')

    image = eVision.EImageBW8()
    data = ctypes.cast(converted.get_address(), ctypes.c_void_p)
    image.UseExternalBuffer(converted.width, converted.height, data, converted.line_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)
```