Voronoi.cpp - brianin3d-misc - Miscellaneous Example Code

Source path: svn/ trunk/ random/ cxx/ Voronoi.cpp

r207

/*2>/dev/null 2>/dev/null 2>/dev/null 2>/dev/null 2>/dev/null

#############################################################

this=$( which ${0} )
that=$( basename ${this} | sed 's,.cpp$,,')

c++ -O6 ${this} -o ${that} -lm && ./${that} ${*}

#############################################################
exit 

http://en.wikipedia.org/wiki/Voronoi_diagram

*/

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <vector>

typedef enum { RANDOM, GRID, HEX } PointMode;

PointMode toPointMode( int n ) {
	return ( 
		1 == n ? GRID
		: (
			2 == n ? HEX 
			: ( 
				RANDOM
			)
		)
	);
}

PointMode toPointMode( char *s ) {
	return toPointMode( atoi( s ) );
}

struct Color {
	int r, g, b;
	Color() {
		this->zero();
	}
	void zero() {
		this->r = this->g = this->b = 0;
	}
	// TODO: configure color choices from the outside
	int random255() {
		return rand() % 255;
	}
	// TODO: configure color choices from the outside
	void random() {
		this->r = this->random255();
		this->g = this->random255();
		this->b = this->random255();
	}
	void copy( Color &that ) {
		this->r = that.r;
		this->g = that.g;
		this->b = that.b;
	}
	void add( Color &that ) {
		this->r += that.r;
		this->g += that.g;
		this->b += that.b;
	}
	void div( float f ) {
		if ( 0 != f ) {
			r /= f;
			g /= f;
			b /= f;
		}
	}
	int equals( Color &that ) {
		return this->r == that.r && this->g == that.g && this->b == that.b;
   	}
	int average( Color &that ) {
		this->r = ( this->r + that.r ) / 2;
		this->g = ( this->g + that.g ) / 2;
		this->b = ( this->b + that.b ) / 2;
	}
	void print( FILE *fp ) {
		fprintf( fp, "%c%c%c", r, g, b );
	}
	void cap() { 
		if ( r > 255 ) r = 255;
		if ( g > 255 ) g = 255;
		if ( b > 255 ) b = 255;
		if ( r < 0 ) r = 0;
		if ( g < 0 ) g = 0;
		if ( b < 0 ) b = 0;
	}
};

struct ColoredPoint {
	int x, y;
	Color color;
	ColoredPoint( int x = 0 , int y = 0 ) {
		set( x, y );
	}
	void set( int x, int y ) {
		this->x = x;
		this->y = y;
		this->color.random();
	}
	void random( int w, int h ) {
		this->set( rand() % w, rand() % h );
	}
	/*
	   this distance calculation wraps around
	*/
	int distanceSquared( float x, float y, int w, int h ) {
		float xdist = fabs( this->x - x );
		float ydist = fabs( this->y - y );

		if ( xdist > w / 2 ) {
			if ( this->x < x ) {
				xdist = this->x + ( w - x );
			} else {
				xdist = x + ( w - this->x );
			}
		}
		if ( ydist > h / 2 ) {
			if ( this->y < y ) {
				ydist = this->y + ( h - y );
			} else {
				ydist = y + ( h - this->y );
			}
		}
		return xdist * xdist + ydist * ydist;
	}

	void rotate( float a_cos, float a_sin, int w, int h ) {
		int dx = x - w / 2;
		int dy = y - h / 2;
		int fx = dx * a_cos + dy * a_sin;
		int fy = dy * a_cos + dx * a_sin;
		x = fx;
		y = fy;
	}
};

struct Voronoi {
	int w, h, n;
	int antialias;
	PointMode mode;
	const char *ppm_filename;
	float rotation;
	float kolor;

	Voronoi() {
		w = 256;
		h = 256;
		n = 64;
		antialias = 1;
		mode = RANDOM;
		ppm_filename = "voronoi.ppm";
		rotation = 0;
		kolor = 0;
	}

	int usage( char *name ) {
		char *basename = strrchr( name, '/' );
		if ( NULL != basename ) {
			name = &( basename[ 1 ] );
		}
		printf( 
			"Usage: %s [options]\n"
			"Generate fun Voronoi diagrams\n"
			"\n"
			"\t-w width     width of the image: default is 256\n"
			"\t-h width     height of the image: default is 256\n"
			"\t-f filename  filename to write to: default is voronoi.ppm\n"
			"\t-m MODE      0 is random, 1 is grid and 2 is hexagons: default is random(0)\n"
			"\t-n POINTS    number of points to use: default is 64\n"
			"\t             for non-random mode, it should be a perfect square\n"
			"\t             and width and height should be divisible by sqrt(n)\n"
			"\t             eg: if n is 64, width and height could be 256 cuz 0 = 256 %% 8\n"
			"\t-a ANTI      enable, disable antialiasing: default is on(1)\n"
			"\t-k KOLOR     this enables a weird color mode, try -k 63: default is 0(off)\n"
			"\t-r RADIANS   rotate the points... kinda: default is 0\n"
			"\n"
			"eg: %s -m 2 -k 57 -r 0 && xv -root -quit voronoi.ppm\n"
			"eg: %s && xv -root -quit voronoi.ppm\n"
			, name 
			, name 
			, name 
		);
		return 0;
	}

