joshua/awesome-attractor
Archived
1
Fork 0
Code Activity

Merge branch 'master' of localhost:AwesomeAttractor

Browse source
This commit is contained in:
Joshua Moerman (@Kassalade) 2011-04-07 18:59:53 +02:00
commit 3d4e11ddea
42 changed files with 1251 additions and 1446 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

111
Attractor.cpp
View file

@ -1,6 +1,6 @@
#include "Attractor.hpp" #include "Attractor.hpp"
#include <iostream> #include "Logger.hpp"
#include <fstream> #include <fstream>
#include <cstdlib> #include <cstdlib>
#include <string> #include <string>
@ -10,100 +10,75 @@
#include "Projector.hpp" #include "Projector.hpp"
Attractor::Attractor(const char* const fileName) { Attractor::Attractor(const std::string& filename) : kernel(0), projector(0) {
// opening file // opening file
std::cout << "Reading file " << fileName << "..." << std::endl; LogInfo("Reading file '%s'...\n", filename.c_str());
stfu::node system; stfu::node system;
system.read(fileName); system.read(filename.c_str());
stfu::node attractor = system.getChild("AttractorKernel");
myAttractor = AttractorKernel::createAttractorKernel(attractor);
kernel = AttractorKernel::createAttractorKernel(system.getChild("AttractorKernel"));
projector = Projector::createProjector(system.getChild(system.getValue("Projector")), system);
} }
Attractor::~Attractor(){ Attractor::~Attractor(){
delete myAttractor; delete kernel;
} }
// this should probably done in the projector section // this should probably done in the projector section
void Attractor::init_range() { void Attractor::init_range() {
// stabilize attractor // stabilize attractor
for ( unsigned int i = 0; i < 100000; i++ ) { for ( unsigned int i = 0; i < 100000; i++ ) {
iterate(); iterate();
} }
// initialize projectors with dimension and first point
const unsigned int dimension = myAttractor->getDimension();
const double * point = myAttractor->vector();
for ( std::vector<Projector*>::iterator it = projectors.begin(); it != projectors.end(); it++ ) {
(*it)->extern_dim = dimension;
(*it)->intern_dim = 2;
(*it)->init(point);
}
// update ranges
for ( unsigned int i = 0; i < 100000; i++ ) {
iterate();
for ( std::vector<Projector*>::iterator it = projectors.begin(); it != projectors.end(); it++ ) {
(*it)->update_range(point);
}
}
for ( std::vector<Projector*>::iterator it = projectors.begin(); it != projectors.end(); it++ ) {
(*it)->finish_range();
}
} }
bool Attractor::is_chaos() { bool Attractor::is_chaos() {
/* /*
check existence of attractor: check existence of attractor:
Escaping Escaping
Single point attractor Single point attractor
Lyapunov exponent Lyapunov exponent
*/ */
/* /*
double sum = 0; double sum = 0;
for ( unsigned int i = 0; i < dim; i++ ) { for ( unsigned int i = 0; i < dim; i++ ) {
const double dist = 0; //new_point[i] - point[i]; const double dist = 0; //new_point[i] - point[i];
sum += dist*dist; sum += dist*dist;
} }
if ( sum >= 1.0e7 ) { if ( sum >= 1.0e7 ) {
// big change => Escaping // big change => Escaping
return false; return false;
} }
if ( sum <= 1.0e-7 ) { if ( sum <= 1.0e-7 ) {
// small change => singularity // small change => singularity
return false; return false;
} }
return true; return true;
*/ */
return true; return true;
} }
void Attractor::iterate() { void Attractor::iterate() {
(*myAttractor)(); (*kernel)();
} }
void Attractor::plot() { void Attractor::plot() {
for ( std::vector<Projector *>::iterator it = projectors.begin(); it != projectors.end(); it++ ) { const double * point = kernel->vector();
const double * point = myAttractor->vector(); projector->plot(point);
(*it)->plot(point);
}
} }
/* /*
IO & control IO & control
*/ */
void Attractor::output() { void Attractor::output() {
const unsigned int dimension = myAttractor->getDimension(); const unsigned int dimension = kernel->getDimension();
const double * point = myAttractor->vector(); const double * point = kernel->vector();
for ( unsigned int i = 0; i < dimension; i++ ) { for ( unsigned int i = 0; i < dimension; i++ ) {
std::cout << point[i] << " "; LogMoreInfo("%f, ", point[i]);
} }
std::cout << std::endl; LogMoreInfo("\n");
} }

19
Attractor.hpp
View file

@ -1,6 +1,7 @@
#ifndef ATTRACTOR_HPP #ifndef ATTRACTOR_HPP
#define ATTRACTOR_HPP #define ATTRACTOR_HPP
#include <string>
#include <vector> #include <vector>
class Projector; class Projector;
@ -9,22 +10,24 @@ class AttractorKernel;
class Attractor { class Attractor {
private: private:
AttractorKernel * myAttractor; AttractorKernel * kernel;
public: public:
// should be private really // should be private really
std::vector<Projector *> projectors; Projector* projector;
Attractor(const char* const filename); Attractor(const std::string& filename);
~Attractor(); ~Attractor();
void init_range(); void init_range();
bool is_chaos(); bool is_chaos();
void iterate(); void iterate();
void plot(); void plot();
void output(); void output();
friend std::ostream& operator<<(std::ostream& os, Attractor const& x);
}; };

110
AttractorKernel.cpp
View file

@ -1,15 +1,15 @@
/* /*
* AttractorKernel.cpp * AttractorKernel.cpp
* AwesomeAttractor * AwesomeAttractor
* *
* Created by Joshua Moerman on 07-08-10. * Created by Joshua Moerman on 07-08-10.
* Copyright 2010 Rodo. All rights reserved. * Copyright 2010 Rodo. All rights reserved.
* *
*/ */
#include "AttractorKernel.hpp" #include "AttractorKernel.hpp"
#include "Logger.hpp"
#include <algorithm> #include <algorithm>
#include <iostream>
#pragma mark - #pragma mark -
#pragma mark memory #pragma mark memory
@ -19,9 +19,8 @@ numberOfParameters(numberOfParameters), dimension(dimension){
try { try {
allocate(); allocate();
} } catch (std::exception& e) {
catch (std::exception& e) { LogError("Couldn't construct Attractorkernel: %s\n", e.what());
std::cout << "Couldn't construct AttractorKernel: " << e.what() << std::endl;
dealloc(); dealloc();
} }
@ -85,7 +84,6 @@ unsigned int AttractorKernel::getDimension() const{
#pragma mark - #pragma mark -
#pragma mark factory function #pragma mark factory function
#include "AttractorKernel.hpp"
#include "kernels/Logistic.hpp" #include "kernels/Logistic.hpp"
#include "kernels/Lorenz3D.hpp" #include "kernels/Lorenz3D.hpp"
#include "kernels/Polynomial.hpp" #include "kernels/Polynomial.hpp"
@ -97,64 +95,64 @@ AttractorKernel * AttractorKernel::createAttractorKernel(stfu::node& attractor){
AttractorKernel * myAttractor = NULL; AttractorKernel * myAttractor = NULL;
// reading basic stuff // reading basic stuff
const std::string attractorType = attractor.getValue("type"); const std::string attractorType = attractor.getValue("type");
const std::string attractorDimension = attractor.getValue("dimensions"); const std::string attractorDimension = attractor.getValue("dimensions");
// for ( unsigned int i = 0; attractorType[i] != '\0'; i++ ) { // for ( unsigned int i = 0; attractorType[i] != '\0'; i++ ) {
// attractorType[i] = tolower(attractorType[i]); // attractorType[i] = tolower(attractorType[i]);
// } // }
const unsigned int dimension = atoi(attractorDimension.c_str()); const unsigned int dimension = atoi(attractorDimension.c_str());
std::cout << " Formula: " << attractorType << std::endl; LogMoreInfo(" Formula: %s\n", attractorType.c_str());
std::cout << " Dimensions: " << dimension << std::endl; LogMoreInfo(" Dimensions: %d\n", dimension);
// depending on type, make the formula object // depending on type, make the formula object
if ( attractorType == "lorenz" ){ if ( attractorType == "lorenz" ){
if ( dimension == 3 ) { if ( dimension == 3 ) {
myAttractor = new Lorenz3D(); myAttractor = new Lorenz3D();
} else { } else {
std::cerr << "something wrong"; LogError("something wrong\n");
exit(37); exit(37);
} }
} else if ( attractorType == "polynomial" ) { } else if ( attractorType == "polynomial" ) {
const std::string attractorOrde = attractor.getValue("orde"); const std::string attractorOrde = attractor.getValue("orde");
const unsigned int orde = atoi(attractorOrde.c_str()); const unsigned int orde = atoi(attractorOrde.c_str());
std::cout << " Orde: " << orde << std::endl; LogMoreInfo(" Orde: %d\n", orde);
myAttractor = new Polynomial(dimension, orde); myAttractor = new Polynomial(dimension, orde);
} else if ( attractorType == "polynomial a" ) { } else if ( attractorType == "polynomial a" ) {
if ( dimension == 3 ) { if ( dimension == 3 ) {
myAttractor = new PolynomialA3D(); myAttractor = new PolynomialA3D();
} else { } else {
std::cerr << "something wrong"; LogError("something wrong\n");
exit(37); exit(37);
} }
} else if ( attractorType == "logistic" ) { } else if ( attractorType == "logistic" ) {
myAttractor = new Logistic(dimension); myAttractor = new Logistic(dimension);
} else if ( attractorType == "unravel" ) { } else if ( attractorType == "unravel" ) {
if ( dimension == 3 ) { if ( dimension == 3 ) {
myAttractor = new Unravel3D(); myAttractor = new Unravel3D();
} else { } else {
std::cerr << "something wrong"; LogError("something wrong\n");
exit(37); exit(37);
} }
} else { } else {
std::cout << "'" << attractorType << "' not recognized" << std::endl; LogError("'%s' not recognized\n", attractorType.c_str());
exit(3); exit(37);
} }
// read parameters // read parameters
const unsigned int numberOfParameters = myAttractor->getNumberOfParameters(); const unsigned int numberOfParameters = myAttractor->getNumberOfParameters();
for ( unsigned int i = 0; i < numberOfParameters; i++ ) { for ( unsigned int i = 0; i < numberOfParameters; i++ ) {
stfu::node attractorParameters = attractor.getChild("parameters"); stfu::node attractorParameters = attractor.getChild("parameters");
(*myAttractor)[i] = atof(attractorParameters.getValue(i).c_str()); (*myAttractor)[i] = atof(attractorParameters.getValue(i).c_str());
std::cout << " Parameter " << i << " set to " << (*myAttractor)[i] << ", "; LogMoreInfo(" Parameter %d set to %f, ", i, (*myAttractor)[i]);
} }
std::cout << std::endl << " Reading file complete" << std::endl; LogMoreInfo("\n Reading file complete\n");
return myAttractor; return myAttractor;
} }

14
AttractorKernel.hpp
View file

@ -22,21 +22,20 @@ protected:
// stuff used by subclasses // stuff used by subclasses
AttractorKernel(const unsigned int dimension, const unsigned int numberOfParameters); AttractorKernel(const unsigned int dimension, const unsigned int numberOfParameters);
void reallocParameters(const unsigned int numberOfParameters);
public: public:
// parameters are stored in a array of doubles // parameters are stored in a array of doubles
double & operator[](const unsigned int index); double & operator[](const unsigned int index);
double const & operator[](const unsigned int index) const; double const & operator[](const unsigned int index) const;
unsigned int getNumberOfParameters() const; unsigned int getNumberOfParameters() const;
// iterate his formula, implemented by subclasses // iterate his formula, implemented by subclasses
virtual void operator()() = 0; virtual void operator()() = 0;
// getter functions for teh resulta (can't be used as setters) // getter functions for teh resulta (can't be used as setters)
double const * vector() const; double const * vector() const;
double const * previousVector() const; double const * previousVector() const;
unsigned int getDimension() const; unsigned int getDimension() const;
// dtor, should be virtual for subclasses to be deleted // dtor, should be virtual for subclasses to be deleted
@ -47,5 +46,6 @@ public:
}; };
#endif // ATTRACTORKERNEL_HPP #endif // ATTRACTORKERNEL_HPP

