bugelniels / nitro Goto Github PK

A way to group different nodes together. Input and output ports can be determined based on the content

Add support for:

• transformations
• Fourier transforms
• Morphology
• Edge detection
• Cropping

Allow data types to specify to which other data types they can convert and how.
E.g. integer and double types should be able to convert to each other
Integer and double types should also be convertible to images (but not the other way around).

Make it easier to retrieve items from the node ports
Primarily, make it more extendable than the current system. I.e. remove the responsibility from NitroNode.

Controls in top down view move the entire space in which the first person moves.

Add a node that allows for mathematical operations on values/integers

Make a spinbox/slider combo, similar to Blender.

Allow modules to register particular nodes as viewer nodes (or associate them with particular dock widgets somehow)
Additionally, allow for registering particular nodes as file load nodes, so that users can drag and drop those file types onto the editor to spawn the corresponding load node.

• Add a factory that constructs a dock widget based on a particular node id/name?
• Add a factory that constructs a node based on a given file extension.

Use a float representation [0-1] instead of integer representation for the images.

Add docker containers for the various operating systems to test the build and execution process.

Specify the controls in the README

Sometimes the output of the quantization nodes shows the input image instead of the quantized.

Probably has to do with some class data not being copied properly.

Automatically generate OpenCV code that performs the task in the node graph.

• Additional feature: automatically copy to clipboard.

Zooming in too much in the node editor view causes the embedded widget to be drawn outside of the node itself. Happens for the image view in particular.

Bottom align the input ports

Dragging a file from the file system onto the node editor part of the application should insert an image viewer node (if it is an image).

Add a progress indicator (either a progress bar or a mouse loading indicator) whenever the graph is being re-evaluated.

Creating a cycle in the node graph causes an infinite loop and a program crash.

Allow for the spawning of multiple copies of the same dock. In particular, allow for multiple image viewers and allow the viewer node(s) to select which dock to view the image in.

Concretely:

• Allow for (at runtime) adding/removing dock widgets
  • Docks should not have an enable/disable button anymore, but simply add/remove
  • Do something similar to blender where you have a dock wrapper and you can select from a dropdown which dock type to use.
• Each copy of a particular dock type gets an index (unique within said dock type)
  • This index should be displayed in the widget
• Viewer nodes should be able to specify the dock type in question

Instead of using inheritance for node creation, instantiate a builder pattern to add input and output nodes. Separate compute interface that can be given using composition to the node

Emit a warning message from CMake if the directories in external/ are not found properly.

Create a nice logo for NITRO

Display the name of the image source in the node

Add an automatic build/release pipeline to GitHub

Only link against the required modules from OpenCV instead of all.

Build the AppImage using an older version of GLibC to ensure maximum compatibility.
As of right now, it won't work on WSL

Update icon links (e.g. https://github.com/BugelNiels/nitro/stargazers, https://github.com/BugelNiels/nitro/watchers)

Currently, the image viewer color info has a fixed minimum size which clashes with the arbitrary resizing of dock widgets.
Allow for this status bar to be collapsed properly.

For improved clarity and ease of development, the ImageData class should separate the color and grayscale images.

XYZ or Lab color space.

When dragging a connection onto a node input should delete the existing connection.

Add a contributing readme to help people get started with developing new features for the project

Create a separate data type to hold a GPU image and process it accordingly.
Most likely start out with CUDA first and port to non-NVIDIA GPUs later. See https://opencv.org/platforms/cuda/

First off, this is a beautiful project!

I'd like to propose a feature for converting multiple images at a time. As far as I can tell, this doesn't seem possible, yet.

Some sub features of this may be:

1. Load images in bulk.
2. Edit images in bulk - while displaying the change on one exemplary image.
3. Export in bulk.

Allow modules to specify which modules it depends on (e.g. an image processing module that depends on imcore)

Dragging nodes onto connections should insert the node onto the connection if possible

Set up a test framework and write tests for NITRO core.

Inputting different sized images can result in crashes on e.g. the mix node.
Fix by taking the size of the first input image and scaling/cropping accordingly

Use the release version in the AppImage name

Should be able to display separate names per port instead of the name of the data type

The cube the raycaster uses to start raycasting is not clipped properly yet.

Title.

Write documentation for the project

Implement seperate/combine nodes using the ICtCp color space.

Update CMake so that it is able to build (cross-platform ideally) a self-contained binary that can be distributed.
This should enable users to run NITRO without installing all the required dependencies first.

Separate out the installation part from the README.md and make a separate BUILD.md