Open eVision

https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us
Admin
Open eVision is a comprehensive machine vision software platform offering a wide range of tools for...
Tokens:3,398,798
Snippets:27,787
Trust Score:9.5
Update:3 months ago
Show doc for...
Tokens:
Raw
### Retrieve Sample Programs Root Path

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/reference/easy-sampleprogramsrootpath.htm

Access the installation directory for sample programs. Use this to locate resources or example files provided with the Open eVision installation.

```C++
std::string GetSampleProgramsRootPath()
```

```C#
static string SampleProgramsRootPath
{ get; }
```

```Python
@staticmethod  
GetSampleProgramsRootPath() -> str
```

--------------------------------

### Install sample dependencies

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/03_Using/1_Starting_Up/2_Using_Open_eVision/Using_Open_eVision_in_Python.htm?TocPath=Using+Open+eVision%7CUsing+Open+eVision%7C_____3

Install required Python packages for sample programs using the provided requirements file.

```bash
pip install –r ./requirements.txt
```

--------------------------------

### Install Open eVision Python bindings

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/03_Using/1_Starting_Up/2_Using_Open_eVision/Using_Open_eVision_in_Python.htm?TocPath=Using+Open+eVision%7CUsing+Open+eVision%7C_____3

Use pip to install the Open eVision wheel file on Windows or Linux.

```bash
pip install “C:\Program Files\Euresys\Open eVision X.Y\Python\ open_evision-VERSION-PLATFORM.whl”
```

```bash
pip install /opt/euresys/Open_eVision_X_Y/Python/open_evision-VERSION-PLATFORM.whl”
```

--------------------------------

### Easy::GetSampleImagesRootPath

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/reference/easy-sampleimagesrootpath.htm

Retrieves the sample images installation path.

```APIDOC
## Easy::GetSampleImagesRootPath

### Description
Retrieves the sample images installation path.

### Signatures

#### C++
`std::string GetSampleImagesRootPath()`

#### .NET (C#)
`static string SampleImagesRootPath { get; }`

#### Python
`@staticmethod GetSampleImagesRootPath() -> str`
```

--------------------------------

### GetSampleProgramsRootPath

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/reference/easy-sampleprogramsrootpath.htm?TocPath=Reference%7CClasses%7CEasy+Class%7C_____30

Retrieves the sample programs installation path.

```APIDOC
## Easy::GetSampleProgramsRootPath

### Description
Retrieves the sample programs installation path.

### Signature
- **C++**: `std::string GetSampleProgramsRootPath()`
- **.NET (C#)**: `static string SampleProgramsRootPath { get; }`
- **Python**: `@staticmethod GetSampleProgramsRootPath() -> str`

### Namespace/Module
- **C++/C#**: Euresys::Open_eVision
- **Python**: open_evision
```

--------------------------------

### Easy Object Installation Path Properties

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/03_Using/1_Starting_Up/5_Basic_Operations/Retrieving_the_Installation_Folders_Programmatically.htm

The Easy object provides static properties to retrieve the root installation paths for various components.

```APIDOC
## Easy Object Installation Properties

### Description
Retrieve the root installation paths for sample images, sample programs, and resources.

### Properties
- **Easy.SampleImagesRootPath** (string) - Returns the installation path for sample images.
- **Easy.SampleProgramsRootPath** (string) - Returns the installation path for sample programs.
- **Easy.ResourcesRootPath** (string) - Returns the installation path for resources.
```

--------------------------------

### Build a sample list in C#

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/03_Using/4_Text_and_Code_Reading/4_EasyDeepOCR/Building_a_Sample_List.htm

Demonstrates the hierarchical initialization of ESampleList, ESample, EText, and ETextLine objects.

```csharp
using Euresys.Open_eVision;
using EDO = Euresys.Open_eVision.EasyDeepOCR;

static partial class Snippet
{
  static void BuildingASampleList()
  {
    ////////////////////////////////////////////////////////
    // This code snippet shows how to fill a sample list. //
    ////////////////////////////////////////////////////////
    // Create an ESampleList
    EDO.ESampleList sampleList = new EDO.ESampleList();
    // Create an ESample vector
    EDO.ESample[] samples = new EDO.ESample[1];
    // Fill the ESample vector
    foreach (EDO.ESample sample in samples) 
    {
      // Set the image
      sample.ImagePath = "image.tif";
      // Create an EText vector 
      EDO.EText[] texts = new EDO.EText[1];
      // Fill the EText vector
      foreach (EDO.EText text in texts)
      {
        // Create an ETextLine vector
        EDO.ETextLine[] textLines = new EDO.ETextLine[1];
        // Fill the ETextLine vector
        foreach (EDO.ETextLine textLine in textLines)
        {
          // Adjust the ERectangle around the text line
          textLine.Rectangle = new ERectangle();
          // Annotate the text line
          textLine.String = "";
        }
        // Set the ETextLine vector
        text.Lines = textLines;
      }
      // Set the EText vector
      sample.Texts = texts;
    }
    // Set the ESample vector
    sampleList.Samples = samples;
    // ...
  }
}
```

--------------------------------

### Get ECircle OrgAngle in C++

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/reference/ecircle-organgle.htm

Retrieves the starting angular position of the circle as a float.

```C++
float GetOrgAngle() const
```

--------------------------------

### Get EWedge OrgAngle

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/reference/legacy.ewedge-organgle.htm

Access the starting angular position of an EWedge across different programming languages.

```C++
float GetOrgAngle() const
```

```C#
float OrgAngle
{ get; }
```

```Python
OrgAngle: float 
{get} 
```

--------------------------------

### GetDeepLearningAdditionalResourcesRootPath

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/reference/easy-deeplearningadditionalresourcesrootpath.htm?TocPath=Reference%7CClasses%7CEasy+Class%7C_____6

Retrieves the installation path for deep learning additional resources. These resources are installed via a separate installer provided by Euresys.