26
AwesomeAttractor.cbp
View file

@ -50,16 +50,15 @@
</Build> </Build>
<Compiler> <Compiler>
<Add option="-Wall" /> <Add option="-Wall" />
<Add option="-Wno-unknown-pragmas" />
</Compiler> </Compiler>
<Linker>
<Add library="libpng" />
</Linker>
<Unit filename="Attractor.cpp" /> <Unit filename="Attractor.cpp" />
<Unit filename="Attractor.hpp" /> <Unit filename="Attractor.hpp" />
<Unit filename="AttractorKernel.cpp" /> <Unit filename="AttractorKernel.cpp" />
<Unit filename="AttractorKernel.hpp" /> <Unit filename="AttractorKernel.hpp" />
<Unit filename="Canvas.cpp" /> <Unit filename="Canvas.cpp" />
<Unit filename="Canvas.hpp" /> <Unit filename="Canvas.hpp" />
<Unit filename="Logger.hpp" />
<Unit filename="Projector.cpp" /> <Unit filename="Projector.cpp" />
<Unit filename="Projector.hpp"> <Unit filename="Projector.hpp">
<Option compilerVar="CC" /> <Option compilerVar="CC" />
@ -68,6 +67,14 @@
<Unit filename="attractors/testLorenz.stf" /> <Unit filename="attractors/testLorenz.stf" />
<Unit filename="attractors/testPolynomial.stf" /> <Unit filename="attractors/testPolynomial.stf" />
<Unit filename="attractors/testUnravel.stf" /> <Unit filename="attractors/testUnravel.stf" />
<Unit filename="canvae/PNG.cpp">
<Option target="&lt;{~None~}&gt;" />
</Unit>
<Unit filename="canvae/PNG.hpp">
<Option target="&lt;{~None~}&gt;" />
</Unit>
<Unit filename="canvae/Raw.cpp" />
<Unit filename="canvae/Raw.hpp" />
<Unit filename="defines.hpp" /> <Unit filename="defines.hpp" />
<Unit filename="kernels/Logistic.cpp" /> <Unit filename="kernels/Logistic.cpp" />
<Unit filename="kernels/Logistic.hpp" /> <Unit filename="kernels/Logistic.hpp" />
@ -81,8 +88,17 @@
<Unit filename="kernels/Unravel3D.hpp" /> <Unit filename="kernels/Unravel3D.hpp" />
<Unit filename="main.cpp" /> <Unit filename="main.cpp" />
<Unit filename="myMath.hpp" /> <Unit filename="myMath.hpp" />
<Unit filename="pngwriter/pngwriter.cc" /> <Unit filename="ostream_helpers.h" />
<Unit filename="pngwriter/pngwriter.h" /> <Unit filename="pngwriter/pngwriter.cc">
<Option target="&lt;{~None~}&gt;" />
</Unit>
<Unit filename="pngwriter/pngwriter.h">
<Option target="&lt;{~None~}&gt;" />
</Unit>
<Unit filename="projectors/Normalizer.cpp" />
<Unit filename="projectors/Normalizer.hpp" />
<Unit filename="projectors/Projection.cpp" />
<Unit filename="projectors/Projection.hpp" />
<Unit filename="stfu/stf.cpp" /> <Unit filename="stfu/stf.cpp" />
<Unit filename="stfu/stf.hpp" /> <Unit filename="stfu/stf.hpp" />
<Extensions> <Extensions>

244
Canvas.cpp
View file

@ -1,245 +1,3 @@
#include <iostream>
#include <fstream>
#include <cmath>
#include <cstdlib>
#include <cassert>
#include "pngwriter/pngwriter.h"
#include "Canvas.hpp" #include "Canvas.hpp"
// lol
Canvas::Canvas(unsigned int width, unsigned int height, unsigned int num_colors):
dim(2), width(width), height(height), num_colors(num_colors), v(0) {
int_array = new unsigned int[width*height*num_colors];
size = new unsigned int[2];
size[0] = width;
size[1] = height;
assert(int_array != NULL);
clear();
#ifdef HARDDEBUG
cout << "New canvas" << endl;
#endif
}
void Canvas::clear() {
for ( unsigned int i = 0; i < width*height*num_colors; i++ ) {
int_array[i] = 0;
}
}
//void Canvas::update_viewwindow() {
//
// //width and height of attractor
// const double dx = xmax - xmin;
// const double dy = ymax - ymin;
//
// //fix aspect ratio
// if ( dx > dy * ((float)width / height) ) {
// const double height2 = dx * ((float)height / width);
// const double middle = 0.5 * (ymax + ymin);
// ymax = middle + 0.5 * height2;
// ymin = middle - 0.5 * height2;
//
// } else {
// const double width2 = dy * ((float)width / height);
// const double middle = 0.5 * (xmax + xmin);
// xmax = middle + 0.5 * width2;
// xmin = middle - 0.5 * width2;
// }
//
// //add a 4% marge
// xmin -= 0.02 * dx;
// xmax += 0.02 * dx;
// ymin -= 0.02 * dy;
// ymax += 0.02 * dy;
//
// //constants for speed
// constant1 = width / (xmax - xmin);
// constant2 = height / (ymax - ymin);
//}
void Canvas::plot(double x, double y) {
// gets x and y coordinate
// ranges [-1, 1] and [-1, 1]
// so how to do the aspect shiz, i don't know
const unsigned int x_int = x*width + width*.5;
const unsigned int y_int = y*width + height*.5;
const unsigned int index = x_int + width * y_int;
if(x_int < width && y_int < height) {
int_array[index]++;
}
}
void Canvas::plot(double x, double y, unsigned int c) {
// same as plot(double x, double y)
// now with color control
const unsigned int x_int = x*width + width*.5;
const unsigned int y_int = y*width + height*.5;
const unsigned int index = x_int + width * y_int + width*height*c;
if(x_int < width && y_int < height) {
int_array[index]++;
}
}
void Canvas::plot(double x, double y, unsigned int c, double intensity) {
// same as plot(double x, double y, unsigned int c)
// but now uses the float array (not yet implemented
}
/*
I/O functions
*/
void Canvas::output() {
std::cout << "Canvas: " << std::endl;
std::cout << "Dimensions: " << width << " x " << height << " x " << num_colors << std::endl;
}
void Canvas::output_file(const char * filename){
unsigned int * max_int = new unsigned int[num_colors];
double * power = new double[num_colors];
for ( unsigned int i = 0; i < num_colors; i++ ) {
max_int[i] = 0;
double cumulative = 0;
unsigned int n = 0;
for ( unsigned int j = 0; j < width*height; j++) {
if ( max_int[i] < int_array[j+i*width*height] ) {
max_int[i] = int_array[j+i*width*height];
}
if ( int_array[j+i*width*height] ) {
cumulative += int_array[j+i*width*height];
n++;
}
}
if ( n > 100 ) {
const double average = cumulative / (double)n;
power[i] = -2.5/log(average/(double)max_int[i]);
if ( power[i] < 0 )
power[i] = 1;
} else {
power[i] = 1;
}
if ( n <= 10 ) {
std::cout << "not enough data" << std::endl;
}
}
const double vibrancy = 2.0;
double averagePower = 0;
for ( unsigned int i = 0; i < num_colors; i++ ) {
averagePower += power[i];
}
averagePower /= (double)num_colors;
for ( unsigned int i = 0; i < num_colors; i++ ) {
power[i] = vibrancy*power[i] + (1.0 - vibrancy)*averagePower;
}
pngwriter * pngFile = new pngwriter(width, height, 0.0, filename);
pngFile->setcompressionlevel(9);
pngFile->settext("Attractor", "Joshua Moerman", "A awesome attractor", "AwesomeAttractor");
for ( unsigned int x = 0; x < width; x++ ) {
for ( unsigned int y = 0; y < height; y++ ) {
double r = 0.0;
double g = 0.0;
double b = 0.0;
for ( unsigned int c = 0; c < num_colors; c++ ) {
const double norm_value = (double)int_array[x + y*width + c*width*height]/max_int[c];
switch(c){
case 0: {
r = (pow(norm_value, power[c]))*3.5;
break;
}
case 1: {
g = (pow(norm_value, power[c]))*3.0;
break;
}
case 2: {
b = (pow(norm_value, power[c]))*3.0;
break;
}
default:
break;
}
}
//pngwriter clips values for me
pngFile->plot(x, y, r, g, b);
}
}
delete[] max_int;
delete[] power;
std::cout << "ready for writing file i suppose: " << filename << std::endl;
std::ofstream file(filename);
if ( !file ) {
std::cout << "jij hebt pech, geen png voor jou" << std::endl;
}
std::cout << filename << std::endl;
pngFile->close();
}
void Canvas::output_file(){
char filename[50];
time_t t = time(0);
struct tm* lt = localtime(&t);
int r = rand() % 10;
sprintf(filename, "render/attractor_%04d-%02d-%02d_%02d-%02d-%02d-%01d.png", lt->tm_year + 1900, lt->tm_mon + 1, lt->tm_mday, lt->tm_hour, lt->tm_min, lt->tm_sec, r);
output_file(filename);
}
void Canvas::output_raw(const char * filename){
std::ofstream outfile (filename, std::ofstream::binary);
outfile.write(reinterpret_cast<char*>(int_array), sizeof(unsigned int)*width*height*num_colors);
}
void Canvas::output_raw(){
char filename[52];
time_t t = time(0);
struct tm* lt = localtime(&t);
int r = rand() % 10;
sprintf(filename, "render/canv%dx%d_%04d-%02d-%02d_%02d-%02d-%02d-%01d.canv", width, height, lt->tm_year + 1900, lt->tm_mon + 1, lt->tm_mday, lt->tm_hour, lt->tm_min, lt->tm_sec, r);
output_raw(filename);
}
void Canvas::input_raw(const char * filename){
std::ifstream infile(filename, std::ifstream::binary);
if ( ! infile ) {
std::cout << "poep" << std::endl;
return;
}
infile.seekg (0, std::ios::end);
int length = infile.tellg();
infile.seekg (0, std::ios::beg);
std::cout << "length: " << length << " =? " << static_cast<int>(width*height*num_colors*sizeof(unsigned int)) << std::endl;
infile.read (reinterpret_cast<char*>(int_array), sizeof (unsigned int)*width*height*num_colors);
}

