Browse Source

replaced spaces with tabs

master
Joshua Moerman 14 years ago
parent
commit
49b3649891
  1. 118
      Attractor.cpp
  2. 14
      Attractor.hpp
  3. 100
      AttractorKernel.cpp
  4. 12
      AttractorKernel.hpp
  5. 340
      Canvas.cpp
  6. 46
      Canvas.hpp
  7. 102
      Parameters.cpp
  8. 30
      Parameters.hpp
  9. 120
      Projector.cpp
  10. 48
      Projector.hpp
  11. 106
      Vector.cpp
  12. 34
      Vector.hpp
  13. 166
      attractors/testAttractor.stf
  14. 110
      attractors/testLorenz.stf
  15. 164
      attractors/testPolynomial.stf
  16. 116
      attractors/testUnravel.stf
  17. 76
      attractors/testUnravelNew.stf
  18. 16
      defines.hpp
  19. 18
      kernels/Logistic.cpp
  20. 4
      kernels/Logistic.hpp
  21. 18
      kernels/Lorenz3D.cpp
  22. 6
      kernels/Lorenz3D.hpp
  23. 52
      kernels/Polynomial.cpp
  24. 10
      kernels/Polynomial.hpp
  25. 20
      kernels/PolynomialA3D.cpp
  26. 4
      kernels/PolynomialA3D.hpp
  27. 26
      kernels/Unravel3D.cpp
  28. 6
      kernels/Unravel3D.hpp
  29. 64
      main.cpp
  30. 2
      myMath.hpp

118
Attractor.cpp

