273 lines
6.6 KiB
C++
273 lines
6.6 KiB
C++
|
|
|
|
#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);
|
|
}
|