48
Canvas.hpp
View file

@ -2,49 +2,21 @@
#define CANVAS_HPP #define CANVAS_HPP
//#include "Vector.hpp" class Canvas {
#include "Attractor.hpp" protected:
#include "Projector.hpp"
// TODO : Canvas class abstraheren (zodat er makkelijk verschillende soorten canvae gemaakt kunnen worden) unsigned int dimension;
Canvas (const unsigned int dimension) : dimension (dimension) {};
class Canvas{ public:
friend class Projector;
unsigned int dim; unsigned int getDimension() const { return dimension; };
unsigned int width;
unsigned int height;
unsigned int num_colors;
unsigned int * size; virtual ~Canvas() {};
unsigned int * int_array; virtual void clear() = 0;
virtual void plot (const double * normalizedPosition) = 0;
public: virtual void output_file (const char * filename) const = 0;
double v;
Canvas(unsigned int width, unsigned int height, unsigned int num_colors = 1);
void clear();
void plot(double x, double y);
void plot(double x, double y, unsigned int c);
// TODO : make double array in canvas (ander soort canvas)
// TODO : subpixel sampling (anders soort canvas)
void plot(double x, double y, unsigned int c, double intensity);
void output();
//void output(Vector& point);
void output_file(const char * filename);
void output_file();
void output_raw(const char * filename);
void output_raw();
void input_raw(const char * filename);
}; };
#endif // CANVAS_HPP #endif // CANVAS_HPP

22
Logger.hpp Normal file
View file