@ -14,9 +14,9 @@ Attractor::Attractor(const char* const fileName) {
// opening file
std::cout << "Reading file " << fileName << "..." << std::endl;
stfu::node system;
system.read(fileName);
stfu::node attractor = system.getChild("AttractorKernel");
stfu::node system;
system.read(fileName);
stfu::node attractor = system.getChild("AttractorKernel");
myAttractor = AttractorKernel::createAttractorKernel(attractor);
}
@ -28,81 +28,81 @@ Attractor::~Attractor(){
// this should probably done in the projector section
void Attractor::init_range() {
// stabilize attractor
for ( unsigned int i = 0; i < 100000; i++ ) {
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();
}
// stabilize attractor
for ( unsigned int i = 0; i < 100000; i++ ) {
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() {
/*
check existence of attractor:
Escaping
Single point attractor
Lyapunov exponent
*/
/*
check existence of attractor:
Escaping
Single point attractor
Lyapunov exponent
*/
/*
double sum = 0;
for ( unsigned int i = 0; i < dim; i++ ) {
const double dist = 0; //new_point[i] - point[i];
sum += dist*dist;
}
if ( sum >= 1.0e7 ) {
// big change => Escaping
return false;
}
if ( sum <= 1.0e-7 ) {
// small change => singularity
return false;
}
return true;
double sum = 0;
for ( unsigned int i = 0; i < dim; i++ ) {
const double dist = 0; //new_point[i] - point[i];
sum += dist*dist;
}
if ( sum >= 1.0e7 ) {
// big change => Escaping
return false;
}
if ( sum <= 1.0e-7 ) {
// small change => singularity
return false;
}
return true;
*/
return true;
return true;
}
void Attractor::iterate() {
(*myAttractor)();
(*myAttractor)();
}
void Attractor::plot() {
for ( std::vector<Projector *>::iterator it = projectors.begin(); it != projectors.end(); it++ ) {
const double * point = myAttractor->vector();
(*it)->plot(point);
}
for ( std::vector<Projector *>::iterator it = projectors.begin(); it != projectors.end(); it++ ) {
const double * point = myAttractor->vector();
(*it)->plot(point);
}
}
/*
IO & control
IO & control
*/
void Attractor::output() {
const unsigned int dimension = myAttractor->getDimension();
const double * point = myAttractor->vector();
const unsigned int dimension = myAttractor->getDimension();
const double * point = myAttractor->vector();
for ( unsigned int i = 0; i < dimension; i++ ) {
for ( unsigned int i = 0; i < dimension; i++ ) {
std::cout << point[i] << " ";
}
}
std::cout << std::endl;
}

14
Attractor.hpp

@ -9,22 +9,22 @@ class AttractorKernel;
class Attractor {
private:
AttractorKernel * myAttractor;
AttractorKernel * myAttractor;
public:
// should be private really
std::vector<Projector *> projectors;
Attractor(const char* const filename);
Attractor(const char* const filename);
~Attractor();
void init_range();
bool is_chaos();
void init_range();
bool is_chaos();
void iterate();
void plot();
void output();
void iterate();
void plot();
void output();
};

100
AttractorKernel.cpp

@ -1,9 +1,9 @@
/*
* AttractorKernel.cpp
* AwesomeAttractor
* AttractorKernel.cpp
* AwesomeAttractor
*
* Created by Joshua Moerman on 07-08-10.
* Copyright 2010 Rodo. All rights reserved.
* Created by Joshua Moerman on 07-08-10.
* Copyright 2010 Rodo. All rights reserved.
*
*/
@ -97,62 +97,62 @@ AttractorKernel * AttractorKernel::createAttractorKernel(stfu::node& attractor){
AttractorKernel * myAttractor = NULL;
// reading basic stuff
const std::string attractorType = attractor.getValue("type");
const std::string attractorDimension = attractor.getValue("dimensions");
const std::string attractorType = attractor.getValue("type");
const std::string attractorDimension = attractor.getValue("dimensions");
// for ( unsigned int i = 0; attractorType[i] != '\0'; i++ ) {
// attractorType[i] = tolower(attractorType[i]);
// }
const unsigned int dimension = atoi(attractorDimension.c_str());
// for ( unsigned int i = 0; attractorType[i] != '\0'; i++ ) {
// attractorType[i] = tolower(attractorType[i]);
// }
const unsigned int dimension = atoi(attractorDimension.c_str());
std::cout << " Formula: " << attractorType << std::endl;
std::cout << " Dimensions: " << dimension << std::endl;
std::cout << " Formula: " << attractorType << std::endl;
std::cout << " Dimensions: " << dimension << std::endl;
// depending on type, make the formula object
if ( attractorType == "lorenz" ){
if ( dimension == 3 ) {
myAttractor = new Lorenz3D();
} else {
std::cerr << "something wrong";
exit(37);
}
} else if ( attractorType == "polynomial" ) {
const std::string attractorOrde = attractor.getValue("orde");
const unsigned int orde = atoi(attractorOrde.c_str());
std::cout << " Orde: " << orde << std::endl;
myAttractor = new Polynomial(dimension, orde);
} else if ( attractorType == "polynomial a" ) {
if ( dimension == 3 ) {
myAttractor = new PolynomialA3D();
} else {
std::cerr << "something wrong";
exit(37);
}
} else if ( attractorType == "logistic" ) {
myAttractor = new Logistic(dimension);
} else if ( attractorType == "unravel" ) {
if ( dimension == 3 ) {
myAttractor = new Unravel3D();
} else {
std::cerr << "something wrong";
exit(37);
}
} else {
std::cout << "'" << attractorType << "' not recognized" << std::endl;
exit(3);
}
if ( attractorType == "lorenz" ){
if ( dimension == 3 ) {
myAttractor = new Lorenz3D();
} else {
std::cerr << "something wrong";
exit(37);
}
} else if ( attractorType == "polynomial" ) {
const std::string attractorOrde = attractor.getValue("orde");
const unsigned int orde = atoi(attractorOrde.c_str());
std::cout << " Orde: " << orde << std::endl;
myAttractor = new Polynomial(dimension, orde);
} else if ( attractorType == "polynomial a" ) {
if ( dimension == 3 ) {
myAttractor = new PolynomialA3D();
} else {
std::cerr << "something wrong";
exit(37);
}
} else if ( attractorType == "logistic" ) {
myAttractor = new Logistic(dimension);
} else if ( attractorType == "unravel" ) {
if ( dimension == 3 ) {
myAttractor = new Unravel3D();
} else {
std::cerr << "something wrong";
exit(37);
}
} else {
std::cout << "'" << attractorType << "' not recognized" << std::endl;
exit(3);
}
// read parameters
const unsigned int numberOfParameters = myAttractor->getNumberOfParameters();
const unsigned int numberOfParameters = myAttractor->getNumberOfParameters();
for ( unsigned int i = 0; i < numberOfParameters; i++ ) {
stfu::node attractorParameters = attractor.getChild("parameters");
(*myAttractor)[i] = atof(attractorParameters.getValue(i).c_str());
for ( unsigned int i = 0; i < numberOfParameters; i++ ) {
stfu::node attractorParameters = attractor.getChild("parameters");
(*myAttractor)[i] = atof(attractorParameters.getValue(i).c_str());
std::cout << " Parameter " << i << " set to " << (*myAttractor)[i] << ", ";
}
}
std::cout << std::endl << " Reading file complete" << std::endl;

12
AttractorKernel.hpp

@ -26,17 +26,17 @@ protected:
public:
// parameters are stored in a array of doubles
// parameters are stored in a array of doubles
double & operator[](const unsigned int index);
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;
// getter functions for teh resulta (can't be used as setters)
double const * vector() const;
double const * previousVector() const;
// getter functions for teh resulta (can't be used as setters)
double const * vector() const;
double const * previousVector() const;
unsigned int getDimension() const;
// dtor, should be virtual for subclasses to be deleted

340
Canvas.cpp

@ -10,236 +10,236 @@
Canvas::Canvas(unsigned int width, unsigned int height, unsigned int num_colors):
dim(2), width(width), height(height), num_colors(num_colors), v(0) {
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;
int_array = new unsigned int[width*height*num_colors];
size = new unsigned int[2];
size[0] = width;
size[1] = height;
assert(int_array != NULL);
assert(int_array != NULL);
clear();
clear();
#ifdef HARDDEBUG
cout << "New canvas" << endl;
cout << "New canvas" << endl;
#endif
}
void Canvas::clear() {
for ( unsigned int i = 0; i < width*height*num_colors; i++ ) {
int_array[i] = 0;
}
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;
// //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;
// //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;
// }
// } 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;
// //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);
// //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]++;
}
// 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]++;
}
// 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
// same as plot(double x, double y, unsigned int c)
// but now uses the float array (not yet implemented
}
/*
I/O functions
I/O functions
*/
void Canvas::output() {
std::cout << "Canvas: " << std::endl;
std::cout << "Dimensions: " << width << " x " << height << " x " << num_colors << 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();
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;
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);
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);
output_file(filename);
}
void Canvas::output_raw(const char * filename){
std::ofstream outfile (filename, std::ofstream::binary);
std::ofstream outfile (filename, std::ofstream::binary);
outfile.write(reinterpret_cast<char*>(int_array), sizeof(unsigned int)*width*height*num_colors);
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;
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);
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);
output_raw(filename);
}
void Canvas::input_raw(const char * filename){
std::ifstream infile(filename, std::ifstream::binary);
std::ifstream infile(filename, std::ifstream::binary);
if ( ! infile ) {
std::cout << "poep" << std::endl;
return;
}
if ( ! infile ) {
std::cout << "poep" << std::endl;
return;
}
infile.seekg (0, std::ios::end);
int length = infile.tellg();
infile.seekg (0, std::ios::beg);
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;
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);
infile.read (reinterpret_cast<char*>(int_array), sizeof (unsigned int)*width*height*num_colors);
}