	void closestColor( std::vector< ColoredPoint > points, int x, int y, Color &accumulator ) {
		n = points.size();
		accumulator.zero();

		float d = 0;
		int closest_distance = 0;
		int distance[ n ];

		// find the closest point to this point (x,y) 
		for ( int i = 0 ; i < n ; i++ ) {
			distance[ i ] = points[ i ].distanceSquared( x, y, w, h );
			if ( 0 == i || distance[ i ] < closest_distance ) {
				closest_distance = distance[ i ];
			}
		}

		// sometimes a point is closer to more than one point
		for ( int i = 0 ; i < n ; i++ ) {
			if ( 0 == kolor ) {
				if ( distance[ i ] == closest_distance ) {
					d++;
					accumulator.add( points[ i ].color );
				}
			} else {
				float f = kolor * ( 1 / float( 1 + distance[ i ] ) );
				accumulator.r += points[ i ].color.r * f ;
				accumulator.g += points[ i ].color.g * f ;
				accumulator.b += points[ i ].color.b * f ;
			}
		}
		accumulator.cap();


		accumulator.div( d );
	}

	int parseArgs( int argc, char *argv[] ) {
		int parsedArgs = 1;
		for ( int i = 1 ; i < argc && parsedArgs ; i++ ) {
			if ( '-' == argv[ i ][ 0 ] && i < argc - 1 ) {
				switch ( argv[ i ][ 1 ] ) {
					case 'w': w = atoi( argv[ ++i ] ); break;
					case 'h': h = atoi( argv[ ++i ] ); break;
					case 'n': n = atoi( argv[ ++i ] ); break;
					case 'a': antialias = atoi( argv[ ++i ] ); break;
					case 'm': mode = toPointMode( argv[ ++i ] ); break;
					case 'k': kolor = atof( argv[ ++i ] ); break;
					case 'r': rotation = atof( argv[ ++i ] ); break;
					case 'f': ppm_filename = argv[ ++i ]; break;
					default: parsedArgs = !parsedArgs;
				}
			} else {
				parsedArgs = !parsedArgs;
			}
		}
		return parsedArgs;
	}

	void initPoints( std::vector< ColoredPoint > &points ) {
		int xi = w / floor( sqrt( n ) );
		int yi = h / floor( sqrt( n ) );
		int q = 0;

		switch ( mode ) {
			case GRID:
				for ( int y = 0 ; y < h ; y += yi ) {
					for ( int x = 0 ; x < w ; x += xi ) {
						points.push_back( ColoredPoint( x + xi /2, y + yi  / 2) );
					}
				}
				break;
			case HEX:
				for ( int y = 0 ; y < h ; y += yi ) {
					for ( int x = ( 0 == q++ % 2 ? 0 : xi / 2 ) ; x < w ; x += xi ) {
						points.push_back( ColoredPoint( x, y ) );
					}
				}
				break;
			default:
				for ( int i = 0 ; i < n ; i++ ) {
					ColoredPoint point;
					point.random( w, h );
					points.push_back( point );
				}
		}
	}

	int main( int argc, char *argv[] ) { 
		int parsedArgs = parseArgs( argc, argv );
		if ( !parsedArgs ) {
			return usage( argv[ 0 ] );
		}
		printf( "%dx%d n=%d f=%s\n", w, h, n, ppm_filename );

		std::vector< ColoredPoint > points;
		initPoints( points );

		Color current;
		Color previous;

		FILE *fp = fopen( ppm_filename, "w" );
		fprintf( fp, "P6\n" "%d %d\n" "255\n", w, h );

		float a_cos = cos( rotation );
		float a_sin = sin( rotation );

		for ( int i = 0 ; i < points.size() ; i++ ) {
			points[ i ].rotate( a_cos, a_sin, w, h );
		}

		for ( int y = 0 ; y < h ; y++ ) {
			for ( int x = 0 ; x < w ; x++ ) {
				closestColor( points, x, y, current );
				if ( antialias && 0 != x ) {
					// sort of a trailing average to "antialias"
					current.average( previous );
					previous.copy( current );
				}
				current.print( fp );
			}
		}

		fclose( fp );

		return 0;
	}
};

int 
main( int argc, char *argv[] ) { 
	srand( time( NULL ) );
	Voronoi diagram;
	diagram.main( argc, argv );
}

Show details Hide details

Change log

r16 by brianin3d on Jun 6, 2009 Diff

add

Go to:

Project members, sign in to write a code review

Older revisions

All revisions of this file

File info

Size: 7592 bytes, 328 lines

View raw file

File properties

svn:executable: *