```APIDOC
## GetDeepLearningAdditionalResourcesRootPath

### Description
Retrieves the deep learning additional resources installation path.

### Signatures

#### C++
`std::string GetDeepLearningAdditionalResourcesRootPath()`

#### .NET (C#)
`static string DeepLearningAdditionalResourcesRootPath { get; }`

#### Python
`@staticmethod GetDeepLearningAdditionalResourcesRootPath() -> str`

### Remarks
The deep learning additional resources are installed through their own installer, available on the Euresys website.
```

--------------------------------

### Create and set a topology in Python

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/03_Using/4_Text_and_Code_Reading/4_EasyDeepOCR/Specifying_a_Topology.htm?TocPath=Using+Open+eVision%7CText+and+Code+Reading+Tools%7CEasyDeepOCR+-+Reading+Texts+with+Deep+Learning%7C_____7

Demonstrates the initialization of topology lines using the Euresys simplified format and applying them to an ETextReader instance.

```python
def SpecifyingATopology():
  ################################################################
  ## This code snippet shows how to create and set a topology.  ##
  ################################################################
  import open_evision as oev
  from open_evision import EasyDeepOCR as EDO
  # Create an ETopologyLine list
  topologyLines = []
  # Fill the vector
  topologyLines.append(EDO.ETopologyLine("[Lot:] 00[-]0{1,3}"))
  topologyLines.append(EDO.ETopologyLine("[Exp:] 00[/]0[/]0{4}"))
  # Create an ETopology instance
  topology = EDO.ETopology()
  # Set the lines
  topology.TopologyLines = topologyLines
  # Create an ETextReader instance
  reader = EDO.ETextReader()
  # Set the topology
  reader.Topology = topology
  # ...
```

--------------------------------

### GetDeepLearningAdditionalResourcesRootPath

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/reference/easy-deeplearningadditionalresourcesrootpath.htm

Retrieves the deep learning additional resources installation path. These resources are installed via a separate installer available on the Euresys website.

```APIDOC
## GetDeepLearningAdditionalResourcesRootPath

### Description
Retrieves the installation path for deep learning additional resources.

### Signatures

#### C++
`std::string GetDeepLearningAdditionalResourcesRootPath()`

#### .NET (C#)
`static string DeepLearningAdditionalResourcesRootPath { get; }`

#### Python
`@staticmethod GetDeepLearningAdditionalResourcesRootPath() -> str`

### Remarks
The deep learning additional resources are installed through their own installer, available on the Euresys website.
```

--------------------------------

### Performing an Optimization with EasyDeepOCR

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/05_Resources/02_Code_Snippets/24_EasyDeepOCR/Performing_an_Optimization.htm?TocPath=Resources%7CCode+Snippets%7CEasyDeepOCR%7C_____4

Demonstrates the process of initializing an ETextReader and running an optimization using an ESampleList.

```csharp
using Euresys.Open_eVision;
using EDO = Euresys.Open_eVision.EasyDeepOCR;

static partial class Snippet
{
  static void PerformingAnOptimization()
  {
    ///////////////////////////////////////////////////////////////
    // This code snippet shows how to perform an optimization.   //
    ///////////////////////////////////////////////////////////////
    // Create an ESample vector
    EDO.ESample[] samples = new EDO.ESample[] { } ;
    // Fill the vector
    // ...
    // Create an ESampleList instance
    EDO.ESampleList sampleList = new EDO.ESampleList();
    // Set the samples
    sampleList.Samples = samples;
    // Create an ETextReader instance
    EDO.ETextReader reader = new EDO.ETextReader();
    // Initialize the ETextReader
    reader.Initialize();
    // Optimize the ETextReader
    EDO.EOptimizationReport report = reader.Optimize(sampleList); 
    // ...
  }
}
```

```cpp
#include <Open_eVision.h>

void PerformingAnOptimization()
{
  ///////////////////////////////////////////////////////////////
  // This code snippet shows how to perform an optimization.   //
  ///////////////////////////////////////////////////////////////
  using namespace Euresys::Open_eVision;
  namespace EDO = Euresys::Open_eVision::EasyDeepOCR;
  // Create an ESample vector
  std::vector<EDO::ESample> samples;
  // Fill the vector
  // ...
  // Create an ESampleList instance
  EDO::ESampleList sampleList;
  // Set the samples
  sampleList.SetSamples(samples);
  // Create an ETextReader instance
  EDO::ETextReader reader;
  // Initialize the ETextReader
  reader.Initialize();
  // Optimize the ETextReader
  EDO::EOptimizationReport report = reader.Optimize(sampleList); 
  // ...
}
```

```python
def PerformingAnOptimization():
  ################################################################
  ## This code snippet shows how to perform an optimization.    ##
  ################################################################
  import open_evision as oev
  from open_evision import EasyDeepOCR as EDO
  # Create an ESample vector
  samples = []
  # Fill the vector
  # ...
  # Create an ESampleList instance
  sampleList = EDO.ESampleList()
  # Set the samples
  sampleList.Samples = samples
  # Create an ETextReader instance
  reader = EDO.ETextReader()
  # Initialize the ETextReader
  reader.Initialize()
  # Optimize the ETextReader
  report = reader.Optimize(sampleList); 
  # ...
```

--------------------------------

### Retrieve Deep Learning Resources Path

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/reference/easy-deeplearningadditionalresourcesrootpath.htm

Access the installation directory for deep learning additional resources. Ensure the resources are installed via the official Euresys installer.

```cpp
std::string GetDeepLearningAdditionalResourcesRootPath()
```

```csharp
static string DeepLearningAdditionalResourcesRootPath
{ get; }
```

```python
@staticmethod  
GetDeepLearningAdditionalResourcesRootPath() -> str
```

--------------------------------

### Install pip on Debian-based Linux

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/03_Using/1_Starting_Up/2_Using_Open_eVision/Using_Open_eVision_in_Python.htm?TocPath=Using+Open+eVision%7CUsing+Open+eVision%7C_____3

Install the pip package manager if it is not available by default.

```bash
sudo apt install python3-pip
```

--------------------------------