46
Canvas.hpp

@ -9,39 +9,39 @@
// TODO : Canvas class abstraheren (zodat er makkelijk verschillende soorten canvae gemaakt kunnen worden)
class Canvas{
friend class Projector;
friend class Projector;
unsigned int dim;
unsigned int width;
unsigned int height;
unsigned int num_colors;
unsigned int dim;
unsigned int width;
unsigned int height;
unsigned int num_colors;
unsigned int * size;
unsigned int * size;
unsigned int * int_array;
unsigned int * int_array;
public:
public:
double v;
double v;
Canvas(unsigned int width, unsigned int height, unsigned int num_colors = 1);
Canvas(unsigned int width, unsigned int height, unsigned int num_colors = 1);
void clear();
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 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();
//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);
void output_file(const char * filename);
void output_file();
void output_raw(const char * filename);
void output_raw();
void input_raw(const char * filename);
};

102
Parameters.cpp

@ -5,106 +5,106 @@ using namespace std;
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
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();
check_pointers();
#ifdef HARDDEBUG
cout << "New Parameters with one default val:" << endl << *this << endl;
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
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();
check_pointers();
#ifdef HARDDEBUG
cout << "New Parameters with two default vals:" << endl << *this << endl;
cout << "New Parameters with two default vals:" << endl << *this << endl;
#endif
}*/
Parameters::~Parameters() {
delete begin;
delete eind;
delete interpolated;
delete begin;
delete eind;
delete interpolated;
#ifdef HARDDEBUG
cout << "Parameters deleted" << endl;
cout << "Parameters deleted" << endl;
#endif
}
void Parameters::check_pointers() {
assert(begin != NULL);
assert(eind != NULL);
assert(interpolated != NULL);
assert(begin != NULL);
assert(eind != NULL);
assert(interpolated != NULL);
}
void Parameters::set(unsigned int parameter, float val1, float val2) {
assert(parameter < num_parameters);
assert(parameter < num_parameters);
begin->coordinates[parameter] = val1;
eind->coordinates[parameter] = val2;
interpolated->coordinates[parameter] = val1;
begin->coordinates[parameter] = val1;
eind->coordinates[parameter] = val2;
interpolated->coordinates[parameter] = val1;
#ifdef HARDDEBUG
cout << "Parameter " << parameter << " set to: " << val1 << " - " << val2 << endl;
cout << "Parameter " << parameter << " set to: " << val1 << " - " << val2 << endl;
#endif
}
void Parameters::set(unsigned int parameter, float val) {
assert(parameter < num_parameters);
assert(parameter < num_parameters);
begin->coordinates[parameter] = val;
eind->coordinates[parameter] = val;
interpolated->coordinates[parameter] = val;
begin->coordinates[parameter] = val;
eind->coordinates[parameter] = val;
interpolated->coordinates[parameter] = val;
#ifdef HARDDEBUG
cout << "Parameter " << parameter << " set to: " << val << endl;
cout << "Parameter " << parameter << " set to: " << val << endl;
#endif
}
float Parameters::get(unsigned int parameter) {
assert(parameter < num_parameters);
assert(parameter < num_parameters);
#ifdef HARDDEBUG
cout << "Asked for parameter " << parameter << " with value:" << interpolated->coordinates[parameter] << endl;
cout << "Asked for parameter " << parameter << " with value:" << interpolated->coordinates[parameter] << endl;
#endif
return interpolated->coordinates[parameter];
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];
}
/*
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;
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;
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;
}

30
Parameters.hpp

@ -5,30 +5,30 @@
class Parameters {
Vector * begin;
Vector * eind;
Vector * interpolated;
Vector * begin;
Vector * eind;
Vector * interpolated;
void check_pointers();
void check_pointers();
public:
// for checks and assertions
unsigned int num_parameters;
// 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();
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 set(unsigned int parameter, float val1, float val2);
void set(unsigned int parameter, float val);
float get(unsigned int parameter);
void interpolate(float time);
void interpolate(float time);
// output operator
friend ostream& operator<<(ostream& os, const Parameters& param);
// output operator
friend ostream& operator<<(ostream& os, const Parameters& param);
};
#endif // PARAMETER_HPP

120
Projector.cpp

@ -7,103 +7,103 @@
#include "myMath.hpp"
void Projector::init(const double * point) {
init_vector();
init_vector();
project(point);
init_range();
project(point);
init_range();
}
void Projector::init_vector() {
project_point = new double[intern_dim];
offset = new double[intern_dim];
project_point = new double[intern_dim];
offset = new double[intern_dim];
assert(project_point != NULL);
assert(offset != NULL);
assert(project_point != NULL);
assert(offset != NULL);
}
void Projector::init_range() {
range_min = new double[intern_dim];
range_max = new double[intern_dim];
range_min = new double[intern_dim];
range_max = new double[intern_dim];
assert(range_min != NULL);
assert(range_max != NULL);
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];
}
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) {
project(point);
for ( unsigned int i = 0; i < intern_dim; i++ ) {
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];
}
}
project(point);
for ( unsigned int i = 0; i < intern_dim; i++ ) {
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() {
// double max_dist = 0.0;
// 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;
// }
// double max_dist = 0.0;
// 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]);
unsigned int teh_size = canvas->size[0];
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];
// 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]);
unsigned int teh_size = canvas->size[0];
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;
factor /= (double)teh_size;
for ( unsigned int i = 0; i < intern_dim; i++ ) {
offset[i] = -0.5*factor*(range_min[i] + range_max[i]);
}
for ( unsigned int i = 0; i < intern_dim; i++ ) {
offset[i] = -0.5*factor*(range_min[i] + range_max[i]);
}
}
void Projector::project(const double * point) {
assert(extern_dim >= 2);
project_point[0] = point[0];
project_point[1] = point[1];
assert(extern_dim >= 2);
project_point[0] = point[0];
project_point[1] = point[1];
}
void Projector::plot(const double * point) {
project(point);
project(point);
const double x = project_point[0]*factor + offset[0];
const double y = project_point[1]*factor + offset[1];
const double x = project_point[0]*factor + offset[0];
const double y = project_point[1]*factor + offset[1];
//cout << x << ", " << y << endl;
//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);
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++ ) {
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;
}
}
}

48
Projector.hpp

@ -4,37 +4,37 @@
class Canvas;
class Projector{
public:
public:
unsigned int extern_dim;
unsigned int intern_dim;
unsigned int extern_dim;
unsigned int intern_dim;
Canvas * canvas;
double * project_point;
Canvas * canvas;
double * project_point;
double * range_min;
double * range_max;
double factor;
double * offset;
double * range_min;
double * range_max;
double factor;
double * offset;
void init(const double * point);
void init_vector();
void init_range();
void update_range(const double * point);
void finish_range();
void init(const double * point);
void init_vector();
void init_range();
void update_range(const double * point);
void finish_range();
// TODO : Matrix gebruiken voor lineaire afbeelding
// TODO : Over kleuren nadenken
/*
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);
// TODO : Matrix gebruiken voor lineaire afbeelding
// TODO : Over kleuren nadenken
/*
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();
void output();
};
#endif // PROJECTOR_HPP

106
Vector.cpp

@ -4,123 +4,123 @@ using namespace std;
#include "Vector.hpp"
Vector::Vector():
dimension(0) {
dimension(0) {
coordinates = new (nothrow) float[0];
coordinates = new (nothrow) float[0];
assert(coordinates != NULL);
assert(coordinates != NULL);
#ifdef HARDDEBUG
cout << "New vector (without elements)" << endl;
cout << "New vector (without elements)" << endl;
#endif
}
Vector::Vector(unsigned int d):
dimension(d) {
dimension(d) {
coordinates = new (nothrow) float[dimension];
coordinates = new (nothrow) float[dimension];
assert(coordinates != NULL);
assert(coordinates != NULL);
#ifdef HARDDEBUG
cout << "New vector:" << endl << *this << endl;
cout << "New vector:" << endl << *this << endl;
#endif
}
Vector::Vector(unsigned int d, float default_val):
dimension(d) {
dimension(d) {
coordinates = new (nothrow) float[dimension];
coordinates = new (nothrow) float[dimension];
assert(coordinates != NULL);
assert(coordinates != NULL);
for (unsigned int i = 0; i < dimension; i++) {
coordinates[i] = default_val;
}
for (unsigned int i = 0; i < dimension; i++) {
coordinates[i] = default_val;
}
#ifdef HARDDEBUG
cout << "New vector with default values:" << endl << *this << endl;
cout << "New vector with default values:" << endl << *this << endl;
#endif
}
Vector::~Vector() {
delete[] coordinates;
delete[] coordinates;
#ifdef HARDDEBUG
cout << "coordinates deleted" << endl;
cout << "coordinates deleted" << endl;
#endif
}
Vector& Vector::operator=(const Vector& a) {
if ( dimension != a.dimension ) {
dimension = a.dimension;
delete[] coordinates;
coordinates = new float[dimension];
if ( dimension != a.dimension ) {
dimension = a.dimension;
delete[] coordinates;
coordinates = new float[dimension];
#ifdef HARDDEBUG
cout << "Dimensions were not equal, made new vector" << endl;
cout << "Dimensions were not equal, made new vector" << endl;
#endif
}
}
for ( unsigned int i = 0; i < dimension; i++ ) {
coordinates[i] = a.coordinates[i];
}
for ( unsigned int i = 0; i < dimension; i++ ) {
coordinates[i] = a.coordinates[i];
}
#ifdef HARDDEBUG
cout << "operator= result" << endl << *this << endl;
cout << "operator= result" << endl << *this << endl;
#endif
return *this;
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 << a.dimension << endl;
for ( unsigned int i = 0; i < a.dimension; i++ ) {
os << a.coordinates[i] << " ";
}
os << endl;
return os;
os << endl;
return os;
}
float& Vector::operator[](const unsigned int index) {
assert(index < dimension);
return coordinates[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];
}
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;
cout << "operator+ result" << endl << ret << endl;
#endif
return ret;
}
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;
}
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;
cout << "operator* result" << endl << ret << endl;
#endif
return ret;
return ret;
}
*/

