// (c) Dinko Korunic, 36355514, kreator@fly.srk.fer.hr
// Zadatak broj 3 iz predmeta Racunalna grafika

#include <iostream.h>
#include <stdlib.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>

class MyDisplay
{
	// klasa MyDisplay u kojoj se nalaze inicijalizacijske xlib
	// rutine, kao i postavljanje background i foreground boje, itd.
	XGCValues gcv;
	unsigned long wp, bp;
	int screen, winx, winy, winsx, winsy;
	public:
		Display *disp;
		Window win;
		GC gc;
		XEvent ev;
		MyDisplay(int _winx, int _winy, int _winsx,
				int _winsy);
		~MyDisplay();
};

MyDisplay::MyDisplay(int _winx=0, int _winy=0, 
	int _winsx=400, int _winsy=400) :
	winx(_winx), winy(_winy), winsx(_winsx), winsy(_winsy)
{

	// konstruktor koji sluzi za misc. inicijalizaciju
	cout << "Initialising graphic subsystem.." << endl;
	// otvaranje displaya
	if ((disp=XOpenDisplay(NULL))==NULL)
	{
		cerr << "I can't open display." << endl;
		exit(EXIT_FAILURE);
	}
	screen=DefaultScreen(disp);
	// stvaranje prototipnog prozora
	win=XCreateSimpleWindow(disp, DefaultRootWindow(disp),
		winx, winy, winsx, winsy, 1, wp=WhitePixel(disp, screen),
		bp=BlackPixel(disp, screen));
	XSelectInput(disp, win, StructureNotifyMask | KeyPressMask
		| ExposureMask);
	// mapiranje prozora
	XMapWindow(disp, win);
	while(1)
	{
		// cekaj dok nije gotovo
		XNextEvent(disp, &ev);
		if (ev.type==MapNotify) break;
	}
	gcv.foreground=wp;
	gcv.background=bp;
	// stvori gc
	gc=XCreateGC(disp, win, GCForeground | GCBackground, &gcv);
	cout << "done." << endl;
}

MyDisplay::~MyDisplay()
{
	// destruktor za graficki engine
	cout << "Shutting graphic subsystem.." << endl;
	XFreeGC(disp, gc);
	XDestroyWindow(disp, win);
	XCloseDisplay(disp);
	cout << "done." << endl;
}

struct Node_t
{
	int x, y;	// node type
};

struct Poly_t
{
	int CoordCount;		// broj koordinata poligona
	Node_t *PolyPtr;	// pokazivac na matricu sa koordinatama poligona
	Node_t *PointPtr;	// pokazivac na matricu sa koordinatama tocke
}; 

class MyDraw3 : public MyDisplay
{
	Poly_t MyPolyPtr;
	long *a, *b, *c; // long buduci da se koordinate mnoze
	int x0, y0, a1, b1, c1, N0, *s; // ove vrijednosti mogu biti
					// cjelobrojne
	float x3, y3, x2, y2, t, t1, d1, d2; // ali ove ne!
	void MyCalcCoef(void);
	void MyWait(void);
	void MyDrawPoly(void);
	void MyCheckPointPoly(void);
	void MyPolyFill(void);
	void V32(void);
	void V31(void);
	public:
		MyDraw3(Poly_t tmpSrc);
};

MyDraw3::MyDraw3(Poly_t tmpSrc) : MyPolyPtr(tmpSrc)
{
	// konstruktor koji poziva bitne pod-dijelove
	MyDrawPoly();
	MyCalcCoef();
	MyCheckPointPoly();
	XFlush(disp);
	MyWait();
	MyPolyFill();
	XFlush(disp);
	MyWait();
}

void MyDraw3::MyDrawPoly(void)
{
	// rutina za iscrtavanje poligona
	int i;
	for (i=0; i<=MyPolyPtr.CoordCount; i++)
	{
		XDrawLine(disp, win, gc, MyPolyPtr.PolyPtr[i].x,
			MyPolyPtr.PolyPtr[i].y, MyPolyPtr.PolyPtr[i+1].x,
			MyPolyPtr.PolyPtr[i+1].y);
	}
}