### Building a Sample List in C#, C++, and Python

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/05_Resources/02_Code_Snippets/24_EasyDeepOCR/Building_a_Sample_List.htm?TocPath=Resources%7CCode+Snippets%7CEasyDeepOCR%7C_____3

These snippets demonstrate the hierarchical structure required to populate an ESampleList, including setting image paths and defining text line rectangles.

```csharp
using Euresys.Open_eVision;
using EDO = Euresys.Open_eVision.EasyDeepOCR;

static partial class Snippet
{
  static void BuildingASampleList()
  {
    ////////////////////////////////////////////////////////
    // This code snippet shows how to fill a sample list. //
    ////////////////////////////////////////////////////////
    // Create an ESampleList
    EDO.ESampleList sampleList = new EDO.ESampleList();
    // Create an ESample vector
    EDO.ESample[] samples = new EDO.ESample[1];
    // Fill the ESample vector
    foreach (EDO.ESample sample in samples) 
    {
      // Set the image
      sample.ImagePath = "image.tif";
      // Create an EText vector 
      EDO.EText[] texts = new EDO.EText[1];
      // Fill the EText vector
      foreach (EDO.EText text in texts)
      {
        // Create an ETextLine vector
        EDO.ETextLine[] textLines = new EDO.ETextLine[1];
        // Fill the ETextLine vector
        foreach (EDO.ETextLine textLine in textLines)
        {
          // Adjust the ERectangle around the text line
          textLine.Rectangle = new ERectangle();
          // Annotate the text line
          textLine.String = "";
        }
        // Set the ETextLine vector
        text.Lines = textLines;
      }
      // Set the EText vector
      sample.Texts = texts;
    }
    // Set the ESample vector
    sampleList.Samples = samples;
    // ...
  }
}
```

```cpp
#include <Open_eVision.h>

void BuildingASampleList()
{
  ////////////////////////////////////////////////////////
  // This code snippet shows how to fill a sample list. //
  ////////////////////////////////////////////////////////
  using namespace Euresys::Open_eVision;
  namespace EDO = Euresys::Open_eVision::EasyDeepOCR;
  // Create an ESampleList
  EDO::ESampleList sampleList;
  // Create an ESample vector
  std::vector<EDO::ESample> samples(1);
  // Fill the ESample vector
  for (EDO::ESample& sample : samples)
  {
    // Set the image
    sample.SetImagePath("image.tif");
    // Create an EText vector 
    std::vector<EDO::EText> texts(1);
    // Fill the EText vector
    for (EDO::EText& text : texts)
    {
      // Create an ETextLine vector
      std::vector<EDO::ETextLine> textLines(1);
      // Fill the ETextLine vector
      for (EDO::ETextLine& textLine : textLines)
      {
        // Adjust the ERectangle around the text line
        textLine.SetRectangle(ERectangle());
        // Annotate the text line
        textLine.SetString("");
      }
      // Set the ETextLine vector
      text.SetLines(textLines);
    }
    // Set the EText vector
    sample.SetTexts(texts);
  }
  // Set the ESample vector
  sampleList.SetSamples(samples);
  // ...
}
```

```python
def BuildingASampleList():
  #########################################################
  ## This code snippet shows how to fill a sample list.  ##
  #########################################################
  import open_evision as oev
  from open_evision import EasyDeepOCR as EDO
  # Create an ESampleList
  sampleList = EDO.ESampleList()
  # Create an ESample vector
  samples = [EDO.ESample()]
  # Fill the ESample vector
  for sample in samples: 
    # Set the image
    sample.ImagePath = "image.tif"
    # Create an EText vector 
    texts = [EDO.EText()]
    # Fill the EText vector
    for text in texts:
      # Create an ETextLine vector
      textLines = [EDO.ETextLine()]
      # Fill the ETextLine vector
      for textLine in textLines:
        # Adjust the ERectangle around the text line
        textLine.Rectangle = oev.ERectangle()
        # Annotate the text line
        textLine.String = ""
      # Set the ETextLine vector
      text.Lines = textLines
    # Set the EText vector
    sample.Texts = texts
  # Set the ESample vector
  sampleList.Samples = samples
  # ...
```

--------------------------------

### Start CodeMeter Service on Linux

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/15_Neo_Licensing_System/Neo_Licensing__System_FAQ.htm?TocPath=Getting+Started%7C_____30

Use this command to manually start the CodeMeter service if it is not running.

```bash
> sudo systemctl start codemeter.service
```

--------------------------------

### Display Neo License Manager help

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/15_Neo_Licensing_System/Using_the_Online_Command_Line.htm?TocPath=Getting+Started%7C_____28

Use the --help argument to view the syntax and available subcommands for the command line tool.