34
Vector.hpp

@ -2,28 +2,28 @@
#define VECTOR_HPP
class Vector {
public:
public:
unsigned int dimension;
float * coordinates;
unsigned int dimension;
float * coordinates;
// const, dest
Vector();
Vector(unsigned int d);
Vector(unsigned int d, float default_val);
~Vector();
// 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);
// output operator
friend ostream& operator<<(ostream& os, const Vector& a);
// easy access
float& Vector::operator[](const unsigned int index);
// 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;
// vector rekenen
Vector& operator=(const Vector& a);
// faaloperatoren
// Vector operator+(const Vector a) const;
// Vector operator*(const float a) const;
};

166
attractors/testAttractor.stf

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

110
attractors/testLorenz.stf

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

164
attractors/testPolynomial.stf

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

116
attractors/testUnravel.stf

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

76
attractors/testUnravelNew.stf

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

16
defines.hpp

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

18
kernels/Logistic.cpp

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

4
kernels/Logistic.hpp

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

18
kernels/Lorenz3D.cpp

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

6
kernels/Lorenz3D.hpp

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

52
kernels/Polynomial.cpp

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

10
kernels/Polynomial.hpp

@ -6,16 +6,16 @@
class Polynomial : public AttractorKernel {
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:
Polynomial();
Polynomial(const unsigned int dimensions, const unsigned int orde);
Polynomial();
Polynomial(const unsigned int dimensions, const unsigned int orde);
virtual void operator()();
virtual void operator()();
};

