bhojpur / ode

The Bhojpur ODE is a Quantum AI/ML enabled optical data engine software based on Bhojpur.NET Platform applied in different industry sectors for object recognition, annotation, and actionable insights.

Bhojpur ODE - Optical Data Engine

The Bhojpur ODE is a high performance optical data processing engine based on the Bhojpur.NET Platform ecosystem for delivery of distributed, AI/ML enabled, applications or services. It features advanced visualization (both in 2D and 3D modes) of medical volumetric data, provided in popular file formats: DICOM, NIfTI, KTX^™, HDR, etc. It has a proprietary ODE-Formats library for image data handling.

Motivation

The Bhojpur ODE is designed to be an artificial intelligence enabled digital imagery data processing and management engine. It could be applied in several different sectors (e.g. Digital Pathology, Microscopy, Telescopy, Remote Sensing, Geology, Drone).

For example, it could be used in a medical center with diagnostic equipment.

• ⚡️ MRI and CT scanning results could be viewed in any computer (inside the medical office and in the client's home)
• 💡 Qualified medical personnel could provide diagnosis or conclusion based the provided visualization.
• 🌐 App could be used as a web application as a part of large websites and services
• 🎓 Could be used by research institutes due to NIfTI, HDR, etc. file standards support
• 🏥 Medical centers can create their clients database, based on this viewer.

Industry Standards

Depending on specific use-cases, the Bhojpur ODE uses following digital imaging file formats. It features ability to import / export images in various formats. For example

• Tagged Image File Format
• Scalable Vector Graphics
• Joint Photographic Experts Group
• NIH Medical Image Processing, Analysis, and Visualization
• LuraTech Imaging
• Bio-Formats defined by the University of Wisconsin - Madison's Laboratory for Optical and Computation Instrumentation
• Flexible Image Transport System

Installation

It works as a standalone HTML5 web application. The latest version can be used with WebGL-enabled desktop browsers (e.g. Chrome, Firefox, Opera) and allows limited usage with mobile browsers (Android Chrome). Version for Safari (macOS, iOS) is planned for future.

npm install
npm run start

References

The DICOM file format description can be found here and here. KTX^™ file format details are listed in KTX. Popular DICOM loader framework: GDCM. Some JavaScript libraries to work with DICOM file format:

1. dicomParser
2. Daikon
3. Xtk.

3D Volumetric Rendering

The three.js is used as some gateway to WebGL renderer. The current three.js version does not support 3D textures, so we use tricky way to build 2D texture from initial 3D texture by linking 2D slices all together as a large tile map. This idea (with source codes) can be seen in project WebGL Volume Rendering.

Build Source Code

The Bhojpur ODE platform core components are developed using several software technologies (e.g. Ivy, Groovy, Gradle, Ant, Ice, Python, Node.js, Java, Spring).

In brief, most of the Bhojpur ODE core components (i.e. developed in Java and Python) could be built using the following commands.

gradle --no-daemon --init-script pkg/init-ci.gradle build
cd pkg && ant build

Based on Gradle ICE Builder Plugin, we have created a set of custom Gradle plugins for the Bhojpur ODE software.

Pre-requisites

Firstly, you need to install ZeroC ICE middleware before compiling .ice interface definition language files. For example, on a macOS operating system, issue the following commands

brew install zeroc-ice/tap/ice
brew install ice
brew install zeroc-ice/tap/ice-builder-xcode
slice2cpp -v
slice2java -v
sudo pip3 install zeroc-ice
slice2py -v
brew install --cask zeroc-ice/tap/icegridgui
export ODEDIR==$(pwd)

The ZeroC ICE tools generate Java source code for the server-side and Python source code for the client-side frameworks.

Gradle Plugins

Our Gradle plugins are defined in the pkg/plugins folder. So, you need to build different Gradle plugins (e.g. artifact, project, api, dsl, server, javapackager, icebuilder) that are used by source code generators. Simply issue the following commands in a new Terminal window to build these plugins.

cd pkg/plugins
gradle --no-daemon --init-script ../init-ci.gradle build

It will only build the Gradle plugins. Then, you need to publish these Gradle plugins locally by issuing the following command. It will be helpful in building other components. However, you need to uncomment the plugins sections in settings.gradle file, if you are starting completely fresh. Or, you can download and utilize the plugins from the Bhojpur Artifactory.

gradle --no-daemon --init-script ../init-ci.gradle publishToMavenLocal

Finally, you can publish these Gradle plugins centrally by issuing the following command

gradle --no-daemon --init-script ../init-ci.gradle publish

Core Framework Libraries

There are core components libraries that must be built first prior to builging the server.

cd pkg/formats/components/bundles/stubs && mvn
cd pkg/formats/components/bundles/codecs && mvn

Source Code Generator

The Bhojpur ODE generates a lot of source code for client- / server- side frameworks.

Java-based Backend

You need to install Java >= 1.8, ant, ivy, mvn, gradle, and other software tools or frameworks. Just issue the following command in your project root folder to build the Bhojpur ODE backend server components developed uing Java programming language.

gradle --no-daemon --init-script pkg/init-ci.gradle build

Python-based Backend

You need to install Python >= 3.8, Django, appdirs, Pillow, numpy, tables, mox3, genshi, and other software libraries. The Bhojpur CLI is dependent on Python-based server framework that access the Java-based backed using ZeroC middleware.

sudo pip3 install appdirs django Pillow numpy tables mox3 genshi
sudo pip3 install -U -r requirements.txt
cd pkg && ant build

Server-side Framework

The source code is compiled into .jar libraries using Gradle software build tool. So, please check if settings.gradle file points to pkg/server folder.

It is based on Java >= 1.8 and Spring Framework. The Bhojpur ODE server is designed to securely store, retrieve, and process digital images efficiently.

cd pkg
gradle --no-daemon --init-script init-ci.gradle build

Client-side Framework

It is based on Python >= 3.8 and Ice >= 3.7. The client is designed to serve image data efficiently using web-based APIs. You could use the odectl tool as a starting point to interact with the Bhojpur ODE server.

export ODE_HOME==$(pwd)

However, you can develop client-side applications in Java as well using libraries. We have created Java plugins for some popular image processing software products.

Web-based Forms

It enables extending the Bhojpur ODE capabilities using web-based Forms. You can build it using node.js and webpack framework.

cd pkg/webui
npm install
node_modules/webpack/bin/webpack.js --progress

Web-based Application

Engine Application

Based on Django framework, it acts as a web-tier for all the Client-side applications. Now, change directory to pkg/components/tools/OdeWeb and issue the following commands to run the Bhojpur ODE web engine.

cd pkg/components/tools/OdeWeb
python3 ./engine/manage.py runserver 0:8000

Viewer Application

Based on OpenLayers and Node.js, it serves as a web viewer of Bhojpur ODE. It is available in the pkg/viewer folder.

npm install
npm run dev