```bash
> NeoLicenseManagerCL.exe --help

Neo License Manager 2
Usage: C:\Program Files\Euresys\NeoLicenseManager\NeoLicenseManagerCL.exe [OPTIONS] SUBCOMMAND
 
Options:
  --console-log               Activates console log
  --file-log TEXT             Activates file log; a path to the desired log file must be specified as argument
  -h,--help
 
Subcommands:
list-containers
  Returns the list of containers
  Options:
    --filter TEXT:{dongle,software}
                                Type of containers to be checked (dongle/software)
    -e,--expert                 Enables expert mode
 
list-licenses
  Returns the list of licenses
  Options:
    -s,--serial-number TEXT     Serial number of a specific container to be checked
    -l,--list-empty-containers  List containers even if they contain no license
    -e,--expert                 Enables expert mode
 
apply-license-file
  Applies the given activation file to the software container of your computer
  Options:
    -p,--path TEXT REQUIRED     Path of the license activation file
 
create-software-container
  Creates a new software container on the computer. It will only work if none were present
  Options:
    -f,--force                  Additional argument to enforce container creation. For expert users only
 
delete-software-container
  Deletes a software container on the computer, given its serial number
  Options:
    -s,--serial-number TEXT REQUIRED
                                Serial number of the software container to be deleted
 
get-container-fingerprint
  Saves the fingerprint file of the given container at the specified location
  Options:
    -s,--serial-number TEXT REQUIRED
                                Serial number of the software container we want to retrieve the fingerprint from
    -p,--path TEXT REQUIRED     File path for the creation of fingerprint
 
check-dongle-OEM-key-readiness
  Checks if the OEM key feature is available in the given container
  Options:
    -s,--serial-number TEXT REQUIRED
                                Serial number of the dongle on which we want to check OEM key readiness
 
prepare-dongle-for-OEM-key
  Prepares a given dongle for OEM key
  Options:
    -s,--serial-number TEXT REQUIRED
                                Serial number of the dongle we want to prepare for OEM key
 
check-neo-status
  Performs a global check-up of the Neo licensing system and print it
  Options:
    -p,--path TEXT              File path for the creation of report
 
activity-log
  Prints the content of the log file
 
activate
  Activates a Neo ticket ID on the given container
  Options:
    -t,--ticket TEXT REQUIRED   Id of the Neo ticket to be activated
    -s,--serial-number TEXT REQUIRED
                                Serial number of the container on which ticket will be activated
    -f,--force                  Additional argument to enforce activation. For expert users only
 
reactivate
  Reactivates a Neo ticket ID on the given container
  Options:
    -t,--ticket TEXT REQUIRED   Id of the Neo ticket to be reactivated
    -s,--serial-number TEXT REQUIRED
                                Serial number of the container on which ticket will be reactivated
    -f,--force                  Additional argument to enforce reactivation. For expert users only
 
request-activation-file
  Generates an activation file using the given Neo ticket ID and container fingerprint file. This file can then be used to proceed to an offline activation.
  Options:
    -f,--fingerprint-path TEXT REQUIRED
                                Path to the fingerprint of a container
    -p,--output-path TEXT REQUIRED
                                Path for the generated activation file
    -t,--ticket TEXT REQUIRED   Neo ticket Id
 
request-reactivation-file
  Generates a reactivation file using the given Neo ticket ID and container fingerprint file. This file can then be used to proceed to an offline reactivation.
  Options:
    -f,--fingerprint-path TEXT REQUIRED
                                Path to the fingerprint of a container
    -p,--output-path TEXT REQUIRED
                                Path for the generated reactivation file
    -t,--ticket TEXT REQUIRED   Neo ticket Id
 
apply-emergency-license
  Activates one of the three emergency licenses packages. It has a 8 days duration.
 
version
  Prints the version of Neo License Manager
 
 
End message of Neo License Manager CL
```

--------------------------------

### Detect and Classify Spots with ESpotDetector

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/05_Resources/02_Code_Snippets/50_EasySpotDetector/Detect_and_Classify_Spots.htm?TocPath=Resources%7CCode+Snippets%7CEasySpotDetector%7C_____3

Demonstrates initializing the detector, configuring particle detection parameters, setting the classifier path, and retrieving detected spots.

```csharp
using Euresys.Open_eVision;

static partial class Snippet
{
  static void ESpotDetector_DetectAndClassifySpots()
  {
    //////////////////////////////////////////////////////////
    // This code snippet shows how to detect the spots      //
    // in a image and submit them in a trained deeplearning //
    // classifier                                           //
    //////////////////////////////////////////////////////////

    // Image constructor
    EImageBW8 srcImage = new EImageBW8();

    // Spot detector constructor
    ESpotDetector detector = new ESpotDetector();

    // Setup the scratch detector parameters with adequate values
    detector.ParticleDetectionParameters = new EParticleDetectionParameters(ESpotPolarity.Any, 12, 5, 50, 25);
    detector.EnableParticleDetection = true;

    // Declare a Deep Learning classifier path
    // The classifier will be used on all detected spot during the Detect() call
    detector.DLClassifierPath = "...";

    // Perform the detection and classification, and get the number of detected spots
    uint nSpot = detector.Detect(srcImage);

    // Finally, get the detected spots
    ESpot[] spots = detector.Spots;
  }
}
```

```cpp
#include <Open_eVision.h>

void DetectAndClassifySpots()
{
  //////////////////////////////////////////////////////////
  // This code snippet shows how to detect the spots      //
  // in a image and submit them in a trained deeplearning //
  // classifier                                           //
  //////////////////////////////////////////////////////////
  using namespace Euresys::Open_eVision;

  // Image constructor
  EImageBW8 srcImage;

  // Spot detector constructor
  ESpotDetector detector;

  // Setup the scratch detector parameters with adequate values
  EParticleDetectionParameters detectionParams(ESpotPolarity_Any, 12, 5, 50, 25);
  detector.SetParticleDetectionParameters(detectionParams);
  detector.SetEnableParticleDetection(true);

  // Declare a Deep Learning classifier path
  // The classifier will be used on all detected spot during the Detect() call
  detector.SetDLClassifierPath("...");

  // Perform the detection and classification, and get the number of detected spots
  int32_t nSpot = detector.Detect(srcImage);

  // Finally, get the detected spots
  std::vector<ESpot> spots = detector.GetSpots();
}
```

```python
def ESpotDetector_DetectAndClassifySpots():
    ##########################################################
    ## This code snippet shows how to detect the spots      ##
    ## in a image and submit them in a trained deeplearning ##
    ## classifier.                                          ##
    ##########################################################

    import open_evision as oev

    # Image constructor
    srcImage = oev.EImageBW8()

    # QR code reader constructor
    detector = oev.ESpotDetector()

    # Setup the particle detector parameters with adequate values
    detector.ParticleDetectionParameters = oev.EParticleDetectionParameters(oev.ESpotPolarity.Black, 12, 5, 50, 25)
    detector.EnableParticleDetection = True

    ## Declare a Deep Learning classifier path
    ## The classifier will be used on all detected spot during the Detect() call
    detector.DLClassifierPath = "..."

    # Perform the detection and get the number of detected spots
    nSpot = detector.Detect(srcImage)

    # Finally, get the detected spots
    spots = detector.Spots
```

--------------------------------

### Get and Set ResampleChars in C++

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/reference/eocv-resamplechars.htm

Access the character resampling mode using the Get and Set methods.

