#include "tgraphics.h"

extern "C" {

#include "Tw/Gf.h"

#include "tvis.h"

}

TGraphics::TGraphics(_TWIDGET *_gf,

					 int ras_x0, int ras_y0,

					 int ras_x1, int ras_y1,

					 int gf_x0, int gf_y0,

					 int gf_x1, int gf_y1,

					 int zoom_level)

	: gf(_gf), currentPoint(0, 0), gfRegion(gf_x0, gf_y0, gf_x1, gf_y1), rasterRegion(ras_x0 - 1, ras_y0 - 1, ras_x1 + 1, ras_y1 + 1)

	  //, rasterRegion(ras_x0,ras_y0,ras_x1,ras_y1)

	  ,

	  zoomFactor(1), pixelSize(1)

{

	double dx, dy;

	int blx, bly;

	if (zoom_level > 0)

		zoomFactor = 1 << zoom_level;

	else if (zoom_level < 0)

		zoomFactor = 1.0 / (1 << -zoom_level);

	pixelSize = 1.0 / zoomFactor;

	blx = ras_x0 - gf_x0 / zoomFactor;

	bly = ras_y0 - gf_y0 / zoomFactor;

	dx = 0.5 - blx;

	dy = 0.5 - bly;

	GfPushMatrix(gf);

	GfTranslate(gf, -0.5, -0.5);

	GfScale(gf, zoomFactor, zoomFactor);

	GfTranslate(gf, dx, dy);

}

//---------------------------------------------------

TGraphics::~TGraphics()

{

	GfPopMatrix(gf);

}

//---------------------------------------------------

void TGraphics::setColor(int r, int g, int b)

{

	_r = r;

	_g = g;

	_b = b;

	GfCpack(gf, r, g, b);

}

//---------------------------------------------------

void TGraphics::drawLine(const TPointI &a, const TPointI &b)

{

	if (a.x < rasterRegion.x0 && b.x < rasterRegion.x0 ||

		a.x > rasterRegion.x1 && b.x > rasterRegion.x1 ||

		a.y < rasterRegion.y0 && b.y < rasterRegion.y0 ||

		a.y > rasterRegion.y1 && b.y > rasterRegion.y1)

		return;

	int v[2];

	GfBgnLine(gf);

	v[0] = a.x;

	v[1] = a.y;

	GfV2i(gf, v);

	v[0] = b.x;

	v[1] = b.y;

	GfV2i(gf, v);

	GfEndLine(gf);

}

//---------------------------------------------------

void TGraphics::drawLine(const TPointD &a, const TPointD &b)

{

	if (a.x < rasterRegion.x0 && b.x < rasterRegion.x0 ||

		a.x > rasterRegion.x1 && b.x > rasterRegion.x1 ||

		a.y < rasterRegion.y0 && b.y < rasterRegion.y0 ||

		a.y > rasterRegion.y1 && b.y > rasterRegion.y1)

		return;

	double v[2];

	GfBgnLine(gf);

	v[0] = a.x;

	v[1] = a.y;

	GfV2d(gf, v);

	v[0] = b.x;

	v[1] = b.y;

	GfV2d(gf, v);

	GfEndLine(gf);

}

//---------------------------------------------------

void TGraphics::beginPolygon()

{

	GfBgnPolygon(gf);

}

//---------------------------------------------------

void TGraphics::endPolygon()

{

	GfEndPolygon(gf);

}

//---------------------------------------------------

void TGraphics::beginLine()

{

	GfBgnLine(gf);

}

//---------------------------------------------------

void TGraphics::endLine()

{

	GfEndLine(gf);

}

//---------------------------------------------------

void TGraphics::vertex(const TPointI &a)

{

	int v[2];

	v[0] = a.x;

	v[1] = a.y;

	GfV2i(gf, v);

}

//---------------------------------------------------

void TGraphics::vertex(const TPointD &a)

{

	double v[2];

	v[0] = a.x;

	v[1] = a.y;

	GfV2d(gf, v);

}

//---------------------------------------------------

void TGraphics::drawRect(const TPointI &a, const TPointI &b)

{

	GfRecti(gf, a.x, a.y, b.x, b.y);

}

//---------------------------------------------------

void TGraphics::drawRect(const TPointD &a, const TPointD &b)

{

	GfRect(gf, a.x, a.y, b.x, b.y);

}

//---------------------------------------------------

