home | portfolio | publications
sqıd – a multi-purpose virtualization tool for data processing & data-flow programming (2020 – )

sqıd is a powerful multi-purpose tool for virtualization of data processing and relaying tasks. It is using the visual programming (VP) paradigm for configuring filter graphs and pipelines to provide support in parameter tuning and composing multi-component installations, to prototype interactive experiences and environments, e.g., for testing and studying user interface technology and devices, as well as potential data-flow architectures.

Starting off as a tiny custom config-file based command line tool for presentation of the Textile Wire Carbon Black, it was progressively extended and complemented with additional functionality and an accesible UI, as well as numerous data sources and sinks, to act as a bridge between numerous devices and applications.

sqıd is meant as a lens that enables to zoom into the data processing aspects (i.e., setting up and tuning) of a pipeline, including small-scale as well as rather complex setups. The GUI is heavily inspired by well-known and widespread VP based patching tools such as Max/MSP, Puredata, vvvv, TouchDesigner, etc., also borrowing some of their terminology. The user may set up directed graphs by instantiating filter nodes (“Operators”) and by configuring respective parameters and instantly see the effects at integrated live data visualizations. Existing Operators include basic algebraic operations, mathematic operations such as FFT, low- and high-pass filters, matrix rearrangements, color space conversions, logical operations, and much more.
Configurations (“scenes”) are saved to human-readable JSON files. Once configured using the GUI and ready to use, the scenes can be again loaded by an sqıd instance, which also can be run headless, i.e., without UI as a console application, to save computing resources and visual clutter. To not depend on graphics interfaces (i.e., OpenGL), it can be compiled completely without UI-support using a preprocessor switch, which makes it feasible for, e.g., running a concluded processing stage on a shell-only edge-computing-device.

The architectural concept is to have sqıd as a layer in between of raw data providers, such as Human Interface Devices (HIDs) or other data generating artifacts on one end, and target applications/frontends on the other end (e.g., a C++, Unity3D, or Unreal Engine application on a PC, an Android or iOS app on a mobile device, a vehicle’s dashboard, or even another tool such as MATLAB for further processing). To maximize its utility, the device would ideally send unprocessed raw data (depending on the type and therefore the required bandwidth) that would be subsequently pre-processed and high-level information extracted (e.g., movements, gestures, commands), which will then be sent to and application for utilization. To provide maximum versatility and to enable distributed architectures, with components on numerous computing devices, it heavily relies on networking interfaces (mostly OSC via UDP for many use cases requiring interactive rate). Basically, any device that can send/receive data via network can be a sender/receiver. Since OSC is a widespread and low-profile protocol in the field of multimedia, it is easy to link sqıd functionality to many existing tools (vvvv, Open Stage Control, MadMapper, etc.).

Note that this network-based architecture also allows for prototyping applications on mobile devices by sending data via WIFI or Bluetooth Serial, or to implement a bypass or feedback loop, e.g., by streaming data to a Python script via TCP, for processing steps requiring scikit.learn, then streaming the result back to sqıd, if required for further handling, etc. Data can furthermore be captured to files on disc (CSV or binary formats) and replayed (e.g., for batch-scripted testing and controlled evaluation of different processing methods from captured input).
The tool’s source code is written in C++ and built on-top of widespread cross-platform libraries uses to ensure portability at least among Windows/macOS/Linux. Visualization is based on OpenGL, data for processing it builds upon OpenCV, so a switch to GPGPU processing is easy to do (although not implemented at this point since never required). It can easily be extended by additional processing Operators, data sources, and sinks, for example adding VRPN functionality is straightforward. The UI is built with extensibility in mind; live data visualizers are replaceable so custom implementations can be added, e.g., replacing the line graph or heatmap visualizations of an Operator type by a 3D scene rendering can be accomplished easily.
For our custom-made sensor hardware, we implemented a specific protocol that we usually transmit via serial, Wifi, or Bluetooth. However, any data can be used easily, as additional data sources are straightforward to implement, also as extensions (in the for of .dll/.so) using the provided plugin system. As of now, the tool supports the following input devices and protocols for input and/or output.
- OSC input/output (via UDP or TCP)
- ZeroMQ input/output
- MQTT input/output
- CAN Bus input/output
- Bluetooth Serial input
- Serial/COM interface input
- MIDI input (via RtMidi)
- TUIO 2.0 protocol input
- Optitrack Natnet and Camera API input
- Audio input (WASAPI, ASIO, DS, ALSA, CORE, etc. via RtAudio)
- XInput Gamepad input
- LeapMotion gesture controller input (Windows only)
- Thalmic Myo EMG Armband input (Windows only)
- Sensel Morph input
- Camera input (via OpenCV)
- Intel Realsense depth sensing camera input
- Kinect for Xbox 360 depth sensing and full-body skeletal tracking camera input (via K4W SDK, Windows only)
- Kinect for Xbox One depth sensing and full-body skeletal tracking camera input (via K4W SDK 2, Windows only)
- Azure Kinect DK input (via Azure Kinect Sensor SDK, Windows only)
Furthermore, streamed data can be compressed to save bandwidth using JPEG for image data, as well as the lossless methods MiniLZO, QuickLZ, bzip2, zStd, zLib, and LZ4 for generic data.

We complement the code with sample implementations for senders/receivers:
Platform IO based firmware for
Arduino compatible MCUs, target application templates for Unity3D, Python, and
Processing, as well as plugins for vvvv, MATLAB (mex-Plugin), and
Grasshopper3D/Rhino.
A publication regarding sqıd is currently under peer-review. As soon as it is published, the source code will be provided on Github, and a link will be added here. Still, in case you find the project interesting and want to learn more and/or contribute, feel free to get in touch.
Credits: University of Applied Sciences Upper Austria, TU Wien
External:
Publication Link will follow here
Github repository will follow here
© copyright 2025 | rolandaigner.com | all rights reserved