```cpp
bool GetResampleChars()
void SetResampleChars(bool bResampleChars)
```

--------------------------------

### Get and Set Width in C#

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/reference/ebaseroi-width.htm

Use the Width property to get or set the width of an EBaseROI object.

```C#
int Width
{ get; set; }
```

--------------------------------

### Creating and Setting a Topology

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/03_Using/4_Text_and_Code_Reading/4_EasyDeepOCR/Specifying_a_Topology.htm?TocPath=Using+Open+eVision%7CText+and+Code+Reading+Tools%7CEasyDeepOCR+-+Reading+Texts+with+Deep+Learning%7C_____7

Demonstrates the initialization of topology lines and their assignment to an ETextReader instance.

```C++
#include <Open_eVision.h>

void SpecifyingATopology()
{
  ///////////////////////////////////////////////////////////////
  // This code snippet shows how to create and set a topology. //
  ///////////////////////////////////////////////////////////////
  using namespace Euresys::Open_eVision;
  namespace EDO = Euresys::Open_eVision::EasyDeepOCR;
  // Create an ETopologyLine vector
  std::vector<EDO::ETopologyLine> topologyLines;
  // Fill the vector
  topologyLines.emplace_back("[Lot:] 00[-]0{1,3}");
  topologyLines.emplace_back("[Exp:] 00[/]0[/]0{4}");
  // Create an ETopology instance
  EDO::ETopology topology;
  // Set the lines
  topology.SetTopologyLines(topologyLines);
  // Create an ETextReader instance
  EDO::ETextReader reader;
  // Set the topology
  reader.SetTopology(topology);
  // ...
}
```

```.NET
using Euresys.Open_eVision;
using EDO = Euresys.Open_eVision.EasyDeepOCR;

static partial class Snippet
{
  static void SpecifyingATopology()
  {
    ///////////////////////////////////////////////////////////////
    // This code snippet shows how to create and set a topology. //
    ///////////////////////////////////////////////////////////////
    // Create an ETopologyLine array
    EDO.ETopologyLine[] topologyLines = new EDO.ETopologyLine[2];
    // Fill the array
    topologyLines[0] = new EDO.ETopologyLine("[Lot:] 00[-]0{1,3}");
    topologyLines[1] = new EDO.ETopologyLine("[Exp:] 00[/]0[/]0{4}");
    // Create an ETopology instance
    EDO.ETopology topology = new EDO.ETopology();
    // Set the lines
    topology.TopologyLines = topologyLines;
    // Create an ETextReader instance
    EDO.ETextReader reader = new EDO.ETextReader();
    // Set the topology
    reader.Topology = topology;
    // ...
  }
}
```

--------------------------------

### Build a sample list in Python

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/03_Using/4_Text_and_Code_Reading/4_EasyDeepOCR/Building_a_Sample_List.htm

Demonstrates the hierarchical initialization of ESampleList, ESample, EText, and ETextLine objects using the Python API.

```python
def BuildingASampleList():
  #########################################################
  ## This code snippet shows how to fill a sample list.  ##
  #########################################################
  import open_evision as oev
  from open_evision import EasyDeepOCR as EDO
  # Create an ESampleList
  sampleList = EDO.ESampleList()
  # Create an ESample vector
  samples = [EDO.ESample()]
  # Fill the ESample vector
  for sample in samples: 
    # Set the image
    sample.ImagePath = "image.tif"
    # Create an EText vector 
    texts = [EDO.EText()]
    # Fill the EText vector
    for text in texts:
      # Create an ETextLine vector
      textLines = [EDO.ETextLine()]
      # Fill the ETextLine vector
      for textLine in textLines:
        # Adjust the ERectangle around the text line
        textLine.Rectangle = oev.ERectangle()
        # Annotate the text line
        textLine.String = ""
      # Set the ETextLine vector
      text.Lines = textLines
    # Set the EText vector
    sample.Texts = texts
  # Set the ESample vector
  sampleList.Samples = samples
  # ...
```

--------------------------------

### Get and Set Height in C#

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/reference/ebaseroi-height.htm?TocPath=Reference%7CClasses%7CEBaseROI+Class%7C_____18

Use the Height property to get or set the height of an EBaseROI object.

```C#
int Height
{ get; set; }
```

--------------------------------

### Detect Spots using EasySpotDetector

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/05_Resources/02_Code_Snippets/50_EasySpotDetector/Detect_Spots.htm?TocPath=Resources%7CCode+Snippets%7CEasySpotDetector%7C_____1

Demonstrates how to initialize the detector, configure particle detection parameters, and retrieve detected spots.

```C#
using Euresys.Open_eVision;

static partial class Snippet
{
  static void ESpotDetector_DetectSpots()
  {
    ////////////////////////////////////////////////////
    // This code snippet shows how to detect particles//
    // in an image with EasySpotDetector              //
    ////////////////////////////////////////////////////

    // Image constructor
    EImageBW8 srcImage = new EImageBW8();

    // Spot detector constructor
    ESpotDetector detector = new ESpotDetector();

    // Setup the particle detector parameters with adequate values
    EParticleDetectionParameters detectionParams;
    detectionParams.Polarity = ESpotPolarity.Black;
    detectionParams.Threshold = 12;
    detectionParams.MinSize = 5;
    detectionParams.MaxSize = 50;
    detectionParams.MinArea = 25;
    detector.ParticleDetectionParameters = detectionParams;

    // Activate the particle detection
    detector.EnableParticleDetection = true;

    // Perform the detection and get the number of detected spots
    uint nSpot = detector.Detect(srcImage);

    // Finally, get the detected spots
    ESpot[] spots = detector.Spots;
  }
}
```