void MyDraw3::MyWait(void)
{
	// postavi wait na keypress
	XSelectInput(disp, win, KeyPressMask | ExposureMask);
	while(1)
	{
		XNextEvent(disp, &ev);
		if (ev.type==KeyPress) break;
	}
}

void MyDraw3::MyCalcCoef(void)
{
	// izracunavanje koeficijenata jednadzbi bridova
	int crdcnt=MyPolyPtr.CoordCount;
	a=new long[crdcnt];
	b=new long[crdcnt];
	c=new long[crdcnt];
	for(int i=0; i<crdcnt; ++i)
	{
		// izracunavanje koeficijenata jednadzbi bridova
		a[i]=MyPolyPtr.PolyPtr[i].y-MyPolyPtr.PolyPtr[i+1].y;
		b[i]=-MyPolyPtr.PolyPtr[i].x+MyPolyPtr.PolyPtr[i+1].x;
		c[i]=MyPolyPtr.PolyPtr[i].x*MyPolyPtr.PolyPtr[i+1].y-
			MyPolyPtr.PolyPtr[i+1].x*MyPolyPtr.PolyPtr[i].y;
	}
}

void MyDraw3::MyCheckPointPoly(void)
{
	// metoda koji sluzi da odredjivanje da li je tocka u poligonu
	// odredimo koeficijente jednadzbe horizontalne zrake iz V
	a1=0;
	b1=1;
	c1=-MyPolyPtr.PointPtr[0].y;
	// postavimo sjecista zrake i bridova poligona
	x0=MyPolyPtr.PointPtr[0].x;
	y0=MyPolyPtr.PointPtr[0].y;
	// crtanje tocke
	XDrawPoint(disp, win, gc, x0, y0);
	s=new int[MyPolyPtr.CoordCount+2];
	V31();
	// odredimo poziciju tocke preko broja sjecista S linije i bridova
	// poligona
	if (N0%2) cout << "Tocka je unutar poligona";
		else cout << "Tocka je izvan poligona";
	cout << endl;
}

void MyDraw3::V31(void)
{
	// metoda V31, kojom se odredjuje broj N0 sjecista S linije i
	// bridova poligona, te puni s[] matrica
	N0=0;
	float w3;
	for (int i=0; i<MyPolyPtr.CoordCount; ++i)
	{
		// izracunavanje sjecista
		x3=b[i]*c1-c[i]*b1;
		y3=-a[i]*c1+c[i]*a1;
		w3=a[i]*b1-b[i]*a1;
		// paralelni pravci
		if (!w3) continue;
		// nehomogene koordinate
		x3=x3/w3;
		y3=y3/w3;
		//postavljanje parametra t tocke x3,y3 na liniji
		MyPolyPtr.PointPtr[0].x=x0;
		MyPolyPtr.PointPtr[0].y=y0;
		x2=MyPolyPtr.PointPtr[0].x+1;
		y2=y0;
		V32();
		if (t<0.) continue;
		// sacuvati vrijednost t
		t1=t;
		// parametar t tocke x3,y3 na i-tom bridu
		MyPolyPtr.PointPtr[0].x=MyPolyPtr.PolyPtr[i].x;
		MyPolyPtr.PointPtr[0].y=MyPolyPtr.PolyPtr[i].y;
		x2=MyPolyPtr.PolyPtr[i+1].x;
		y2=MyPolyPtr.PolyPtr[i+1].y;
		V32();
		if (t<=0. || t>1.) continue;
		if (t==1.)
		{
			// linija i brid se sijeku u zavrsnom vrhu brida,
			// te ako je i-ti brid i (i+1)-ti brid ispod/iznad
			// linije treba odbaciti sjeciste
			x2=MyPolyPtr.PolyPtr[i+2].x;
			y2=MyPolyPtr.PolyPtr[i+2].y;
			d1=a1*MyPolyPtr.PointPtr[0].x+b1*
				MyPolyPtr.PointPtr[0].y+c1;
			d2=a1*x2+b1*y2+c1;
			if ((d1>0. && d2>0.) || (d1<0. && d2<0.)) continue;
			s[N0++]=(int)t1;
		}
		else
		s[N0++]=(int)t1;
	}
}

