Python operator
Building block of our real-time analysis
The Python Operator is one of our analysis modules for graphically programmable real-time analysis, and yet it is completely different.
This operator offers the option of implementing your own analysis approaches and applying them to the data stream in real time.
Editor
The parameterization interface of the Python operator offers an extensive code editor. In addition to syntax highlighting, the auto-complete function provides information on functions and variables as you type.
The source code of the operator can either be saved in the operator itself (i.e. in the database) or in the file system, e.g. in a Git repository. Depending on the configuration, changes in the file system are synchronized directly in the operator.
Debugger
Have you lost the thread and now the world seems a bit bewildering?
Don't worry: this happens to us all the time; we have integrated the debugger so that we can stop execution at breakpoints at any time and see exactly what is going on.
Of course, variables and the current call stack can be inspected. Another cool feature is that you can execute code directly on the spot in an interactive console and "look around", so to speak, even if something is not directly visible in the variables..
Here's how you can quickly get to the bottom of those tricky bugs.
Profiling
The analysis is ready, but can't quite keep up with the amount of data?
Then the integrated profiler is certainly helpful: it provides a precise overview of which functions have taken up how much time. Performance bottlenecks are thus quickly identified and can be optimized in a targeted manner.
The indiscriminate optimization of source code is usually at the expense of readability. With the Profiler, you can invest your thoughts where it really makes a difference: On the parts of the code that really eat up time.
Your own parameter interface (GUI)
The Python operator offers the possibility of implementing completely new operators. Experience has shown that these operators can become just as complex and versatile as our other operators.
Accordingly, there is also a need for intuitively adjustable parameters for Python operators.
You can create and display your own parameter representations based on Qt and PySide2 directly in the source code. The Python code can also be made inaccessible so that the operator behaves practically identically to conventional analysis modules.
Customizable inputs & outputs
Python operators can be flexibly extended with inputs and outputs. This allows them to be combined with other components of our operator network in a variety of ways. The inputs and outputs are the interface to other operators.
All data types possible in the operator network are supported and are available in Python via corresponding software interfaces (bindings).
Limitless possibilities
Machine learning and data science have long since become part of our everyday lives. We are constantly surrounded by them - wouldn't it be cool to be able to use these tools for process monitoring too?...we thought so too and pre-installed many Python libraries so that you can get started right away.
Python provides access to state-of-the-art methods of data analysis.
Not to mention what you can program yourself in Python to tailor the analysis exactly to your process.
Performance & real-time analysis
Python is lame?
Then you may not yet know how to do it properly ;-)
Joking aside: Python is an interpreted scripting language and therefore the execution of Python code requires more effort than in C or C++.
The trick, however, lies in the use of highly optimized libraries. Data science libraries such as Numpy or Tensorflow are actually implemented in C or C++ and are executed as binary code. The algorithms are developed and optimized by hundreds of specialists.
If you use Numpy skillfully, it is difficult to write similarly performant code in C++ yourself..
Software interfaces
The Analyzer4D software can not only execute Python code, but functions of the Analyzer4D software can be called from Python at the same time.
This allows Python programs to benefit from the high performance of our compiled software.
Similar to compiled Python libraries, we have created bindings that allow us to access our C++ data structures directly from Python.