```C++
#include <Open_eVision.h>

void DetectSpots()
{
  ////////////////////////////////////////////////////
  // This code snippet shows how to detect particles//
  // in an image with EasySpotDetector              //
  ////////////////////////////////////////////////////
  using namespace Euresys::Open_eVision;

  // Image constructor
  EImageBW8 srcImage;

  // Spot detector constructor
  ESpotDetector detector;

  // Setup the particle detector parameters with adequate values
  EParticleDetectionParameters detectionParams;
  detectionParams.Polarity = ESpotPolarity_Black;
  detectionParams.Threshold = 12;
  detectionParams.MinSize = 5;
  detectionParams.MaxSize = 50;
  detectionParams.MinArea = 25;
  detector.SetParticleDetectionParameters(detectionParams);

  // Activate the particle detection
  detector.SetEnableParticleDetection(true);

  // Perform the detection and get the number of detected spots
  int32_t nSpot = detector.Detect(srcImage);

  // Finally, get the detected spots
  std::vector<ESpot> spots = detector.GetSpots();
}
```

```Python
def ESpotDetector_DetectSpots():
    #####################################################
    ## This code snippet shows how to detect particles ##
    ## in an image with EasySpotDetector.              ##
    #####################################################

    import open_evision as oev

    # Image constructor
    srcImage = oev.EImageBW8()

    # QR code reader constructor
    detector = oev.ESpotDetector()

    # Setup the particle detector parameters with adequate values
    detectionParams = oev.EParticleDetectionParameters()
    detectionParams.Polarity = oev.ESpotPolarity.Black
    detectionParams.Threshold = 12
    detectionParams.MinSize = 5
    detectionParams.MaxSize = 50
    detectionParams.MinArea = 25
    detector.ParticleDetectionParameters = detectionParams

    # Activate the particle detection
    detector.EnableParticleDetection = True

    # Perform the detection and get the number of detected spots
    nSpot = detector.Detect(srcImage)

    # Finally, get the detected spots
    spots = detector.Spots
```

--------------------------------

### Initialize SDL Window and E3DViewer

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/05_Resources/07_Sample_Programs/07_Python_Specific/easy3d_viewer.htm?TocPath=Resources%7CSample+Programs%7CPython+Specific%7C_____3

Creates an SDL window and initializes the E3DViewer instance for 3D rendering.

```python
window = SDL_CreateWindow(b"Easy3D - 3D Viewer Sample", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 800, 600, SDL_WINDOW_OPENGL)
context = SDL_GL_CreateContext(window)
SDL_GL_MakeCurrent(window, context)
viewer = open_evision.Easy3D.E3DViewer(open_evision.Easy3D.EUIAPI.Qt)
```

--------------------------------

### Get and Set Classifier Height in C#

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/reference/easydeeplearning.eclassifier-height.htm

Use the Height property to get or set the input image height for the classifier.

```C#
uint Height
{ get; set; }
```

--------------------------------

### Legacy EasyGauge API Usage Example

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/03_Using/3_Matching_and_Measurement/2_EasyGauge/Legacy_EasyGauge/Differences_with_the_Legacy_API.htm?TocPath=Using+Open+eVision%7CMatching+and+Measurement+Tools%7CEasyGauge+-+Measuring+down+to+Sub-Pixel%7CLegacy+EasyGauge%7C_____1

Example demonstrating the hierarchical gauge attachment and processing pattern used in the legacy API.

```cpp
// EWorldShape constructor
EWorldShape worldShape;
// Gauges constructor
ERectangleGauge rectangleGauge;
ECircleGauge circleGauge1, circleGauge2;

// Attach the rectangle gauge to the EWorldShape
rectangleGauge.Attach(&worldShape);
// Attach the circle gauges to the rectangle gauge
circleGauge1.Attach(&rectangleGauge);
circleGauge2.Attach(&rectangleGauge);

// Trigger the measurement of all the
// gauges attached to the EWorldShape
worldShape.Process(&img, true);

// Retrieve the measurement result of the rectangle gauge
float sizeX = rectangleGauge->GetMeasuredRectangle().GetSizeX();

// Retrieve the measurement result of the circle gauges
ECircle circ1 = circleGauge1->GetMeasuredRectangle();
ECircle circ1 = circleGauge2->GetMeasuredRectangle();
```

--------------------------------

### Configure and Save EasyFind Search Parameters

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/05_Resources/02_Code_Snippets/20_EasyFind/Setting_Search_Parameters.htm

Demonstrates how to initialize an EPatternFinder, set search constraints, and persist the configuration to a file.

```C#
using Euresys.Open_eVision;

static partial class Snippet
{
  static void SettingSearchParameters2()
  {
    //////////////////////////////////////////////////////////
    // This code snippet shows how to tune pattern finding  //
    // search parameters and save them into a file.         //
    //////////////////////////////////////////////////////////
    // Image constructor
    EImageBW8 pattern = new EImageBW8();
    // EPatternFinder constructor
    EPatternFinder finder = new EPatternFinder();
    // ...
    // Learn the pattern
    finder.Learn(pattern);
    // Set the maximum number of occurrences
    finder.MaxInstances = 5;
    // Set the rotation tolerances
    finder.AngleTolerance = 20.0f;
    // Set the minimum score
    finder.MinScore = 0.70f;
    // Save the finding context into a model file
    finder.Save("myModel.fnd");
  }

}
```

```C++
#include <Open_eVision.h>

void SettingSearchParameters2()
{
  //////////////////////////////////////////////////////////
  // This code snippet shows how to tune pattern finding  //
  // search parameters and save them into a file.         //
  //////////////////////////////////////////////////////////
  using namespace Euresys::Open_eVision;
  // Image constructor
  EImageBW8 pattern;
  // EPatternFinder constructor
  EPatternFinder finder;
  // ...
  // Learn the pattern
  finder.Learn(&pattern);
  // Set the maximum number of occurrences
  finder.SetMaxInstances(5);
  // Set the rotation tolerances
  finder.SetAngleTolerance(20.f);
  // Set the minimum score
  finder.SetMinScore(0.70f);
  // Save the finding context into a model file
  finder.Save("myModel.fnd");
}
```