20
kernels/PolynomialA3D.cpp

@ -1,9 +1,9 @@
//
// $filename
// $projectname
// $filename
// $projectname
//
// Created by Joshua moerman on $TODAY.
// Copyright 2010 Joshua Moerman. All rights reserved.
// Created by Joshua moerman on $TODAY.
// Copyright 2010 Joshua Moerman. All rights reserved.
//
#include "PolynomialA3D.hpp"
@ -23,14 +23,14 @@ PolynomialA3D::PolynomialA3D():
void PolynomialA3D::operator()() {
std::swap(vectorNew, vectorOld);
vectorNew[0] = parameters[0] + vectorOld[1] - vectorOld[1]*vectorOld[2];
vectorNew[1] = parameters[1] + vectorOld[2] - vectorOld[2]*vectorOld[0];
vectorNew[2] = parameters[2] + vectorOld[0] - vectorOld[0]*vectorOld[1];
vectorNew[0] = parameters[0] + vectorOld[1] - vectorOld[1]*vectorOld[2];
vectorNew[1] = parameters[1] + vectorOld[2] - vectorOld[2]*vectorOld[0];
vectorNew[2] = parameters[2] + vectorOld[0] - vectorOld[0]*vectorOld[1];
}
/*
N dimensional:
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];
}
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];
}
*/