@ -0,0 +1,22 @@
#ifndef LOGGER_HPP_INCLUDED
#define LOGGER_HPP_INCLUDED
#include <cstdio>
extern int verbose;
#define LogDebug(s, ...) \
if ( verbose >= 3 ) printf(s, ##__VA_ARGS__);
#define LogMoreInfo(s, ...) \
if ( verbose >= 2 ) printf(s, ##__VA_ARGS__);
#define LogInfo(s, ...) \
if ( verbose >= 1 ) printf(s, ##__VA_ARGS__);
#define LogError(s, ...) \
if ( verbose >= 0 ) { printf("%s, %d: ", __FILE__, __LINE__); printf(s, ##__VA_ARGS__); }
#endif // LOGGER_HPP_INCLUDED

110
Parameters.cpp
View file

@ -1,110 +0,0 @@
#include <iostream>
using namespace std;
#include "Parameters.hpp"
Parameters::Parameters(unsigned int num_parameters, float default_val):
num_parameters(num_parameters) {
begin = new (nothrow) Vector(num_parameters, default_val);
eind = new (nothrow) Vector(num_parameters, default_val);
interpolated = new (nothrow) Vector(num_parameters, default_val);
// *interpolated = *begin
check_pointers();
#ifdef HARDDEBUG
cout << "New Parameters with one default val:" << endl << *this << endl;
#endif
}
/*Parameters::Parameters(unsigned int num_parameters, float default_val1, float default_val2):
num_parameters(num_parameters) {
begin = new (nothrow) Vector(num_parameters, default_val1);
eind = new (nothrow) Vector(num_parameters, default_val2);
interpolated = new (nothrow) Vector(num_parameters, default_val1);
// *interpolated = *begin
check_pointers();
#ifdef HARDDEBUG
cout << "New Parameters with two default vals:" << endl << *this << endl;
#endif
}*/
Parameters::~Parameters() {
delete begin;
delete eind;
delete interpolated;
#ifdef HARDDEBUG
cout << "Parameters deleted" << endl;
#endif
}
void Parameters::check_pointers() {
assert(begin != NULL);
assert(eind != NULL);
assert(interpolated != NULL);
}
void Parameters::set(unsigned int parameter, float val1, float val2) {
assert(parameter < num_parameters);
begin->coordinates[parameter] = val1;
eind->coordinates[parameter] = val2;
interpolated->coordinates[parameter] = val1;
#ifdef HARDDEBUG
cout << "Parameter " << parameter << " set to: " << val1 << " - " << val2 << endl;
#endif
}
void Parameters::set(unsigned int parameter, float val) {
assert(parameter < num_parameters);
begin->coordinates[parameter] = val;
eind->coordinates[parameter] = val;
interpolated->coordinates[parameter] = val;
#ifdef HARDDEBUG
cout << "Parameter " << parameter << " set to: " << val << endl;
#endif
}
float Parameters::get(unsigned int parameter) {
assert(parameter < num_parameters);
#ifdef HARDDEBUG
cout << "Asked for parameter " << parameter << " with value:" << interpolated->coordinates[parameter] << endl;
#endif
return interpolated->coordinates[parameter];
}
void Parameters::interpolate(float time) {
/*
Dit is mogelijk met vector rekenen:
(*interpolated) = (*begin) * ( 1.0 - time ) + (*eind) * time;
Maar we doen het per element, zodat we simpelere code hebben,
geen vectoren hoeven te returnen en makkelijker kunnen optimaliseren
*/
const float invtime = 1.0 - time;
for ( unsigned int i = 0; i < num_parameters; i++ ) {
interpolated->coordinates[i] = invtime * begin->coordinates[i] + time * eind->coordinates[i];
}
#ifdef HARDDEBUG
cout << "interpolate() result" << endl << *interpolated << endl;
#endif
}
ostream& operator<<(ostream& os, const Parameters& param) {
os << param.num_parameters << endl;
os << "Begin:" << endl << *param.begin << endl;
os << "Eind:" << endl << *param.eind << endl;
os << "Interpolated:" << endl << *param.interpolated << endl;
os <<endl;
return os;
}

34
Parameters.hpp
View file

@ -1,34 +0,0 @@
#ifndef PARAMETER_HPP
#define PARAMETER_HPP
#include "Vector.hpp"
class Parameters {
Vector * begin;
Vector * eind;
Vector * interpolated;
void check_pointers();
public:
// for checks and assertions
unsigned int num_parameters;
Parameters(unsigned int num_parameters, float default_val = 0.0);
//Parameters(unsigned int num_parameters, float default_val1, float default_val2);
~Parameters();
void set(unsigned int parameter, float val1, float val2);
void set(unsigned int parameter, float val);
float get(unsigned int parameter);
void interpolate(float time);
// output operator
friend ostream& operator<<(ostream& os, const Parameters& param);
};
#endif // PARAMETER_HPP

130
Projector.cpp
View file

@ -1,109 +1,61 @@
#include <iostream> #include "Logger.hpp"
#include <cmath>
#include <cassert>
#include "Projector.hpp" #include "Projector.hpp"
#include <algorithm>
#include "Canvas.hpp" #include "Canvas.hpp"
#include "myMath.hpp"
void Projector::init(const double * point) { #pragma mark -
init_vector(); #pragma mark memory
project(point); Projector::Projector(unsigned int inputDimension, unsigned int outputDimension) : canvas(0), projector(0), projectedPoint(0), inputDimension(inputDimension), outputDimension(outputDimension), ready(true) {
init_range(); try {
allocate();
} catch(std::exception& e) {
LogError("Couldn't construct Projector: %s\n", e.what());
deallocate();
}
std::fill_n(projectedPoint, outputDimension, 0.0);
} }
void Projector::init_vector() { Projector::~Projector(){
project_point = new double[intern_dim]; deallocate();
offset = new double[intern_dim];
assert(project_point != NULL);
assert(offset != NULL);
} }
void Projector::init_range() { void Projector::allocate() {
range_min = new double[intern_dim]; projectedPoint = new double[outputDimension];
range_max = new double[intern_dim];
assert(range_min != NULL);
assert(range_max != NULL);
for ( unsigned int i = 0; i < intern_dim; i++ ) {
range_min[i] = range_max[i] = project_point[i];
}
} }
void Projector::update_range(const double * point) { void Projector::deallocate() {
project(point); delete[] projectedPoint;
for ( unsigned int i = 0; i < intern_dim; i++ ) { projectedPoint = NULL;
if ( project_point[i] < range_min[i] ) {
range_min[i] = project_point[i];
} else if ( project_point[i] > range_max[i] ) {
range_max[i] = project_point[i];
}
}
} }
void Projector::finish_range() { #pragma mark -
// double max_dist = 0.0; #pragma mark plot
// for ( unsigned int i = 0; i < intern_dim; i++ ) {
// const double dist = range_max[i] - range_min[i];
// if ( dist > max_dist )
// max_dist = dist;
// }
//
// factor = 0.9/max_dist;
// for ( unsigned int i = 0; i < intern_dim; i++ ) {
// offset[i] = -0.5*factor*(range_min[i] + range_max[i]);
// }
factor = canvas->size[0] / (range_max[0] - range_min[0]); void Projector::plot(const double* point) {
unsigned int teh_size = canvas->size[0]; project(point);
for ( unsigned int i = 1; i < intern_dim; i++ ) {
double dist = range_max[i] - range_min[i];
if ( factor * dist > (double)canvas->size[i] ) {
factor = (double)canvas->size[i] / dist;
//teh_size = canvas->size[i];
std::cout << "crap for dim" << i << std::endl;
}
}
factor /= (double)teh_size; if(ready) {
if(canvas != NULL) {
canvas->plot(projectedPoint);
}
for ( unsigned int i = 0; i < intern_dim; i++ ) { if(projector != NULL) {
offset[i] = -0.5*factor*(range_min[i] + range_max[i]); projector->plot(projectedPoint);
} }
}
} }
#pragma mark -
#pragma mark factory function
void Projector::project(const double * point) { #include "projectors/Normalizer.hpp"
assert(extern_dim >= 2);
project_point[0] = point[0]; Projector* Projector::createProjector(stfu::node const& projector, stfu::node const& system) {
project_point[1] = point[1]; Projector* output = new Normalizer(3);
}
return new Normalizer(3);
void Projector::plot(const double * point) {
project(point);
const double x = project_point[0]*factor + offset[0];
const double y = project_point[1]*factor + offset[1];
//cout << x << ", " << y << endl;
canvas->plot(x, y);
if ( even(point[2]*17) )
canvas->plot(x, y, 1);
if ( even(point[2]*17+0.6) )
canvas->plot(x, y, 2);
}
void Projector::output(){
std::cout << "Projector properties: " << std::endl;
std::cout << " factor: " << factor << std::endl;
for ( unsigned int i = 0; i < intern_dim; i++ ) {
std::cout << " dimension " << i << ": offset: " << offset[i] << ", range: [" << range_min[i] << ", " << range_max[i] << "]" << std::endl;
}
} }

47
Projector.hpp
View file

@ -1,40 +1,37 @@
#ifndef PROJECTOR_HPP #ifndef PROJECTOR_HPP
#define PROJECTOR_HPP #define PROJECTOR_HPP
#include "stfu/stf.hpp"
class Canvas; class Canvas;
class Projector{ class Projector {
public: private:
void allocate();
void deallocate();
unsigned int extern_dim; protected:
unsigned int intern_dim; Canvas* canvas;
Projector* projector;
Canvas * canvas; double* projectedPoint;
double * project_point;
double * range_min; unsigned int inputDimension;
double * range_max; unsigned int outputDimension;
double factor;
double * offset;
void init(const double * point); bool ready;
void init_vector();
void init_range();
void update_range(const double * point);
void finish_range();
virtual void project(const double* point) = 0;
// TODO : Matrix gebruiken voor lineaire afbeelding public:
// TODO : Over kleuren nadenken Projector(unsigned int inputDimension, unsigned int outputDimension);
/* virtual ~Projector();
Kleurmodi:
-genormalizeerde coordinaten als kleurintensiteit (gebruikt fp canvas)
-kleurbanden, dus met een periodieke functie (gebruikt int canvas)
*/
void project(const double * point);
void plot(const double * point);
void output(); // delegates forward trough the chain, know wha i'm sayin'?
void plot(const double* point);
// factory function
static Projector* createProjector(stfu::node const& projector, stfu::node const& system);
}; };
#endif // PROJECTOR_HPP #endif // PROJECTOR_HPP

126
Vector.cpp
View file

@ -1,126 +0,0 @@
#include <iostream>
using namespace std;
#include "Vector.hpp"
Vector::Vector():
dimension(0) {
coordinates = new (nothrow) float[0];
assert(coordinates != NULL);
#ifdef HARDDEBUG
cout << "New vector (without elements)" << endl;
#endif
}
Vector::Vector(unsigned int d):
dimension(d) {
coordinates = new (nothrow) float[dimension];
assert(coordinates != NULL);
#ifdef HARDDEBUG
cout << "New vector:" << endl << *this << endl;
#endif
}
Vector::Vector(unsigned int d, float default_val):
dimension(d) {
coordinates = new (nothrow) float[dimension];
assert(coordinates != NULL);
for (unsigned int i = 0; i < dimension; i++) {
coordinates[i] = default_val;
}
#ifdef HARDDEBUG
cout << "New vector with default values:" << endl << *this << endl;
#endif
}
Vector::~Vector() {
delete[] coordinates;
#ifdef HARDDEBUG
cout << "coordinates deleted" << endl;
#endif
}
Vector& Vector::operator=(const Vector& a) {
if ( dimension != a.dimension ) {
dimension = a.dimension;
delete[] coordinates;
coordinates = new float[dimension];
#ifdef HARDDEBUG
cout << "Dimensions were not equal, made new vector" << endl;
#endif
}
for ( unsigned int i = 0; i < dimension; i++ ) {
coordinates[i] = a.coordinates[i];
}
#ifdef HARDDEBUG
cout << "operator= result" << endl << *this << endl;
#endif
return *this;
}
ostream& operator<<(ostream& os, const Vector& a) {
os << a.dimension << endl;
for ( unsigned int i = 0; i < a.dimension; i++ ) {
os << a.coordinates[i] << " ";
}
os << endl;
return os;
}
float& Vector::operator[](const unsigned int index) {
assert(index < dimension);
return coordinates[index];
}
// matig werkende optelling en scalaire vermenigvuldiging van vectoren
/*
Vector Vector::operator+(const Vector a) const {
if ( dimension != a.dimension ) {
cout << "WARNING: dimensions not equal in vector addition" << endl;
exit(1);
} else {
static Vector ret(dimension);
for ( unsigned int i = 0; i < dimension; i++ ) {
ret.coordinates[i] = coordinates[i] + a.coordinates[i];
}
#ifdef HARDDEBUG
cout << "operator+ result" << endl << ret << endl;
#endif
return ret;
}
}
Vector Vector::operator*(const float a) const {
static Vector ret(dimension);
for ( unsigned int i = 0; i < dimension; i++ ) {
ret.coordinates[i] = coordinates[i] * a;
}
#ifdef HARDDEBUG
cout << "operator* result" << endl << ret << endl;
#endif
return ret;
}
*/

31
Vector.hpp
View file

@ -1,31 +0,0 @@
#ifndef VECTOR_HPP
#define VECTOR_HPP
class Vector {
public:
unsigned int dimension;
float * coordinates;
// const, dest
Vector();
Vector(unsigned int d);
Vector(unsigned int d, float default_val);
~Vector();
// output operator
friend ostream& operator<<(ostream& os, const Vector& a);
// easy access
float& Vector::operator[](const unsigned int index);
// vector rekenen
Vector& operator=(const Vector& a);
// faaloperatoren
// Vector operator+(const Vector a) const;
// Vector operator*(const float a) const;
};
#endif // VECTOR_HPP

168
attractors/testAttractor.stf
View file

@ -2,104 +2,104 @@
input: "attractor" input: "attractor"
output: "png" output: "png"
attractor: { AttractorKernel: {
type: lorenz/unravel/polynomial/polynomial a/logistic type: lorenz/unravel/polynomial/polynomial a/logistic
=> "polynomial" => "polynomial"
dimensions: most types only support 3D dimensions: most types only support 3D
=> "3" => "3"
orde: "2" orde: "2"
iterations: "1000000" iterations: "1000000"
parameters: the variables of the attractortype parameters: the variables of the attractortype
{ {
:"0.148" :"0.148"
:"0" :"0"
:"0" :"0"
:"0" :"0"
:"0" :"0"
:"0" :"0"
:"0.119" :"0.119"
:"0.424" :"0.424"
:"1.100" :"1.100"
:"0" :"0"
:"0.125" :"0.125"
:"0.199" :"0.199"
:"0" :"0"
:"0" :"0"
:"0" :"0"
:"0" :"0"
:"-0.643" :"-0.643"
:"0" :"0"
:"0" :"0"
:"0" :"0"
:"-1.120" :"-1.120"
:"-1.188" :"-1.188"
:"0" :"0"
:"0" :"0"
:"0" :"0"
:"-0.864" :"-0.864"
:"0" :"0"
:"0" :"0"
:"0" :"0"
:"0" :"0"
:"0" :"0"
} }
} }
projector: { projector: {
type: auto center/lineair map/spherical/color projector type: auto center/lineair map/spherical/color projector
=> "lineair map" => "lineair map"
domain: input of the projector, normally the attractor, but can also be a projector domain: input of the projector, normally the attractor, but can also be a projector
=> "attractor" => "attractor"
domainDimension: redundant, because it knows from domain domainDimension: redundant, because it knows from domain
=> "3" => "3"
codomain: output of the Projector, normally a canvas, but can also be another projector codomain: output of the Projector, normally a canvas, but can also be another projector
=> "canvas" => "canvas"
codomainDimensions: redundant, because it knows from codomain codomainDimensions: redundant, because it knows from codomain
=> "2" => "2"
matrix: describing the lineair map matrix: describing the lineair map
{ {
:{ :"1" :"0" :"0" } :{ :"1" :"0" :"0" }
:{ :"0" :"1" :"0" } :{ :"0" :"1" :"0" }
} }
} }
canvas: { canvas: {
type: 2D image/2D slices/3D volume/2D animation type: 2D image/2D slices/3D volume/2D animation
=> "2D image" => "2D image"
output: canvas/png/jpg/zip/mpg output: canvas/png/jpg/zip/mpg
=> "png" => "png"
width: "6400" width: "6400"
height: "6400" height: "6400"
colors: "3" colors: "3"
imageConversion: description how to show the abstract canvas classe imageConversion: description how to show the abstract canvas classe
{ {
colorMatrix: desciribing lineair map from canvas colors to RGB colorspace colorMatrix: desciribing lineair map from canvas colors to RGB colorspace
{ {
:{ :"1" :"0" :"0" } :{ :"1" :"0" :"0" }
:{ :"0" :"1" :"0" } :{ :"0" :"1" :"0" }
:{ :"0" :"0" :"1" } :{ :"0" :"0" :"1" }
} }
vibrancy: "0" vibrancy: "0"
gamma: "-2.5" gamma: "-2.5"
brightness: "3" brightness: "3"
} }
pngFile: png options pngFile: png options
{ {
fileName: leave empty to autogenerate filename fileName: leave empty to autogenerate filename
=> "" => ""
compression: "9" compression: "9"
author: "Joshua Moerman" author: "Joshua Moerman"
title: "Unravel" title: "Unravel"
description: "A unravel-type attractor made with AwesomeAttractor" description: "A unravel-type attractor made with AwesomeAttractor"
} }
} }

112
attractors/testLorenz.stf
View file

@ -2,76 +2,76 @@
input: "attractor" input: "attractor"
output: "png" output: "png"
attractor: { AttractorKernel: {
type: lorenz/unravel/polynomial/polynomial a/logistic type: lorenz/unravel/polynomial/polynomial a/logistic
=> "Lorenz" => "lorenz"
dimensions: most types only support 3D dimensions: most types only support 3D
=> "3" => "3"
iterations: "1000000" iterations: "1000000"
parameters: the variables of the attractortype parameters: the variables of the attractortype
{ {
:"0.01" :"0.01"
:"4.002" :"4.002"
:"28" :"28"
:"0.3" :"0.3"
} }
} }
projector: { projector: {
type: auto center/lineair map/spherical/color projector type: auto center/lineair map/spherical/color projector
=> "lineair map" => "lineair map"
domain: input of the projector, normally the attractor, but can also be a projector domain: input of the projector, normally the attractor, but can also be a projector
=> "attractor" => "attractor"
domainDimension: redundant, because it knows from domain domainDimension: redundant, because it knows from domain
=> "3" => "3"
codomain: output of the Projector, normally a canvas, but can also be another projector codomain: output of the Projector, normally a canvas, but can also be another projector
=> "canvas" => "canvas"
codomainDimensions: redundant, because it knows from codomain codomainDimensions: redundant, because it knows from codomain
=> "2" => "2"
matrix: describing the lineair map matrix: describing the lineair map
{ {
:{ :"1" :"0" :"0" } :{ :"1" :"0" :"0" }
:{ :"0" :"1" :"0" } :{ :"0" :"1" :"0" }
} }
} }
canvas: { canvas: {
type: 2D image/2D slices/3D volume/2D animation type: 2D image/2D slices/3D volume/2D animation
=> "2D image" => "2D image"
output: canvas/png/jpg/zip/mpg output: canvas/png/jpg/zip/mpg
=> "png" => "png"
width: "6400" width: "6400"
height: "6400" height: "6400"
colors: "3" colors: "3"
imageConversion: description how to show the abstract canvas classe imageConversion: description how to show the abstract canvas classe
{ {
colorMatrix: desciribing lineair map from canvas colors to RGB colorspace colorMatrix: desciribing lineair map from canvas colors to RGB colorspace
{ {
:{ :"1" :"0" :"0" } :{ :"1" :"0" :"0" }
:{ :"0" :"1" :"0" } :{ :"0" :"1" :"0" }
:{ :"0" :"0" :"1" } :{ :"0" :"0" :"1" }
} }
vibrancy: "0" vibrancy: "0"
gamma: "-2.5" gamma: "-2.5"
brightness: "3" brightness: "3"
} }
pngFile: png options pngFile: png options
{ {
fileName: leave empty to autogenerate filename fileName: leave empty to autogenerate filename
=> "" => ""
compression: "9" compression: "9"
author: "Joshua Moerman" author: "Joshua Moerman"
title: "Unravel" title: "Unravel"
description: "A unravel-type attractor made with AwesomeAttractor" description: "A unravel-type attractor made with AwesomeAttractor"
} }
} }

166
attractors/testPolynomial.stf
View file

@ -2,103 +2,103 @@
input: "attractor" input: "attractor"
output: "png" output: "png"
attractor: { AttractorKernel: {
type: lorenz/unravel/polynomial/polynomial a/logistic type: lorenz/unravel/polynomial/polynomial a/logistic
=> "polynomial" => "polynomial"
dimensions: most types only support 3D dimensions: most types only support 3D
=> "3" => "3"
orde: "2" orde: "2"
iterations: "1000000" iterations: "1000000"
parameters: the variables of the attractortype parameters: the variables of the attractortype
{ {
:"0.862" :"0.862"
:"-1.147" :"-1.147"
:"0.01" :"0.01"
:"0.241" :"0.241"
:"-0.85" :"-0.85"
:"-0.174" :"-0.174"
:"1.193" :"1.193"
:"-0.572" :"-0.572"
:"0.772" :"0.772"
:"0.147" :"0.147"
:"-0.049" :"-0.049"
:"0.427" :"0.427"
:"-0.103" :"-0.103"
:"-0.402" :"-0.402"
:"1.13" :"1.13"
:"0.859" :"0.859"
:"-0.642" :"-0.642"
:"-0.649" :"-0.649"
:"-1.074" :"-1.074"
:"-0.636" :"-0.636"
:"-0.706" :"-0.706"
:"0.315" :"0.315"
:"-0.125" :"-0.125"
:"1.193" :"1.193"
:"0.533" :"0.533"
:"-0.091" :"-0.091"
:"0.778" :"0.778"
:"-1.199" :"-1.199"
:"-0.112" :"-0.112"
:"0.025" :"0.025"
} }
} }
projector: { projector: {
type: auto center/lineair map/spherical/color projector type: auto center/lineair map/spherical/color projector
=> "lineair map" => "lineair map"
domain: input of the projector, normally the attractor, but can also be a projector domain: input of the projector, normally the attractor, but can also be a projector
=> "attractor" => "attractor"
domainDimension: redundant, because it knows from domain domainDimension: redundant, because it knows from domain
=> "3" => "3"
codomain: output of the Projector, normally a canvas, but can also be another projector codomain: output of the Projector, normally a canvas, but can also be another projector
=> "canvas" => "canvas"
codomainDimensions: redundant, because it knows from codomain codomainDimensions: redundant, because it knows from codomain
=> "2" => "2"
matrix: describing the lineair map matrix: describing the lineair map
{ {
:{ :"1" :"0" :"0" } :{ :"1" :"0" :"0" }
:{ :"0" :"1" :"0" } :{ :"0" :"1" :"0" }
} }
} }
canvas: { canvas: {
type: 2D image/2D slices/3D volume/2D animation type: 2D image/2D slices/3D volume/2D animation
=> "2D image" => "2D image"
output: canvas/png/jpg/zip/mpg output: canvas/png/jpg/zip/mpg
=> "png" => "png"
width: "6400" width: "6400"
height: "6400" height: "6400"
colors: "3" colors: "3"
imageConversion: description how to show the abstract canvas classe imageConversion: description how to show the abstract canvas classe
{ {
colorMatrix: desciribing lineair map from canvas colors to RGB colorspace colorMatrix: desciribing lineair map from canvas colors to RGB colorspace
{ {
:{ :"1" :"0" :"0" } :{ :"1" :"0" :"0" }
:{ :"0" :"1" :"0" } :{ :"0" :"1" :"0" }
:{ :"0" :"0" :"1" } :{ :"0" :"0" :"1" }
} }
vibrancy: "0" vibrancy: "0"
gamma: "-2.5" gamma: "-2.5"
brightness: "3" brightness: "3"
} }
pngFile: png options pngFile: png options
{ {
fileName: leave empty to autogenerate filename fileName: leave empty to autogenerate filename
=> "" => ""
compression: "9" compression: "9"
author: "Joshua Moerman" author: "Joshua Moerman"
title: "Unravel" title: "Unravel"
description: "A unravel-type attractor made with AwesomeAttractor" description: "A unravel-type attractor made with AwesomeAttractor"
} }
} }

118
attractors/testUnravel.stf
View file

@ -2,79 +2,79 @@
input: "attractor" input: "attractor"
output: "png" output: "png"
attractor: { AttractorKernel: {
type: lorenz/unravel/polynomial/polynomial a/logistic type: lorenz/unravel/polynomial/polynomial a/logistic
=> "unravel" => "unravel"
dimensions: most types only support 3D dimensions: most types only support 3D
=> "3" => "3"
iterations: "1000000" iterations: "1000000"
parameters: the variables of the attractortype parameters: the variables of the attractortype
{ {
:"-0.78" :"-0.78"
:"2.042" :"2.042"
:"1.22" :"1.22"
:"-1.267" :"-1.267"
:"1.37" :"1.37"
:"2.3" :"2.3"
:"-2.195" :"-2.195"
} }
} }
projector: { projector: {
type: auto center/lineair map/spherical/color projector type: auto center/lineair map/spherical/color projector
=> "lineair map" => "lineair map"
domain: input of the projector, normally the attractor, but can also be a projector domain: input of the projector, normally the attractor, but can also be a projector
=> "attractor" => "attractor"
domainDimension: redundant, because it knows from domain domainDimension: redundant, because it knows from domain
=> "3" => "3"
codomain: output of the Projector, normally a canvas, but can also be another projector codomain: output of the Projector, normally a canvas, but can also be another projector
=> "canvas" => "canvas"
codomainDimensions: redundant, because it knows from codomain codomainDimensions: redundant, because it knows from codomain
=> "2" => "2"
matrix: describing the lineair map matrix: describing the lineair map
{ {
:{ :"1" :"0" :"0" } :{ :"1" :"0" :"0" }
:{ :"0" :"1" :"0" } :{ :"0" :"1" :"0" }
} }
} }
canvas: { canvas: {
type: 2D image/2D slices/3D volume/2D animation type: 2D image/2D slices/3D volume/2D animation
=> "2D image" => "2D image"
output: canvas/png/jpg/zip/mpg output: canvas/png/jpg/zip/mpg
=> "png" => "png"
width: "6400" width: "6400"
height: "6400" height: "6400"
colors: "3" colors: "3"
imageConversion: description how to show the abstract canvas classe imageConversion: description how to show the abstract canvas classe
{ {
colorMatrix: desciribing lineair map from canvas colors to RGB colorspace colorMatrix: desciribing lineair map from canvas colors to RGB colorspace
{ {
:{ :"1" :"0" :"0" } :{ :"1" :"0" :"0" }
:{ :"0" :"1" :"0" } :{ :"0" :"1" :"0" }
:{ :"0" :"0" :"1" } :{ :"0" :"0" :"1" }
} }
vibrancy: "0" vibrancy: "0"
gamma: "-2.5" gamma: "-2.5"
brightness: "3" brightness: "3"
} }
pngFile: png options pngFile: png options
{ {
fileName: leave empty to autogenerate filename fileName: leave empty to autogenerate filename
=> "" => ""
compression: "9" compression: "9"
author: "Joshua Moerman" author: "Joshua Moerman"
title: "Unravel" title: "Unravel"
description: "A unravel-type attractor made with AwesomeAttractor" description: "A unravel-type attractor made with AwesomeAttractor"
} }
} }

104
attractors/testUnravelNew.stf
View file

@ -1,69 +1,71 @@
input: "AttractorKernel" Projector: "FirstProjector"
output: "Canvas"
iterations: "100000" iterations: "100000"
AttractorKernel: { AttractorKernel: {
type: "unravel" type: "unravel"
dimensions: "3" dimensions: "3"
parameters: parameters:
{ {
:"-0.78" :"-0.78"
:"2.042" :"2.042"
:"1.22" :"1.22"
:"-1.267" :"-1.267"
:"1.37" :"1.37"
:"2.3" :"2.3"
:"-2.195" :"-2.195"
} }
} }
projections: Applied in order they appear { FirstProjector: {
:{ type: "auto center"
type: "auto center"
}
:{
type: "lineair map"
matrix: Projector: "SecondProjector"
{ }
:{ :"1" :"0" :"0" }
:{ :"0" :"1" :"0" } SecondProjector {
} type: "lineair map"
matrix:
{
:{ :"1" :"0" :"0" }
:{ :"0" :"1" :"0" }
} }
Canvas: "Canvas"
} }
Canvas: { Canvas: {
type: "2D canvas" type: "2D canvas"
output: "png" output: "png"
width: "6400" width: "6400"
height: "6400" height: "6400"
colors: "3" colors: "3"
imageConversion: description how to show the abstract canvas classe imageConversion: description how to show the abstract canvas classe
{ {
colorMatrix: desciribing lineair map from canvas colors to RGB colorspace colorMatrix: desciribing lineair map from canvas colors to RGB colorspace
{ {
:{ :"1" :"0" :"0" } :{ :"1" :"0" :"0" }
:{ :"0" :"1" :"0" } :{ :"0" :"1" :"0" }
:{ :"0" :"0" :"1" } :{ :"0" :"0" :"1" }
} }
vibrancy: "0" vibrancy: "0"
gamma: "-2.5" gamma: "-2.5"
exposure: "3" exposure: "3"
} }
pngFile: png options pngFile: png options
{ {
fileName: leave empty to autogenerate filename fileName: leave empty to autogenerate filename
=> "" => ""
compression: "9" compression: "9"
author: "Joshua Moerman" author: "Joshua Moerman"
title: "Unravel" title: "Unravel"
description: "A unravel-type attractor made with AwesomeAttractor" description: "A unravel-type attractor made with AwesomeAttractor"
} }
} }

137
canvae/PNG.cpp Normal file
View file

@ -0,0 +1,137 @@
#include "../Logger.hpp"
#include <fstream>
#include <cmath>
#include <cstdlib>
#include <cassert>
#include "../pngwriter/pngwriter.h"
#include "PNG.hpp"
PNG::PNG(unsigned int width, unsigned int height, unsigned int num_colors):
Canvas(2), width(width), height(height), num_colors(num_colors), v(0) {
int_array = new unsigned int[width*height*num_colors];
assert(int_array != NULL);
clear();
LogDebug("New Canvas\n");
}
void PNG::clear() {
for ( unsigned int i = 0; i < width*height*num_colors; i++ ) {
int_array[i] = 0;
}
}
void PNG::plot(double * position) {
const double& x = position[0];
const double& y = position[1];
const unsigned int x_int = x*width + width*.5;
const unsigned int y_int = y*width + height*.5;
const unsigned int index = x_int + width * y_int;
if(x_int < width && y_int < height) {
int_array[index]++;
}
}
/*
I/O functions
*/
void PNG::output_file(const char * filename){
unsigned int * max_int = new unsigned int[num_colors];
double * power = new double[num_colors];
for ( unsigned int i = 0; i < num_colors; i++ ) {
max_int[i] = 0;
double cumulative = 0;
unsigned int n = 0;
for ( unsigned int j = 0; j < width*height; j++) {
if ( max_int[i] < int_array[j+i*width*height] ) {
max_int[i] = int_array[j+i*width*height];
}
if ( int_array[j+i*width*height] ) {
cumulative += int_array[j+i*width*height];
n++;
}
}
if ( n > 100 ) {
const double average = cumulative / (double)n;
power[i] = -2.5/log(average/(double)max_int[i]);
if ( power[i] < 0 )
power[i] = 1;
} else {
power[i] = 1;
}
if ( n <= 10 ) {
LogInfo("not enough data\n");
}
}
const double vibrancy = 2.0;
double averagePower = 0;
for ( unsigned int i = 0; i < num_colors; i++ ) {
averagePower += power[i];
}
averagePower /= (double)num_colors;
for ( unsigned int i = 0; i < num_colors; i++ ) {
power[i] = vibrancy*power[i] + (1.0 - vibrancy)*averagePower;
}
pngwriter * pngFile = new pngwriter(width, height, 0.0, filename);
pngFile->setcompressionlevel(9);
pngFile->settext("Attractor", "Joshua Moerman", "A awesome attractor", "AwesomeAttractor");
for ( unsigned int x = 0; x < width; x++ ) {
for ( unsigned int y = 0; y < height; y++ ) {
double r = 0.0;
double g = 0.0;
double b = 0.0;
for ( unsigned int c = 0; c < num_colors; c++ ) {
const double norm_value = (double)int_array[x + y*width + c*width*height]/max_int[c];
switch(c){
case 0: {
r = (pow(norm_value, power[c]))*3.5;
break;
}
case 1: {
g = (pow(norm_value, power[c]))*3.0;
break;
}
case 2: {
b = (pow(norm_value, power[c]))*3.0;
break;
}
default:
break;
}
}
//pngwriter clips values for me
pngFile->plot(x, y, r, g, b);
}
}
delete[] max_int;
delete[] power;
LogInfo("Writing %s\n", filename);
std::ofstream file(filename);
if ( !file ) {
LogError("Couldn't write to file");
}
pngFile->close();
LogMoreInfo("File written");
}

27
canvae/PNG.hpp Normal file
View file

@ -0,0 +1,27 @@
#ifndef PNG_HPP
#define PNG_HPP
#include "../Canvas.hpp"
class PNG : public Canvas {
unsigned int width;
unsigned int height;
unsigned int num_colors;
unsigned int * int_array;
public:
double v;
PNG (unsigned int width, unsigned int height, unsigned int num_colors = 1);
virtual void clear();
virtual void plot (const double * normalizedPosition);
virtual void output_file (const char * filename) const;
};
#endif // PNG_HPP

61
canvae/Raw.cpp Normal file
View file

@ -0,0 +1,61 @@
#include "../Logger.hpp"
#include <fstream>
#include <cmath>
#include <cstdlib>
#include <cassert>
#include <algorithm>
#include <numeric>
#include <functional>
#include "Raw.hpp"
Raw::Raw (const unsigned int dimension, const unsigned int* sizes_):
Canvas(dimension) {
sizes = new unsigned int[dimension];
assert(sizes != NULL);
std::copy(sizes_, sizes_ + dimension, sizes);
sizesMultiplied = new unsigned int[dimension];
assert(sizesMultiplied != NULL);
sizesMultiplied[0] = 1;
for ( unsigned int i = 1; i < dimension; ++i ) {
sizesMultiplied[i] = sizesMultiplied[i-1]*sizes[i-1];
}
arraySize = 1;
for ( unsigned int i = 0; i < dimension; ++i ) {
arraySize *= sizes[i];
}
pixelArray = new unsigned int[arraySize];
assert(pixelArray != NULL);
clear();
LogDebug("New RawCanvas of dimension %d\n", dimension);
}
void Raw::clear() {
std::fill_n(pixelArray, arraySize, 0);
}
void Raw::plot(const double * position) {
unsigned int index = 0;
for ( unsigned int i = 0; i < dimension; ++i ) {
index += (unsigned int)(position[i]*sizes[i] + 0.5*sizes[i])*sizesMultiplied[i];
}
if(index < arraySize) {
pixelArray[index]++;
}
}
/*
I/O functions
*/
void Raw::output_file(const char * filename) const{
std::ofstream outfile (filename, std::ofstream::binary);
outfile.write(reinterpret_cast<char*>(pixelArray), sizeof(unsigned int)*arraySize);
}

24
canvae/Raw.hpp Normal file
View file

@ -0,0 +1,24 @@
#ifndef RAW_HPP
#define RAW_HPP
#include "../Canvas.hpp"
class Raw : public Canvas {
unsigned int * sizes;
unsigned int * sizesMultiplied;
unsigned int * pixelArray;
unsigned int arraySize;
public:
Raw (const unsigned int dimension, const unsigned int* sizes);
virtual void clear();
virtual void plot (const double * normalizedPosition);
virtual void output_file (const char * filename) const;
};
#endif // RAW_HPP

12
cleanCode.sh Normal file
View file

@ -0,0 +1,12 @@
DIRS="./*.cpp ./*.hpp ./kernels/*.cpp ./kernels/*.hpp ./attractors/*.stf"
echo "This program will delete all trailing whitespaces and will replace spaces with tabs"
for file in ${DIRS}
do
echo "yay ${file}"
unexpand -t 4 ${file} | sed 's/[ \t]*$//' > ${file}.new
cat ${file}.new > ${file}
rm ${file}.new
done

18
defines.hpp
View file

@ -1,15 +1,13 @@
#define DEFAULT_ATTRACTOR_FILE "attractors/testUnravel.stf"
//TODO: do this with files
#define ATTRACTOR_FILE "attractors/testUnravel.stf"
#ifdef UNI_BUILD #ifdef UNI_BUILD
#warning Building for the RU, are you sure? #warning Building for the RU, are you sure?
#define WIDTH 8000 #define DEFAULT_WIDTH 8000
#define HEIGHT 8000 #define DEFAULT_HEIGHT 8000
#define ITERATIONS 4200000000 #define DEFAULT_ITERATIONS 4200000000
#else #else
#define WIDTH 800 #define DEFAULT_WIDTH 800
#define HEIGHT 800 #define DEFAULT_HEIGHT 800
#define ITERATIONS 1000000 #define DEFAULT_ITERATIONS 1000000
#endif #endif

18
kernels/Logistic.cpp
View file

@ -1,9 +1,9 @@
// //
// $filename // $filename
// $projectname // $projectname
// //
// Created by Joshua moerman on $TODAY. // Created by Joshua moerman on $TODAY.
// Copyright 2010 Joshua Moerman. All rights reserved. // Copyright 2010 Joshua Moerman. All rights reserved.
// //
#include "Logistic.hpp" #include "Logistic.hpp"
@ -15,12 +15,12 @@
Logistic::Logistic(): Logistic::Logistic():
AttractorKernel(3, 3) { AttractorKernel(3, 3) {
init(); init();
} }
Logistic::Logistic(const unsigned int dimension): Logistic::Logistic(const unsigned int dimension):
AttractorKernel(dimension, dimension) { AttractorKernel(dimension, dimension) {
init(); init();
} }
void Logistic::init() { void Logistic::init() {
@ -36,8 +36,8 @@ void Logistic::init() {
void Logistic::operator()() { void Logistic::operator()() {
std::swap(vectorNew, vectorOld); std::swap(vectorNew, vectorOld);
for ( unsigned int i = 0; i < dimension; i++ ) { for ( unsigned int i = 0; i < dimension; i++ ) {
vectorNew[i] = parameters[i]*vectorOld[i]*(1.0 - vectorOld[i]); vectorNew[i] = parameters[i]*vectorOld[i]*(1.0 - vectorOld[i]);
} }
} }

4
kernels/Logistic.hpp
View file

@ -10,8 +10,8 @@ private:
public: public:
Logistic(); Logistic();
Logistic(const unsigned int dimension); Logistic(const unsigned int dimension);
virtual void operator()(); virtual void operator()();

18
kernels/Lorenz3D.cpp
View file

@ -7,7 +7,7 @@
Lorenz3D::Lorenz3D(): Lorenz3D::Lorenz3D():
AttractorKernel(3, 4){ AttractorKernel(3, 4){
init(); init();
} }
void Lorenz3D::init() { void Lorenz3D::init() {
@ -23,17 +23,17 @@ void Lorenz3D::init() {
void Lorenz3D::operator()() { void Lorenz3D::operator()() {
std::swap(vectorNew, vectorOld); std::swap(vectorNew, vectorOld);
vectorNew[0] = vectorOld[0] + parameters[0] * parameters[1] * (vectorOld[1] - vectorOld[0]); vectorNew[0] = vectorOld[0] + parameters[0] * parameters[1] * (vectorOld[1] - vectorOld[0]);
vectorNew[1] = vectorOld[1] + parameters[0] * (vectorOld[0] * (parameters[2] - vectorOld[2]) - vectorOld[1]); vectorNew[1] = vectorOld[1] + parameters[0] * (vectorOld[0] * (parameters[2] - vectorOld[2]) - vectorOld[1]);
vectorNew[2] = vectorOld[2] + parameters[0] * (vectorOld[0] * vectorOld[1] - parameters[3] * vectorOld[2]); vectorNew[2] = vectorOld[2] + parameters[0] * (vectorOld[0] * vectorOld[1] - parameters[3] * vectorOld[2]);
} }
/* /*
4D: 4D:
new_point[0] = point[0] + param[0] * param[1] * (point[1] - point[0]); new_point[0] = point[0] + param[0] * param[1] * (point[1] - point[0]);
new_point[1] = point[1] + param[0] * (point[0] * (param[2] - point[2]) - point[1] + point[3]); new_point[1] = point[1] + param[0] * (point[0] * (param[2] - point[2]) - point[1] + point[3]);
new_point[2] = point[2] + param[0] * (point[0] * point[1] - param[3] * point[2]); new_point[2] = point[2] + param[0] * (point[0] * point[1] - param[3] * point[2]);
new_point[3] = point[3] - param[0] * param[4] * point[0]; new_point[3] = point[3] - param[0] * param[4] * point[0];
break; break;
*/ */

6
kernels/Lorenz3D.hpp
View file

@ -6,13 +6,13 @@
class Lorenz3D : public AttractorKernel { class Lorenz3D : public AttractorKernel {
private: private:
void init(); void init();
public: public:
Lorenz3D(); Lorenz3D();
virtual void operator()(); virtual void operator()();
}; };

50
kernels/Polynomial.cpp
View file

@ -1,9 +1,9 @@
// //
// $filename // $filename
// $projectname // $projectname
// //
// Created by Joshua moerman on $TODAY. // Created by Joshua moerman on $TODAY.
// Copyright 2010 Joshua Moerman. All rights reserved. // Copyright 2010 Joshua Moerman. All rights reserved.
// //
#include "Polynomial.hpp" #include "Polynomial.hpp"
@ -11,13 +11,13 @@
unsigned int calculateNumberOfParameters(const unsigned int dimension, const unsigned int orde) { unsigned int calculateNumberOfParameters(const unsigned int dimension, const unsigned int orde) {
double n_coef = orde + 1; double n_coef = orde + 1;
for (unsigned int i = 2; i <= dimension; i++) { for (unsigned int i = 2; i <= dimension; i++) {
n_coef = n_coef*(orde + i)/(i - 1); n_coef = n_coef*(orde + i)/(i - 1);
} }
const unsigned int output = (unsigned int) n_coef; const unsigned int output = (unsigned int) n_coef;
return output; return output;
} }
@ -37,26 +37,26 @@ Polynomial::Polynomial(const unsigned int dimension, const unsigned int orde):
void Polynomial::operator()() { void Polynomial::operator()() {
std::swap(vectorNew, vectorOld); std::swap(vectorNew, vectorOld);
unsigned int m = 0; unsigned int m = 0;
for ( unsigned int i = 0; i < dimension; i++ ) { for ( unsigned int i = 0; i < dimension; i++ ) {
vectorNew[i] = parameters[m]; vectorNew[i] = parameters[m];
m++; m++;
recur(i, 0, 1, m); recur(i, 0, 1, m);
} }
} }
void Polynomial::recur(unsigned int curr_dimension, unsigned int prev_i, unsigned int n, unsigned int& m, double prev_product) { void Polynomial::recur(unsigned int curr_dimension, unsigned int prev_i, unsigned int n, unsigned int& m, double prev_product) {
double product; double product;
for (unsigned int i = prev_i; i < dimension; i++) { for (unsigned int i = prev_i; i < dimension; i++) {
product = prev_product * vectorOld[i]; product = prev_product * vectorOld[i];
vectorNew[curr_dimension] += parameters[m] * product; vectorNew[curr_dimension] += parameters[m] * product;
m++; m++;
if (n < orde) { if (n < orde) {
recur(curr_dimension, i, n+1, m, product); recur(curr_dimension, i, n+1, m, product);
} }
} }
} }

10
kernels/Polynomial.hpp
View file

@ -6,16 +6,16 @@
class Polynomial : public AttractorKernel { class Polynomial : public AttractorKernel {
private: private:
unsigned int orde; unsigned int orde;
void recur(unsigned int curr_dimension, unsigned int prev_i, unsigned int n, unsigned int& m, double prev_product=1.0); void recur(unsigned int curr_dimension, unsigned int prev_i, unsigned int n, unsigned int& m, double prev_product=1.0);
public: public:
Polynomial(); Polynomial();
Polynomial(const unsigned int dimensions, const unsigned int orde); Polynomial(const unsigned int dimensions, const unsigned int orde);
virtual void operator()(); virtual void operator()();
}; };

20
kernels/PolynomialA3D.cpp
View file

@ -1,9 +1,9 @@
// //
// $filename // $filename
// $projectname // $projectname
// //
// Created by Joshua moerman on $TODAY. // Created by Joshua moerman on $TODAY.
// Copyright 2010 Joshua Moerman. All rights reserved. // Copyright 2010 Joshua Moerman. All rights reserved.
// //
#include "PolynomialA3D.hpp" #include "PolynomialA3D.hpp"
@ -23,14 +23,14 @@ PolynomialA3D::PolynomialA3D():
void PolynomialA3D::operator()() { void PolynomialA3D::operator()() {
std::swap(vectorNew, vectorOld); std::swap(vectorNew, vectorOld);
vectorNew[0] = parameters[0] + vectorOld[1] - vectorOld[1]*vectorOld[2]; vectorNew[0] = parameters[0] + vectorOld[1] - vectorOld[1]*vectorOld[2];
vectorNew[1] = parameters[1] + vectorOld[2] - vectorOld[2]*vectorOld[0]; vectorNew[1] = parameters[1] + vectorOld[2] - vectorOld[2]*vectorOld[0];
vectorNew[2] = parameters[2] + vectorOld[0] - vectorOld[0]*vectorOld[1]; vectorNew[2] = parameters[2] + vectorOld[0] - vectorOld[0]*vectorOld[1];
} }
/* /*
N dimensional: N dimensional:
for ( unsigned int i = 0; i < dim; i++ ) { for ( unsigned int i = 0; i < dim; i++ ) {
new_point[i] = param[i] + point[(i+1) % dim] - point[(i+1) % dim]*point[(i+2) % dim]; new_point[i] = param[i] + point[(i+1) % dim] - point[(i+1) % dim]*point[(i+2) % dim];
} }
*/ */

4
kernels/PolynomialA3D.hpp
View file

@ -8,9 +8,9 @@ private:
public: public:
PolynomialA3D(); PolynomialA3D();
virtual void operator()(); virtual void operator()();
}; };

22
kernels/Unravel3D.cpp
View file

@ -16,18 +16,18 @@ Unravel3D::Unravel3D():
void Unravel3D::operator()() { void Unravel3D::operator()() {
std::swap(vectorNew, vectorOld); std::swap(vectorNew, vectorOld);
vectorNew[0] = parameters[0]*(vectorOld[2] + parameters[1]); vectorNew[0] = parameters[0]*(vectorOld[2] + parameters[1]);
vectorNew[1] = parameters[2]*(vectorOld[0] + parameters[3]); vectorNew[1] = parameters[2]*(vectorOld[0] + parameters[3]);
vectorNew[2] = parameters[4]*(vectorOld[1] + parameters[5]); vectorNew[2] = parameters[4]*(vectorOld[1] + parameters[5]);
const double dist = vectorNew[0]*vectorNew[0] + vectorNew[1]*vectorNew[1] + vectorNew[2]*vectorNew[2]; const double dist = vectorNew[0]*vectorNew[0] + vectorNew[1]*vectorNew[1] + vectorNew[2]*vectorNew[2];
if ( dist > parameters[6]*parameters[6] ) { if ( dist > parameters[6]*parameters[6] ) {
const double sqrtDist = std::sqrt(dist); const double sqrtDist = std::sqrt(dist);
const double p = 1.0 - parameters[6] * ( static_cast<int> ( sqrtDist / parameters[6] ) + 1.0 ) / sqrtDist; const double p = 1.0 - parameters[6] * ( static_cast<int> ( sqrtDist / parameters[6] ) + 1.0 ) / sqrtDist;
vectorNew[0] *= p; vectorNew[0] *= p;
vectorNew[1] *= p; vectorNew[1] *= p;
vectorNew[2] *= p; vectorNew[2] *= p;
} }
} }

6
kernels/Unravel3D.hpp
View file

@ -6,10 +6,10 @@
class Unravel3D : public AttractorKernel { class Unravel3D : public AttractorKernel {
public: public:
Unravel3D(); Unravel3D();
Unravel3D(const unsigned int dimensions); Unravel3D(const unsigned int dimensions);
virtual void operator()(); virtual void operator()();
}; };

239
main.cpp
View file

@ -1,147 +1,118 @@
#include "Logger.hpp"
#include <iostream> #include <iostream>
#include <ctime> #include <ctime>
#include <valarray>
#include <cstring>
#include "Attractor.hpp" #include "Attractor.hpp"
#include "Canvas.hpp" #include "Canvas.hpp"
#include "Projector.hpp" #include "Projector.hpp"
#include "canvae/Raw.hpp"
#include "ostream_helpers.h"
#include "defines.hpp" #include "defines.hpp"
int main(int argc, char *argv[]) {
clock_t start, end; int verbose;
double totalTime, totalIterations;
// initialising stuff void showHelpText() {
Attractor myAttractor(ATTRACTOR_FILE); std::cout << "Awesome Attractor, version " << __DATE__ << std::endl;
std::cout << "Usage: AwesomeAttractor [OPTION]... FILE" << std::endl << std::endl;
Projector projection; std::cout << "Optons:" << std::endl;
Canvas canvas(WIDTH, HEIGHT, 3); std::cout << " --help Shows this help" << std::endl;
projection.canvas = &canvas; std::cout << " -q quiet mode" << std::endl;
std::cout << " -v verbose mode" << std::endl;
myAttractor.projectors.push_back(&projection); std::cout << " -V loud mode" << std::endl;
myAttractor.init_range(); std::cout << " -w N Sets width of output image to N" << std::endl;
std::cout << " -h N Sets height of output image to N" << std::endl;
projection.output(); std::cout << " -i N Sets number of iterations to N" << std::endl;
exit(0);
unsigned int iterations = ITERATIONS;
start = clock();
for ( unsigned int j = 1; j <= 100; j++ ) {
for ( unsigned int i = 0; i <= iterations; i++ ) {
myAttractor.iterate();
myAttractor.plot();
}
system("clear");
myAttractor.output();
std::cout << j << "% done" << std::endl;
}
end = clock();
totalIterations = 100.0*iterations;
totalTime = ((double)(end-start)/(double)(CLOCKS_PER_SEC));
printf("\ntotal clock time: %f\n", totalTime );
printf("average iterations per second: %f\n\n", totalIterations/((double)(end-start)/(double)(CLOCKS_PER_SEC)) );
// saving output
start = clock();
canvas.output_file();
end = clock();
totalTime = ((double)(end-start)/(double)(CLOCKS_PER_SEC));
printf("total clock time for writing png: %f\n", totalTime );
printf("\n Awesome Attractor, version %s\n", __DATE__);
/*if ( argc <= 2 ) {
cout << endl << "nothing to do..." << endl;
cout << "usage:" << endl;
cout << " rendering to canvas: -a my_attractor.attr 500000000 my_attractor.canv 800 600 3" << endl;
cout << " canvas to png: -c my_attractor.canv 800 600 3 my_atttractor.png" << endl << endl;
exit(0);
}
int mode;
string argv1 = argv[1];
if ( argv1 == "-a" ) {
cout << "rendermode" << endl;
mode = 1;
} else if ( argv1 == "-c" ) {
cout << "canvasmode" << endl;
mode = 2;
} else {
cout << "i do.. i do... i do not understand... \"" << argv1 << "\""<< endl;
exit(0);
}
switch ( mode ) {
case 1: {
if ( argc != 8 ) {
cout << "all parameters must be set..." << endl;
exit(0);
}
string attractorFile = argv[2];
unsigned int iterations = atoi(argv[3]);
string canvasFile = argv[4];
unsigned int width = atoi(argv[5]);
unsigned int height = atoi(argv[6]);
unsigned int numColors = atoi(argv[7]);
Attractor attract(attractorFile.c_str());
cout << attractorFile << " is read" << endl;
Projector projection;
Canvas canvas(width, height, numColors);
projection.canvas = &canvas;
attract.projectors.push_back(&projection);
attract.init_range();
projection.output();
for ( unsigned int j = 1; j <= 100; j++ ) {
for ( unsigned int i = 0; 100*i <= iterations; i++ ) {
attract.iterate();
attract.plot();
}
cout << j << "% done" << endl;
}
canvas.output_raw(canvasFile.c_str());
cout << canvasFile << " is outputted" << endl;
break;
}
case 2: {
if ( argc != 7 ) {
cout << "all parameters must be set..." << endl;
exit(0);
}
string canvasFile = argv[2];
unsigned int width = atoi(argv[3]);
unsigned int height = atoi(argv[4]);
unsigned int numColors = atoi(argv[5]);
string pngFile = argv[6];
Canvas canvas(width, height, numColors);
canvas.input_raw(canvasFile.c_str());
cout << canvasFile << " is read" << endl;
for ( double v = -1.5; v < 1.6; v += 1.5 ) {
canvas.v = v;
canvas.output_file();
}
cout << pngFile << " was exported" << endl;
break;
}
default: {
cout << "WTF" << endl;
break;
}
}*/
return 0;
} }
int main(int argc, char* argv[]) {
verbose = 0;
std::string attractorFile = DEFAULT_ATTRACTOR_FILE;
unsigned int iterations = DEFAULT_ITERATIONS;
unsigned int width = DEFAULT_WIDTH;
unsigned int height = DEFAULT_HEIGHT;
if(argc <= 1) {
showHelpText();
}
for(int i = 1; i < argc; ++i) {
if(strcmp(argv[i], "-v") == 0) {
verbose = 1;
} else if(strcmp(argv[i], "-q") == 0) {
verbose = -1;
} else if(strcmp(argv[i], "--help") == 0) {
showHelpText();
} else if(strcmp(argv[i], "-V") == 0) {
verbose = 3;
} else if(strcmp(argv[i], "-w") == 0) {
width = atoi(argv[++i]);
} else if(strcmp(argv[i], "-h") == 0) {
height = atoi(argv[++i]);
} else if(strcmp(argv[i], "-i") == 0) {
iterations = atoi(argv[++i]);
} else {
attractorFile = argv[i];
}
}
LogInfo("Awesome Attractor, version %s\n", __DATE__);
// initialising stuff
Attractor myAttractor(attractorFile);
/*unsigned int sizes[] = {128, 128, 128};
Canvas* canvas = new Raw(3, sizes);
projection.canvas = canvas;*/
myAttractor.init_range();
//projection.output();
LogInfo("\nRendering\n");
clock_t start, end;
start = clock();
for(unsigned int j = 1; j <= 100; ++j) {
for(unsigned int i = 0; i <= iterations; i++) {
myAttractor.iterate();
myAttractor.plot();
}
if(verbose >= 0) {
std::cout << "\r" << j << "% done" << std::flush;
}
}
end = clock();
double totalIterations = 100.0*iterations;
double totalTime = ((double)(end-start)/(double)(CLOCKS_PER_SEC));
LogInfo("\nTotal clock time: %f\n", totalTime);
LogMoreInfo("Average iterations per second: %f\n\n", totalIterations/totalTime);
// saving output
char filename[50];
time_t t = time(0);
struct tm* lt = localtime(&t);
int r = rand() % 10;
sprintf(filename, "render/attractor_%04d-%02d-%02d_%02d-%02d-%02d-%01d.raw", lt->tm_year + 1900, lt->tm_mon + 1, lt->tm_mday, lt->tm_hour, lt->tm_min, lt->tm_sec, r);
start = clock();
//canvas->output_file(filename);
end = clock();
totalTime = ((double)(end-start)/(double)(CLOCKS_PER_SEC));
LogInfo("Total clock time for writing png: %f\n", totalTime);
return 0;
}

2
myMath.hpp
View file

@ -4,7 +4,7 @@
#include <cmath> #include <cmath>
bool even(double x) { bool even(double x) {
return (((int)floor(x)) % 2 == 0); return (((int)floor(x)) % 2 == 0);
} }
#endif // MYMATH_HPP #endif // MYMATH_HPP

24
ostream_helpers.h Normal file
View file

@ -0,0 +1,24 @@
#ifndef OSTREAM_HELPERS_HPP
#define OSTREAM_HELPERS_HPP
#include <iterator>
#include <algorithm>
#include "AttractorKernel.hpp"
#include "Attractor.hpp"
std::ostream& operator<<(std::ostream& os, AttractorKernel const& x) {
const unsigned int dimension = x.getDimension();
const double * point = x.vector();
std::copy(point, point+dimension, std::ostream_iterator<double>(os, ", "));
return os;
}
std::ostream& operator<<(std::ostream& os, Attractor const& x) {
os << x.kernel << "\n";
os << x.projector << "\n";
return os;
}
#endif // OSTREAM_HELPERS_HPP

102
projectors/Normalizer.cpp Normal file
View file

@ -0,0 +1,102 @@
#include "../Logger.hpp"
#include "Normalizer.hpp"
#pragma mark -
#pragma mark memory
Normalizer::Normalizer(unsigned int dimension) : Projector(dimension, dimension), factor(1) {
ready = false;
try {
allocate();
} catch (std::exception& e) {
LogError("Couldn't construct Normalizer (Projector): %s\n", e.what());
deallocate();
}
std::fill_n(range_min, outputDimension, 0.0);
std::fill_n(range_max, outputDimension, 0.0);
std::fill_n(offset, outputDimension, 0.0);
}
Normalizer::~Normalizer() {
deallocate();
}
void Normalizer::allocate(){
range_min = new double[outputDimension];
range_max = new double[outputDimension];
offset = new double[outputDimension];
}
void Normalizer::deallocate(){
delete[] range_min;
range_min = 0;
delete[] range_max;
range_max = 0;
delete[] offset;
offset = 0;
}
#pragma mark -
#pragma mark plot
void Normalizer::project(const double * point) {
for ( unsigned int i = 0; i < inputDimension; ++i ) {
projectedPoint[0] = point[0]*factor + offset[0];
}
if(!ready){
static unsigned int state = 0;
switch(state) {
case 0:
init_range();
break;
case 500000:
finish_range();
ready = true;
break;
default:
update_range();
break;
}
++state;
}
}
#pragma mark -
#pragma mark setting up
void Normalizer::init_range() {
for ( unsigned int i = 0; i < outputDimension; i++ ) {
range_min[i] = range_max[i] = projectedPoint[i];
}
}
void Normalizer::update_range() {
for ( unsigned int i = 0; i < outputDimension; i++ ) {
if ( projectedPoint[i] < range_min[i] ) {
range_min[i] = projectedPoint[i];
} else if ( projectedPoint[i] > range_max[i] ) {
range_max[i] = projectedPoint[i];
}
}
}
void Normalizer::finish_range() {
factor = 2.0 / (range_max[0] - range_min[0]);
for ( unsigned int i = 1; i < outputDimension; i++ ) {
double dist = range_max[i] - range_min[i];
if ( factor * dist > 2.0 ) {
factor = 2.0 / dist;
//teh_size = canvas->size[i];
LogDebug("Crap for dimension %d\n", i);
}
}
for ( unsigned int i = 0; i < outputDimension; i++ ) {
offset[i] = -0.5*factor*(range_min[i] + range_max[i]);
}
}

29
projectors/Normalizer.hpp Normal file
View file

@ -0,0 +1,29 @@
#ifndef NORMALIZER_HPP
#define NORMALIZER_HPP
#include "../Projector.hpp"
class Normalizer : public Projector {
private:
double* range_min;
double* range_max;
double* offset;
double factor;
void allocate();
void deallocate();
void init_range();
void update_range();
void finish_range();
protected:
virtual void project(const double* point);
public:
Normalizer(unsigned int dimension);
virtual ~Normalizer();
};
#endif // NORMALIZER_HPP

10
projectors/Projection.cpp Normal file
View file

@ -0,0 +1,10 @@
#include "Projection.hpp"
Projection::Projection(unsigned int inputDimension, unsigned int outputDimension) : Projector(inputDimension, outputDimension){
}
void Projection::project(const double* point){
for ( unsigned int i = 0; i < inputDimension; ++i){
projectedPoint[i] = point[i];
}
}

16
projectors/Projection.hpp Normal file
View file

@ -0,0 +1,16 @@
#ifndef PROJECTION_HPP
#define PROJECTION_HPP
#include "../Projector.hpp"
class Projection : public Projector {
protected:
virtual void project(const double* point);
public:
Projection(unsigned int inputDimension, unsigned int outputDimension);
};
#endif // PROJECTION_HPP