Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/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.
https://github.com/bhojpur/ode
digitalpathology image-processing neural-network quantum-algorithms
Last synced: 5 days ago
JSON representation
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.
- Host: GitHub
- URL: https://github.com/bhojpur/ode
- Owner: bhojpur
- Created: 2021-12-24T16:59:45.000Z (about 3 years ago)
- Default Branch: main
- Last Pushed: 2022-06-29T16:00:57.000Z (over 2 years ago)
- Last Synced: 2024-11-24T01:19:54.488Z (2 months ago)
- Topics: digitalpathology, image-processing, neural-network, quantum-algorithms
- Language: Java
- Homepage: https://page.bhojpur-consulting.com/product/ode/
- Size: 41.8 MB
- Stars: 2
- Watchers: 1
- Forks: 1
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Bhojpur ODE - Optical Data Engine
The `Bhojpur ODE` is a high performance *optical data* processing engine based on
the [Bhojpur.NET Platform](https://github.com/bhojpur/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.
- :globe_with_meridians: App could be used as a web application as a part of large
websites and services
- :mortar_board: Could be used by research institutes due to NIfTI, HDR, etc. file
standards support
- :hospital: 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](./pkg/formats/). It features ability to *import* / *export* images
in various formats. For example
- [Tagged Image File Format](https://docs.fileformat.com/image/tiff/)
- [Scalable Vector Graphics](https://www.w3.org/TR/SVG2/)
- [Joint Photographic Experts Group](https://jpeg.org/)
- [NIH Medical Image Processing, Analysis, and Visualization](https://mipav.cit.nih.gov/)
- [LuraTech Imaging](https://www.foxit.com/enterprise-automation/)
- [Bio-Formats](https://eliceirilab.org/software/bio-formats/) defined by the University of Wisconsin - Madison's [Laboratory for Optical and Computation Instrumentation](https://eliceirilab.org/)
- [Flexible Image Transport System](https://fits.gsfc.nasa.gov/)
## 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.
```bash
npm install
npm run start
```
## References
The `DICOM` file format description can be found [here](http://dicom.nema.org/standard.html)
and [here](https://www.leadtools.com/sdk/medical/dicom-spec). KTX™ file format
details are listed in [KTX](https://www.khronos.org/registry/KTX/specs/1.0/ktxspec_v1.html).
Popular DICOM loader framework: [GDCM](https://sourceforge.net/projects/gdcm/).
Some JavaScript libraries to work with DICOM file format:
1. [dicomParser](https://github.com/chafey/dicomParser)
2. [Daikon](https://github.com/rii-mango/Daikon)
3. [Xtk](https://github.com/xtk/X#readme).
## 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](https://github.com/lebarba/WebGLVolumeRendering).
## Build Source Code
The `Bhojpur ODE` platform *core* components are developed using several software technologies
(e.g. [Ivy](https://ant.apache.org/ivy/), [Groovy](https://groovy-lang.org), [Gradle](https://gradle.org),
[Ant](https://ant.apache.org/), [Ice](https://zeroc.com/products/ice), [Python](https://www.python.org),
[Node.js](https://nodejs.org), [Java](https://www.java.com), [Spring](https://spring.io)).
In brief, most of the `Bhojpur ODE` core components (i.e. developed in *Java* and *Python*)
could be built using the following commands.
```bash
gradle --no-daemon --init-script pkg/init-ci.gradle build
cd pkg && ant build
```
Based on Gradle [ICE Builder Plugin](https://github.com/zeroc-ice/ice-builder-gradle),
we have created a set of custom Gradle *plugins* for the `Bhojpur ODE` software.
### Pre-requisites
Firstly, you need to install [ZeroC ICE](https://doc.zeroc.com/ice/) middleware before
compiling `.ice` interface definition language files. For example, on a `macOS`
operating system, issue the following commands
```bash
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](./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.
```bash
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](./settings.gradle)
file, if you are starting completely fresh. Or, you can download and utilize the plugins
from the Bhojpur Artifactory.
```bash
gradle --no-daemon --init-script ../init-ci.gradle publishToMavenLocal
```
Finally, you can `publish` these Gradle plugins centrally by issuing the following command
```bash
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.
```bash
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.
```bash
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.
```bash
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](./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.
```bash
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](/cmd/odectl) tool as
a starting point to interact with the `Bhojpur ODE` server.
```bash
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.
```bash
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.
```bash
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.
```bash
npm install
npm run dev
```