4
kernels/PolynomialA3D.hpp

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

26
kernels/Unravel3D.cpp

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

6
kernels/Unravel3D.hpp

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

64
main.cpp

@ -14,53 +14,53 @@
int main(int argc, char *argv[]) {
clock_t start, end;
double totalTime, totalIterations;
clock_t start, end;
double totalTime, totalIterations;
bool verbose = false;
bool verbose = false;
// initialising stuff
Attractor myAttractor(ATTRACTOR_FILE);
// initialising stuff
Attractor myAttractor(ATTRACTOR_FILE);
Projector projection;
Canvas canvas(WIDTH, HEIGHT, 3);
projection.canvas = &canvas;
Projector projection;
Canvas canvas(WIDTH, HEIGHT, 3);
projection.canvas = &canvas;
myAttractor.projectors.push_back(&projection);
myAttractor.init_range();
myAttractor.projectors.push_back(&projection);
myAttractor.init_range();
projection.output();
projection.output();
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();
}
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();
}
if (verbose) {
myAttractor.output();
std::cout << j << "% done" << std::endl;
}
}
end = clock();
}
end = clock();
totalIterations = 100.0*iterations;
totalTime = ((double)(end-start)/(double)(CLOCKS_PER_SEC));
std::cout << std::endl << "total clock time: " << totalTime << std::endl;
std::cout << "average iterations per second: " << totalIterations/((double)(end-start)/(double)(CLOCKS_PER_SEC)) << std::endl << std::endl;
totalIterations = 100.0*iterations;
totalTime = ((double)(end-start)/(double)(CLOCKS_PER_SEC));
std::cout << std::endl << "total clock time: " << totalTime << std::endl;
std::cout << "average iterations per second: " << totalIterations/((double)(end-start)/(double)(CLOCKS_PER_SEC)) << std::endl << std::endl;
// saving output
start = clock();
canvas.output_file();
end = clock();
// saving output
start = clock();
canvas.output_file();
end = clock();
totalTime = ((double)(end-start)/(double)(CLOCKS_PER_SEC));
totalTime = ((double)(end-start)/(double)(CLOCKS_PER_SEC));
std::cout << "total clock time for writing png: " << totalTime << std::endl;
std::cout << std::endl << "Awesome Attractor, version " << __DATE__ << std::endl;
std::cout << "total clock time for writing png: " << totalTime << std::endl;
std::cout << std::endl << "Awesome Attractor, version " << __DATE__ << std::endl;
return 0;
return 0;
}

2
myMath.hpp

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