Image processing pipeline – Overview Administration
This project, in total, is worth 50% of your unit grade, but it is split into two 25% submissions. To break down the task, further the assignment is split into three conceptual parts:
First submission (25%); due Tuesday May 12th by 11.59pm Part A (25%)
Second submission (25%); due Friday May 29th by 11.59pm Part B (15%)
Part C (10%)
This document is the assignment overview which describes the overall high-level purpose of the assignment and its components.
Background
In computing, a pipeline is a set of data processors, constructed by connecting nodes in a series, where the output of one node becomes the input of the next one.
Pipeline frameworks are often constructed to allow users to build processing pipelines using a range of common computational operations on data.
MRI Example
A recent technique in MRI called Quantitative Susceptibility Mapping (QSM) generally uses a pipeline consisting of a series of steps before a final susceptibility map is obtained. In each step, the data from the previous step is processed further.
General example
A simple example of a pipeline is shown that uses 4 nodes (crop, vignette, greyscale, and sharpen):
Task Overview
Write an image processing framework that can be used to construct and execute image processing pipelines. Additionally, provide a program that demonstrates the working framework.
Nodes / image processors (Part A) (25%)
Your program should implement a range of classes that each represent a different kind of node that may eventually become a part of a pipeline. Each node class should contain a Process method capable of performing an operation on a given input image in order to produce a desired output image.
Processors are categorised below as easy, intermediate, and challenging. The implementation of these processors is worth a maximum of 15 marks in total. You may choose which processors to implement. If your processors sum to more than 15 marks, any functionality or code quality issues present will cause a deduction of marks starting from 15 (i.e. ‘bonus’ marks are not awarded, and implementing more than 15 marks worth of processors is risky if your code quality or functionality is not completely correct).
Easy processors (total 8 marks)
(1 marks) Greyscale
(1 marks) Intensity thresholding
(1 marks) Masking (using an input mask image) (2 marks) Crop
(1 marks) Resize
(2 marks) Pixelate
Intermediate processors (total 12 marks)
(4 marks) Vignette
(4 marks) Normalise
(4 marks) Random noise
Challenging processors (total 16 marks) (8 marks) 2D Kernel convolution
(8 marks) Masking by region growing
API example:
This example demonstrates how the intensity thresholding node may be used. At the end of part A, you should be able to test each of your nodes in a similar fashion:
More details for this part of the assignment are in the part A document.
N_Threshold node = new N_Threshold(min: 20, max: 200);
Image input = new Image(“input_image.png”);
Image output = node.Process(input);
output.Write(“thresholded_image.png”)
Pipeline framework (Part B) (15%)
In order to create a pipeline, nodes need to be able to connect together, so that their inputs and outputs flow into each other, and the entire pipeline can be run automatically. To achieve this, an abstraction layer is needed over all the node classes from part A so that they can be linked.
Below is a basic example showing the manual setup of two nodes followed by pipeline execution using Pipeline.Run :
create pipeline
List
new N_Crop(0, 0, 200, 200),
new N_Vignette()
};
load input data
Image input = new Image(“cat.png”);
run pipeline and get result
Image output = Pipeline.Run(input, pipeline);
write result to output.png
output.Write(“output.png”);
In this example, N_Crop and N_Vignette are subclasses of Node . This allows them to be put together in a List of generic Node objects. Then, the full pipeline can be executed using a single method ( Pipeline.Run ).
Additionally, in part B, the following two features should be implemented:
Intermediate results (outputs of each node) should be automatically saved to disk if specified in the Run method using an optional parameter.
Useful messages should be logged to the console to document the execution of a pipeline if specified in the Run method using an optional parameter. Logs should include the name of each node, the input image size and output image size, and other useful information (see usage examples at the bottom of this document).
More details for this are in the part B document.
Demonstration program (Part C) (10%)
In this part, you will create a program to demonstrate the functionality of the work you completed in parts A and B. You will write a Main method that will run a pipeline across inputs specified by command-line arguments.
The specification for this part of the assignment is still being developed.