/*
File gsm.h (GrauStufenMatrix)

HeaderFile zur Berechnung der Graustufenmatrix fuer die 
Erzeugung von Kaustiken mit der Lieberherr-Methode (www.dpk.ch/Material.htm).

 Autor
 Daniel Baumgartner
 Kantonsschule Baden
 
 www.mathematicus.ch
 eMail <vorname>_<nachname>@bluewin.ch
*/

const double pi=3.1415926;
const double grad=pi/180;

int sign(int z)
{
    if (z>0) return 1;
    else if (z<0) return -1;
    else return 0;
};

/* Klasse vek */
class vek
{
    public:
    double x,y;
    void def(double,double);
    vek operator + (vek);
    vek operator - (vek);
    vek operator * (double);
    void dreh(double);
    void schreibe();
};

vek vek::operator + (vek u)
{
    vek h;
    h.def(x+u.x,y+u.y);
    return h;
};

vek vek::operator - (vek u)
{
    vek h;
    h.def(x-u.x,y-u.y);
    return h;
};

vek vek::operator * (double a)
{
    vek h;
    h.def(a*x,a*y);
    return h;
};

void vek::def(double a,double b)
{
    x=a;
    y=b;
};

void vek::dreh(double phi)
{
    double h=x;
    x=x*cos(phi)-y*sin(phi);
    y=h*sin(phi)+y*cos(phi);
};

void vek::schreibe()
{
    cout << "{"<<x<<","<<y<<"}" << endl;
};


/* Klasse Punkt */

class pkt
{
    public:
    double x,y;
    pkt();
    pkt(double,double);
    void def(double,double);
    pkt operator + (vek);
    void schreibe();
};

pkt::pkt(double a,double b)
{
    x=a;
    y=b;
};

pkt::pkt()
{
    x=0;
    y=0;
};

void pkt::def(double a,double b)
{
    x=a;
    y=b;
};

pkt pkt::operator + (vek u)
{
    pkt h;
    h.def(x+u.x,y+u.y);
    return h;
};

void pkt::schreibe()
{
    cout << "("<<x<<","<<y<<")" << endl;
};

/* Klasse Matrix mit int-Eintraegen */

class intmat{
    private:
    
    public:
    int z,s;
    int *eintraege;
    intmat();
    intmat(int,int);
    void def(int,int);
    int& x(int,int);
    void schreibe();
    
    };
    
intmat::intmat(int m,int n){
    eintraege=new int[m*n];
    for (long i=0;i<m*n;i++){eintraege[i]=0;};
    z=m;
    s=n;
};

intmat::intmat(){
    eintraege=new int[0];
    eintraege[0]=0;
    z=1;
    s=1;
};


void intmat::def(int m,int n){
    delete[] eintraege;
    eintraege=new int[m*n];
    for (long i=0;i<m*n;i++){eintraege[i]=0;};
    z=m;
    s=n;
};
    
int& intmat::x(int i,int j){
    return eintraege[(i-1)*s+j-1];
};

void intmat::schreibe(){
    cout<<"{";
    for(int i=0;i<z;i++){
	cout<<"{";
	for (int j=0;j<s;j++){
	    cout<<eintraege[i*s+j];
	    if (j==s-1) cout<<"}";
	    else cout<<",";
	};    
	if (i==z-1) cout<<"}";
	else cout<<",";
    };
    cout<<endl;
};

double xmin,xmax,ymin,ymax;//Bereich der Figur
long pix_X;//Anzahl Pixel in x-Richtung

double deltax;
double deltay;

/* Berechnung der globalen Variablen
 xmin,xmax,ymin,ymax,deltax,deltay
*/
void pixel_koord(double x1, double x2,double y1, double y2)
{
    xmin=x1;
    xmax=x2;
    ymin=y1;
    ymax=y2;
    deltax=xmax-xmin;
    deltay=ymax-ymin;
}

/* Die Matrix in Mathematica-Syntax schreiben*/
void mathematicaMatrix(intmat a,char* name)
{
    FILE *mFile;
    
    mFile=fopen(name,"w");
    fprintf(mFile,"{");
    for (int i=0;i<a.z;i++){
	fprintf(mFile,"{");
	for (int j=0;j<a.s;j++){
	    fprintf(mFile,"%d",a.eintraege[i*a.s+j]);
	    if (j==a.s-1) fprintf(mFile,"}");
	    else fprintf(mFile,",");
	};    
	if (i==a.z-1) fprintf(mFile,"}");
	else fprintf(mFile,",\n");
    };
    cout<<endl;
    fclose(mFile);
}

/* Die Matrix in Octave bzw MatLab-Syntax schreiben*/
void octaveMatrix(intmat a,char* name)
{
    FILE *mFile;
    
    mFile=fopen(name,"w");
    fprintf(mFile,"[");
    for (int i=0;i<a.z;i++){
	for (int j=0;j<a.s;j++){
	    fprintf(mFile,"%d",a.eintraege[i*a.s+j]);
	    if (j<a.s-1) fprintf(mFile,",");
	    else if (i!=a.z-1) fprintf(mFile,";");
	};    
	if (i==a.z-1) fprintf(mFile,"];");
	else fprintf(mFile,"\n");
    };
    cout<<endl;
    fclose(mFile);
};

/* die Matrix in ein File schreiben
 a: die Matrix
 name: Name des Files
 flag: 0=Mathematicasyntax 1=Octave/MatLab-Syntax
*/
void pixelbild(intmat a,char* name,int flag)
{
    if (flag==0) mathematicaMatrix(a,name);
    else octaveMatrix(a,name);
    };



void pixel(int xi,int yi,intmat& p)
{
    p.x(yi+1,xi+1)++;
};

/* Implementation des Bresenham-Algorithmus*/
void erzeuge_pixelStrecke(int xa,int ya,int xe,int ye, intmat& p)
{
    int parX,parY,errD,errP,pix;
    
    int deltaX=xe-xa;
    int deltaY=ye-ya;
    int dx=sign(deltaX);
    int dy=sign(deltaY);
    if (deltaX*dx>deltaY*dy) {
	parX=dx;
	parY=0;
	errD=deltaX*dx;
	errP=deltaY*dy;
	pix=deltaX*dx;
    } else {
	parX=0;
	parY=dy;
	errD=deltaY*dy;
	errP=deltaX*dx;
	pix=deltaY*dy;
    };
    int xi=xa;
    int yi=ya;
    pixel(xi,yi,p);
    float d=-errD/2.0;
    for (int i=0;i<pix+1;i++) {
    
	d+=errP;
	if (d>0) {
	    d-=errD;
	    xi+=dx;
	    yi+=dy;
	} else {
	    xi+=parX;
	    yi+=parY;
	};
	pixel(xi,yi,p);
    };
};

/* Die Pixel einer Strecke berechnen */
void pixel_strecke(pkt a,pkt e,intmat& p)
{
    double k=pix_X/deltax;
    erzeuge_pixelStrecke(
        (int)round((a.x-xmin)*k),(int)round((a.y-ymin)*k),
        (int)round((e.x-xmin)*k),(int)round((e.y-ymin)*k),
        p);
};