void MyDraw3::V32(void)
{
	// metoda V32 koja sluzi da za liniju (x1,y1) i (x2,y2) odredimo
	// parametar t za tocku linije (x3,y3)
	d1=x2-MyPolyPtr.PointPtr[0].x;
	d2=y2-MyPolyPtr.PointPtr[0].y;
	if (d1) t=(x3-MyPolyPtr.PointPtr[0].x)/d1;
	if (d2) t=(y3-MyPolyPtr.PointPtr[0].y)/d2;
}

void MyDraw3::MyPolyFill(void)
{
	// metoda koja sluzi da punjenje konkavnog poligona
	int xmin, xmax, ymin, ymax, Z, i, j;
	xmin=xmax=MyPolyPtr.PolyPtr[0].x;
	ymin=ymax=MyPolyPtr.PolyPtr[0].y;
	int tmpP;
	for(i=0; i<MyPolyPtr.CoordCount; i++)
	{
		// odredimo maximalni x i y kao i minimalni
		if ((tmpP=MyPolyPtr.PolyPtr[i].x)>xmax) xmax=tmpP;
		if (tmpP<xmin) xmin=tmpP;
		if ((tmpP=MyPolyPtr.PolyPtr[i].y)>ymax) ymax=tmpP;
		if (tmpP<ymin) ymin=tmpP;
	}
	for (int L=ymin; L<=ymax; ++L)
	{
		// pocetna tocka ispitne linije i koeficijenti njene
		// jednadzbe
		x0=0;
		y0=L;
		a1=0;
		b1=1;
		c1=-y0;
		// sjecista ispitne linije i bridova poligona
		V31();
		// pogledati broj sjecista
		if (N0<2) continue;
		do
		{
			// uzlazno urediti sjecista duz linije
			Z=0;
			for (i=0; i<=N0-2; ++i)
			{
				if (s[i]>s[i+1])
				{
					t=s[i];
					s[i]=s[i+1];
					s[i+1]=(int)t;
					Z=1;
				}
			}
		} while (Z);
		// punjenje
		for (j=0; j<=N0-1; j+=2)
			XDrawLine(disp, win, gc, s[j], y0, s[j+1], y0);
	}
}

Poly_t MyAllInput(void)
{
	Poly_t tmpPolyPtr;
	// unos broja koordinata
	do
	{
		cout << "Unesi broj vrhova n konveksnog poligona ";
		cin >> tmpPolyPtr.CoordCount;
	} while (tmpPolyPtr.CoordCount<3);
	// alociraj prostor za n vrhova
	tmpPolyPtr.PolyPtr=new Node_t[tmpPolyPtr.CoordCount+2];
	int i;
	for (i=0; i<tmpPolyPtr.CoordCount; i++)
	{
		cout << "Unesi x,y tocke #" << i+1 << " ";
		cin >> tmpPolyPtr.PolyPtr[i].x;
		cin >> tmpPolyPtr.PolyPtr[i].y;
	}
	// konkavni poligon! spoji krajnje tocke
	tmpPolyPtr.PolyPtr[i]=tmpPolyPtr.PolyPtr[0];
	tmpPolyPtr.PolyPtr[i+1]=tmpPolyPtr.PolyPtr[1];
	tmpPolyPtr.PointPtr=new Node_t[1];	
	cout << "Unesi x,y koordinate tocke V(x1,y1) ";
	cin >> tmpPolyPtr.PointPtr[0].x;
	cin >> tmpPolyPtr.PointPtr[0].y;
	return tmpPolyPtr;
}

int main(void)
{
	MyDraw3 MyDraw3Object(MyAllInput());
	return EXIT_SUCCESS;
}