Skip to content

GSoC 2020

Jump to bottom Edit New page
Mateusz Łoskot edited this page Feb 23, 2020 · 12 revisions

Google Summer of Code 2020

This is list of proposals of GIL projects for GSoC 2020. The projects below are also copied to the official Boost wiki at https://github.com/boostorg/wiki/wiki/Google-Summer-of-Code%3A-2020 where all Boost proposals are collected.

PROJECT 1: Image Processing Algorithms

This proposal is continuation of Image Processing Algorithms project submitted and developed by Miral Shah during GSoC 2019.

Boost.GIL provides core features for images and, thanks to Miral Shah's work, a collection of basic image processing algorithms. However, there still is more algorithms to be added to the collection.

Check GIL's wiki page Image Processing Algorithms with table presenting the algorithms implementation status and the wish-list.

1. Mathematical Morphology

  • Dilation
  • Erosion
  • Blurring / Smoothing
  • Sharpening

2. Normalizing Channels

3. De-Noising

  • Wiener filter
  • Average filter
  • Median filter

4. Kernels and Convolutions

  • The GSoC 2019 project implemented lots of improvements and new features in the kernels and convolutions, but this area may still benefit from further development, optimisations and documenting.

5. Your favourite image processing algorithms

6. Image Processing Documentation

  • We need a beautifully written and presented documentation of the image processing features in GIL
  • For example, https://github.com/boostorg/gil/issues/396, describes an idea of the docs structure based on the "Principles of Digital Image Processing" book

PROJECT 2: Histogram

Histogram is one of essential tools in the image processing techniques. Although it belongs to the image processing algorithms, we propose this as a separate self-contained project.

Boost.GIL presents how to compute histogram in the documentation, Tutorial: Histogram, as well some existing algorithms already compute histogram as in case of the Otsu's thresholding, but there is no functionality in GIL available via public interfaces for histogram computation and operations.

This project proposal is about making histogram a first-class feature in GIL.

List of suggested topics [1]:

  • Computing histograms
    • 1D histogram of single image (8-bit grayscale image)
    • Histograms of images with more than 8 bits (Binning technique)
    • Histogram of color images
      • Intensity histogram (Luminance)
      • Individual color channel histogram
      • Combined color histogram
      • 1D histogram of individual components of any color space of single image (HSV, RGB, XYZ)
      • 2D histogram [2] projections [3] of single image (e.g. H and S of HSV, R and B of RGB, etc.)
      • 3D histogram of single image [4]
    • Cumulative histogram
  • Point operations - histogram transformations or histogram-based image enhancements
    • Histogram Normalization
    • Histogram Equalization
    • Histogram Specification - adjusting an image to a given reference histogram
  • Segmentation
    • Thresholding - use of new histogram computation in the GIL thresholding algorithms
    • Extras - optional ideas for when the histogram core features are implemented
      • Histogram Backprojection [5] - Where in the image are the colors that belong to the object being looked for? [6]
      • 2D histogram scheme for colour image segmentation [7]
  • Integration with Boost.Histogram
  • Histogram visualization - for testing and debugging purposes
    • If there is support for Boost.Histogram, we can rely on its ASCII 1D plots
    • GIL extension for basic plotting of histogram in SVG format (e.g. see SVG in Boost.Geometry)
    • GIL extension based on a third-party plotting library

References:

Programming competency test

Using latest Boost.GIL, implement a simple convolution filter and show its use in a test application to detect edges in a grayscale input image.

Alternatively, choose a simple algorithm from any topic of image processing, preferably related to your interests regarding the GSoC project, and propose its implementation using latest Boost.GIL.

Alternatively, bonus project that allows you to show your C++ skills beyond usage of Boost.GIL: Using C++11 type traits and Boost.MP11, define promote metafunction that tries to promote (find) fundamental integral type T (e.g. char, short, etc.) to another integral type with size roughly twice the bit size of T. For example, for using P = promote<char>::type should assert the following static_assert(std::is_same<P, short>::value) or possibly static_assert(std::is_same<P, int>::value).

If you get stuck, don't hesitate to submit even partial solution.

Add a custom footer
Add a custom sidebar
Clone this wiki locally