void TGraphics::drawRect(const TRectI &rect)

{

	GfRecti(gf, rect.x0, rect.y0, rect.x1, rect.y1);

}

//---------------------------------------------------

void TGraphics::drawRect(const TRectD &rect)

{

	GfRect(gf, rect.x0, rect.y0, rect.x1, rect.y1);

}

//---------------------------------------------------

void TGraphics::drawArc(const TBezierArc &arc)

{

	int n = 50;

	beginLine();

	for (int i = 0; i <= n; i++)

		vertex(arc.getPoint((double)i / (double)n));

	endLine();

}

//---------------------------------------------------

void TGraphics::drawArc(const TCubicCurve &arc)

{

	int n = 80;

	beginLine();

	for (int i = 0; i <= n; i++)

		vertex(arc.getPoint((double)i / (double)n));

	endLine();

}

//---------------------------------------------------

void TGraphics::drawArcTo(const TPointD &d1, const TPointD &d2,

						  const TPointD &d3)

{

	TPointD oldPoint = currentPoint;

	currentPoint += d1 + d2 + d3;

	drawArc(TBezierArc(oldPoint, oldPoint + d1, oldPoint + d1 + d2, currentPoint));

}

//---------------------------------------------------

void TGraphics::drawDiamond(const TPointD &p, double r)

{

	beginPolygon();

	vertex(p + TPointD(r, 0));

	vertex(p + TPointD(0, r));

	vertex(p + TPointD(-r, 0));

	vertex(p + TPointD(0, -r));

	endPolygon();

}

//---------------------------------------------------

void TGraphics::drawCross(const TPointD &p, double r)

{

	drawLine(p - TPointD(r, r), p + TPointD(r, r));

	drawLine(p - TPointD(-r, r), p + TPointD(-r, r));

}

//---------------------------------------------------

void TGraphics::drawSquare(const TPointD &p, double r)

{

	beginLine();

	vertex(p + TPointD(-r, -r));

	vertex(p + TPointD(-r, r));

	vertex(p + TPointD(r, r));

	vertex(p + TPointD(r, -r));

	vertex(p + TPointD(-r, -r));

	endLine();

}

//---------------------------------------------------

void TGraphics::drawArc(

	const TPointD &p0,

	const TPointD &p1,

	const TPointD &p2)

{

	TRectD rect = convert(rasterRegion.enlarge(+10));

	//TRectD rect(rasterRegion.x0, rasterRegion.y0, rasterRegion.x1, rasterRegion.y1);

	TRectD bBox = boundingBox(p0, p1, p2);

	if (!rect.overlaps(bBox)) {

		/*

  unsigned char tmp_r = _r;

  unsigned char tmp_g = _g;

  unsigned char tmp_b = _b;

  setColor(100,100,100);

  drawRect(bBox);

  drawLine(TLineD(bBox.x0, bBox.y0, bBox.x1, bBox.y1));

  drawLine(TLineD(bBox.x0, bBox.y1, bBox.x1, bBox.y0));

  setColor(tmp_r, tmp_g, tmp_b);

  */

		return;

	}

	double threshold = pixelSize * 0.125;

	TPointD v = p2 - p0;

	TPointD u = p1 - p0;

	TPointD r = rotate90(v);

	double sqr_tsh = (threshold * threshold) * (v * v);

	double dist = r * u;

	if ((dist * dist) > sqr_tsh) {

		TPointD l1 = 0.5 * (p0 + p1);

		TPointD r1 = 0.5 * (p1 + p2);

		TPointD l2 = 0.5 * (l1 + r1);

		drawArc(p0, l1, l2);

		drawArc(l2, r1, p2);

	} else {

		beginLine();

		vertex(p0);

		vertex(p2);

		endLine();

	}

}

//---------------------------------------------------

void TGraphics::drawCircle(TPointD p, double radius)

{

	GfCirc(gf, p.x, p.y, radius);

}

//---------------------------------------------------

void TGraphics::fillCircle(TPointD p, double radius)

{

	GfCircf(gf, p.x, p.y, radius);

}

//---------------------------------------------------

void TGraphics::rectWrap(int wrap_pixels)

{

	GfRectWrap(gf, wrap_pixels);

}

//---------------------------------------------------

void TGraphics::rectWrite(int x0, int y0, int x1, int y1, void *buffer)

{

	GfRectWrite(gf, x0, y0, x1, y1, buffer);

}