• Stars
    star
    227
  • Rank 175,900 (Top 4 %)
  • Language
    Go
  • License
    MIT License
  • Created about 6 years ago
  • Updated over 1 year ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

A system independent tool for interactive image manipulation with Voronoi and Delaunay data structures.

Voronoi/Delaunay image manipulation

This project implements a small, lightweight tool for real-time image manipulation with Voronoi/Delaunay data structures.

The focus of this project was, to enable users without knowledge of Voronoi or Delaunay specifics, to experiment and play with different looks a Voronoi or Delaunay structure can give to an image.

Some time ago I implemented a similar effect (also Voronoi/Delaunay) in Python (github.com/MauriceGit/Delaunay_Triangulation). The main goal for this new project was, to make it a lot more robust, user friendly, fast and actually useable.

Interface:

The program will start two separate windows. One to actually display the image and a control window. It will look like the following:

Image view Control view
Image view Controls

Requirements:

  • Graphics card supporting OpenGL 3.3
  • Windows users: Have mingw64 installed. Other C compilers might or might not work. Please report back if it works or submit necessary changes to this README.
  • Have Go (Golang) installed on your system.

Run:

  • Download this repository or run git clone https://github.com/MauriceGit/Voronoi_Image_Manipulation
  • Enter the project directory
  • Run go get ./... to install all dependencies
  • Run go build within the projects directory
  • Run the created executable.
  • Do not remove the Images/apple.png directory. This image is loaded by default when the program starts.

Screenshots and usecases:

Just to give you and incomplete overview what kind of effects you can achieve with this tool (sometimes with the corresponding controls set).

The point Distribution set to Poisson Disk to achieve random but equally distributed points over the whole area. This gives the most pleasing and homogeneous look most of the time. Poisson Disk point dist

The point Distribution set to Random. Truly random point distribution. Will create unequally sized regions. Random point dist

The point Distribution set to Grid will create honeycomb like regions (hexagons) by placing points in a shifted grid. Grid point dist

Grid point dist

Set the Face Rendering to Delaunay Triangles. Delaunay faces

Delaunay faces

Sunset delaunay

An image of a Labrador with Poisson disk distributed points. Voronoi faces

If you like you can add the Voronoi lines and points to actually display the underlaying data structure. Voronoi lines and points

Voronoi lines

Voronoi lines

Sunset voronoi

When checking Adaptive Color, the lines of Delaunay edges and points will get the average color of the image underneath. Creating an interesting effect. Adaptive Color

Adaptive Color checked with Voronoi faces and points displayed with a grid layout. Adaptive Color voronoi

You could just view the points as well (well that doesn't really use Voronoi/Delaunay any more. But still looks cool :)). Just points

At last, you can just ignore the image to investigate/look at voronoi and Delaunay tessellation itself: Just voronoi

Just voronoi and delaunay

More Repositories

1

Delaunay_Triangulation

My own implementation of a Delaunay triangulation and Voronoi partition in Python applied to images.
Python
255
star
2

Partikel_accelleration_on_GPU

Particle accelleration with OpenGL 4.3, using the compute shader to calculate particle movement on graphics hardware.
C
253
star
3

skiplist

A Go library for an efficient implementation of a skip list: https://godoc.org/github.com/MauriceGit/skiplist
Go
252
star
4

compiler

Compiler for a small language into x86-64 Assembly
Go
243
star
5

Simple_GLSL_Shader_Example

A very simple example of how shaders in OpenGL can be used, to color Objects or map a texture on some triangles.
C
239
star
6

Water_Simulation

Water-Simulation with real time specular reflection on the waters surface. The reflection is implemented in GLSL and runs on the GPU and in screen space. The water itself is implemented using a pressure based approach for the surface calculation.
C
149
star
7

XBox_Controller_Linux_Interface

An interface that interacts with an XBox One controller via the usb stream. With simple methods for object or camera control (i.e. for OpenGL contexts).
C
132
star
8

Cloth_Simulation

Cloth-Visualization via particle-simulation.
C
83
star
9

Advanced_Algorithms

Quick implementations of some advanced algorithms for searching, sorting and trees
Python
77
star
10

Screen_Space_Ambient_Occlusion

Giving a scene a depth-dependent shading, completely irregarding the scene complexity, in screen-space.
C
47
star
11

Quaternion_Library

A small library that capsulates most commonly used operations on Quaternions. Also a small sample implementation, that rotates an object around an axis, using Quaternions.
C
40
star
12

Energy-Dome_Terrain

A visually appealing terrain visualization from real-world data with some extras, such as an animated energy dome, LOD tessellation and multisampling
Go
29
star
13

advsearch

A Go library for advanced searching in sorted data structures
Go
22
star
14

Repeat_History

A small but useful command for a linux shell. It makes the bash history more easily accessible than cmd+r.
Shell
19
star
15

Marching_Cubes_on_GPU

A marching cube algorithm, that is executed in parallel on the GPU, using compute shaders. This will later enable a highly parallel creation of advanced landscape/terrain structures in potentially real-time (next project).
Go
9
star
16

tree23

An implementation of a balanced 2,3-tree that allows accessing next/previous elements in O(1) at all times.
Go
8
star
17

Vector_Library

Small vector library in C, containing all basic vector operations.
C
4
star
18

2D_Bin_Packing

several parallel solutions for a 2D bin packing problem for a programming contest.
Python
2
star
19

Variance_Shadow_Maps

Small example of a project, that uses variance shadow maps with hardware Multisampling.
Go
2
star
20

Voronoi_DivideAndConquer

A Go implementation of a voronoi tessellation with the divide and conquer algorithm. It is still work in progress and not yet working properly!
Go
2
star
21

mtVector

A short vector library with all necessary operations for a Delaunay triangulation, including optimized matrix multiplication
Go
1
star
22

game

JavaScript
1
star
23

Agar_Clone_Joystick_Client

A C++ client for our programming challenge (2016) supporting an X-BOX-Controller.
C++
1
star
24

FastDelaunayImages

Go
1
star
25

AdventOfCode

My solutions for the advent of code puzzles (AOC)
Python
1
star
26

Artificial_Neural_Network_Character_Classification

Implementation of an artificial neural network with backpropagation for classification of characters.
Python
1
star
27

Bachelor_Thesis_Arimaa

Implementation of the practical part of my bachelor thesis for the FH-Wedel. The thesis has been awarded with the "Wedeler Hochschulpreis" for innovation. The code implements an artificial intelligence which plays the game of Arimaa.
Java
1
star