```Python
def SettingSearchParameters2():
    ##########################################################
    ## This code snippet shows how to tune pattern finding  ##
    ## search parameters and save them into a file.         ##
    ##########################################################
    import open_evision as oev
    # Image constructor
    pattern = oev.EImageBW8()
    # EPatternFinder constructor
    finder = oev.EPatternFinder()
    # ...
    # Learn the pattern
    finder.Learn(pattern)
    # Set the maximum number of occurrences
    finder.MaxInstances = 5
    # Set the rotation tolerances
    finder.AngleTolerance = 20.
    # Set the minimum score
    finder.MinScore = 0.7
    # Save the finding context into a model file
    finder.Save("myModel.fnd")
```

--------------------------------

### Drawing Image and ROI on Windows

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/03_Using/1_Starting_Up/5_Basic_Operations/Drawing_in_Open_eVision.htm?TocPath=Using+Open+eVision%7CBasic+Operations%7C_____4

Example demonstrating how to render an image and its ROI frame using an EWindowsDrawAdapter.

```cpp
EImageBW8 image;
EROIBW8 roi;
EWindowsDrawAdapter adapter(windowHdc);
image.Draw(adapter);
roi.DrawFrame(adapter);
```

--------------------------------

### EPixelViewBW16.__init__

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/reference/epixelviewbw16-epixelviewbw16.htm

Initializes a new instance of the EPixelViewBW16 class.

```APIDOC
## EPixelViewBW16.__init__

### Description
Initializes an instance of the EPixelViewBW16 class.

### Signature
`__init__(arg0: EPixelViewBW16) -> None`

### Parameters
- **arg0** (EPixelViewBW16) - Required - The object to initialize.
```

--------------------------------

### Easy Object Installation Path Properties

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/03_Using/1_Starting_Up/5_Basic_Operations/Retrieving_the_Installation_Folders_Programmatically.htm?TocPath=Using+Open+eVision%7CBasic+Operations%7C_____11

The Easy object provides static properties to retrieve the root paths for various installation components.

```APIDOC
## Easy Object Properties

### Description
Use the following properties of the `Easy` object to programmatically retrieve the installation paths for different components.

### Properties
- **Easy.SampleImagesRootPath** (string) - Returns the installation path for sample images.
- **Easy.SampleProgramsRootPath** (string) - Returns the installation path for sample programs.
- **Easy.ResourcesRootPath** (string) - Returns the installation path for resources.
```

--------------------------------

### Install Python 3.11 on older Ubuntu versions

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/03_Using/1_Starting_Up/2_Using_Open_eVision/Using_Open_eVision_in_Python.htm?TocPath=Using+Open+eVision%7CUsing+Open+eVision%7C_____3

Use the deadsnakes PPA to install a compatible Python version on Ubuntu 22.10 or earlier.

```bash
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt update
sudo apt install python3.11 python3.11-venv # 3.11 minimum
```

--------------------------------

### EPixelViewBW32.__init__

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/reference/epixelviewbw32-epixelviewbw32.htm?TocPath=Reference%7CClasses%7CEPixelViewBW32+Class%7C_____1

Initializes a new instance of the EPixelViewBW32 class.

```APIDOC
## EPixelViewBW32.__init__

### Description
Initializes an instance of the EPixelViewBW32 class.

### Signature
`__init__(arg0: EPixelViewBW32) -> None`

### Parameters
- **arg0** (EPixelViewBW32) - Required - The object to initialize.
```

--------------------------------

### Configure and Execute E3DComparer

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/03_Using/6_3D_Processing/5_Easy3DMatch/Comparison_E3DComparer.htm?TocPath=Using+Open+eVision%7C3D+Processing+Tools%7CEasy3DMatch+-+3D+Alignment+and+Comparison%7C_____3

Demonstrates setting up the E3DComparer with reference meshes, anomaly thresholds, and ROI definitions before performing a comparison.

```python
def E3DComparerAdvanced():
    ####################################################
    ## This code snippet shows how to set the options ##
    ## when comparing two elements with E3DComparer.  ##
    ####################################################
    from open_evision import Easy3D
    # load the reference cad and set reference
    comparer = Easy3D.E3DComparer()
    cad = Easy3D.EMesh()
    cad.Load("...")
    comparer.MeshReference = cad

    # Set thresholds
    comparer.AnomalyThresholds = Easy3D.EAnomalyThresholds(distanceThreshold=0.2, areaThreshold=1.)
    comparer.AnomalyHysteresis = Easy3D.EAnomalyThresholds(distanceThreshold=1.5, areaThreshold=0.5)  # defined relatively to base thresholds

    # Set ROIs
    rois = [Easy3D.E3DBox(15, 15, 15)]
    comparer.ROI = rois
    dontCare = [Easy3D.E3DBox(5, 5, 5)]
    comparer.DontCare = dontCare
    no_extra_material = [Easy3D.E3DBox(Easy3D.E3DPoint(10, 15, 20), 0, 0, 0, 5, 5, 5)]
    comparer.NoExtraMaterial = no_extra_material

    # Prepare data structures (optional)
    comparer.PrepareReference()

    # load the sample and perform comparison
    sample = Easy3D.EPointCloud()
    sample.Load("...")
    comparer.Compare(sample)

    # compute anomalies
    anomalies = comparer.ComputesAnomalies()
    #TODO: if len(anomalies) != 0: an anomaly was detected: inspect the sample manually? throw it away?

    # get cloud to inspect it manually
    visualisation_cloud = Easy3D.EPointCloud()
    comparer.GetComparisonPointCloud(visualisation_cloud)
```

--------------------------------

### Get and Set Standard Symbologies in C++

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/reference/ebarcode-standardsymbologies.htm

Access the standard symbologies bitmask using the Get and Set methods in the Euresys::Open_eVision namespace.

```cpp
uint32_t GetStandardSymbologies() const
void SetStandardSymbologies(uint32_t un32StandardSymbologies)
```

--------------------------------

### Optimizing ETextReader

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/03_Using/4_Text_and_Code_Reading/4_EasyDeepOCR/Performing_an_Optimization.htm

Demonstrates the workflow for optimizing an ETextReader instance using a list of samples.

```C++
#include <Open_eVision.h>

void PerformingAnOptimization()
{
  ///////////////////////////////////////////////////////////////
  // This code snippet shows how to perform an optimization.   //
  ///////////////////////////////////////////////////////////////
  using namespace Euresys::Open_eVision;
  namespace EDO = Euresys::Open_eVision::EasyDeepOCR;
  // Create an ESample vector
  std::vector<EDO::ESample> samples;
  // Fill the vector
  // ...
  // Create an ESampleList instance
  EDO::ESampleList sampleList;
  // Set the samples
  sampleList.SetSamples(samples);
  // Create an ETextReader instance
  EDO::ETextReader reader;
  // Initialize the ETextReader
  reader.Initialize();
  // Optimize the ETextReader
  EDO::EOptimizationReport report = reader.Optimize(sampleList); 
  // ...
}
```

```C#
using Euresys.Open_eVision;
using EDO = Euresys.Open_eVision.EasyDeepOCR;

static partial class Snippet
{
  static void PerformingAnOptimization()
  {
    ///////////////////////////////////////////////////////////////
    // This code snippet shows how to perform an optimization.   //
    ///////////////////////////////////////////////////////////////
    // Create an ESample vector
    EDO.ESample[] samples = new EDO.ESample[] { } ;
    // Fill the vector
    // ...
    // Create an ESampleList instance
    EDO.ESampleList sampleList = new EDO.ESampleList();
    // Set the samples
    sampleList.Samples = samples;
    // Create an ETextReader instance
    EDO.ETextReader reader = new EDO.ETextReader();
    // Initialize the ETextReader
    reader.Initialize();
    // Optimize the ETextReader
    EDO.EOptimizationReport report = reader.Optimize(sampleList); 
    // ...
  }
}
```

```Python
def PerformingAnOptimization():
  ################################################################
  ## This code snippet shows how to perform an optimization.    ##
  ################################################################
  import open_evision as oev
  from open_evision import EasyDeepOCR as EDO
  # Create an ESample vector
  samples = []
  # Fill the vector
  # ...
  # Create an ESampleList instance
  sampleList = EDO.ESampleList()
  # Set the samples
  sampleList.Samples = samples
  # Create an ETextReader instance
  reader = EDO.ETextReader()
  # Initialize the ETextReader
  reader.Initialize()
  # Optimize the ETextReader
  report = reader.Optimize(sampleList); 
  # ...
```

--------------------------------

### New EasyGauge API Usage Example

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/03_Using/3_Matching_and_Measurement/2_EasyGauge/Legacy_EasyGauge/Differences_with_the_Legacy_API.htm?TocPath=Using+Open+eVision%7CMatching+and+Measurement+Tools%7CEasyGauge+-+Measuring+down+to+Sub-Pixel%7CLegacy+EasyGauge%7C_____1

Example demonstrating the modern API approach using explicit measurement calls and frame conversion.

```cpp
// Optional if no calibration is needed
ECameraCalibration calibration;

// Gauges constructor
ERectangleGauge rectangleGauge;
ECircleGauge circleGauge1, circleGauge2;

try
{
  ERectangle rect = rectangleGauge.Measure(img, calibration.ToFrame());
  ECircle circ1 = circleGauge1.Measure(img, rect.ToFrame());
  ECircle circ2 = circleGauge2.Measure(img, rect.ToFrame());
}
catch (const EException& e)
{
  // One of the measurement failed.
}
```

--------------------------------

### ECodeGrid::GetResults

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/reference/ecodegrid-getresults.htm

Retrieves the detected codes from the ECodeGrid. Can be called without arguments to get all codes, or with column and row parameters to get codes for a specific cell.

```APIDOC
## ECodeGrid::GetResults

### Description
Returns the detected codes from the ECodeGrid object. This method can be used to retrieve all detected codes or codes specific to a grid cell.

### Signature
- **C++**: `std::vector<ECode> GetResults(uint32_t column, uint32_t row) const` or `std::vector<ECode> GetResults() const`
- **C#**: `ECode[] GetResults(uint column, uint row)` or `ECode[] GetResults()`
- **Python**: `GetResults(column: int, row: int) -> list[ECode]` or `GetResults() -> list[ECode]`

### Parameters
- **column** (uint/int) - Optional - The column index of a cell.
- **row** (uint/int) - Optional - The row index of a cell.
```

--------------------------------

### EPixelViewBW8.__init__

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/reference/epixelviewbw8-epixelviewbw8.htm?TocPath=Reference%7CClasses%7CEPixelViewBW8+Class%7C_____1

Initializes a new instance of the EPixelViewBW8 class.

```APIDOC
## EPixelViewBW8.__init__

### Description
Initializes an instance of the EPixelViewBW8 class.

### Signature
`__init__(arg0: EPixelViewBW8) -> None`

### Parameters
- **arg0** (EPixelViewBW8) - Required - The object to initialize.
```

--------------------------------

### Check for Engine Setup Data in C++

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/reference/easydeeplearning.edeeplearningtool-hasenginesetupdata.htm

Use this method to verify if the tool currently holds engine setup data for the configured device, precision, and batch size.

```C++
bool HasEngineSetupData(  
) const 
```

--------------------------------

### EPixelViewBW8.__init__

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/reference/epixelviewbw8-epixelviewbw8.htm

Initializes a new instance of the EPixelViewBW8 class.

```APIDOC
## EPixelViewBW8.__init__

### Description
Initializes an instance of the EPixelViewBW8 class.

### Signature
`__init__(arg0: EPixelViewBW8) -> None`

### Parameters
- **arg0** (EPixelViewBW8) - The object to initialize.
```

--------------------------------

### GetResourcesRootPath

Source: https://documentation.euresys.com/Products/OPEN_EVISION/OPEN_EVISION/en-us/Content/reference/easy-resourcesrootpath.htm

Retrieves the resources installation path.

```APIDOC
## GetResourcesRootPath

### Description
Retrieves the resources installation path.

### Signatures

#### C++
`std::string GetResourcesRootPath()`

#### .NET (C#)
`static string ResourcesRootPath { get; }`

#### Python
`@staticmethod GetResourcesRootPath() -> str`
```
Tokens:
Raw