//-----------------------------------------------------------------------------
int sample_d(mglGraph *gr)
{
mglData a(50,50),b(50,50);
mglData cx(50,50,50),cy(50,50,50),cz(50,50,50);
a.Modify("0.6*sin(2*pi*x)*sin(3*pi*y) + 0.4*cos(3*pi*(x*y))");
b.Modify("0.6*cos(2*pi*x)*cos(3*pi*y) + 0.4*cos(3*pi*(x*y))");
cx.Modify("0.01*(x-0.3)/pow((x-0.3)^2+(y-0.5)^2+(z-0.5)^2,1.5) - 0.01*(x-0.7)/pow((x-0.7)^2+(y-0.5)^2+(z-0.5)^2,1.5)");
cy.Modify("0.01*(y-0.5)/pow((x-0.3)^2+(y-0.5)^2+(z-0.5)^2,1.5) - 0.01*(y-0.5)/pow((x-0.7)^2+(y-0.5)^2+(z-0.5)^2,1.5)");
cz.Modify("0.01*(z-0.5)/pow((x-0.3)^2+(y-0.5)^2+(z-0.5)^2,1.5) - 0.01*(z-0.5)/pow((x-0.7)^2+(y-0.5)^2+(z-0.5)^2,1.5)");
gr->NewFrame();
gr->Box(); gr->Axis("xy");
gr->Puts(mglPoint(0,1.2,1),"Vector field (color ~ \\sqrt{a^2})","rC",8);
gr->Vect(a,b,"","value 50");
gr->EndFrame();
gr->NewFrame();
gr->Box(); gr->Axis("xy");
gr->Puts(mglPoint(0,1.2,1),"Vector field (length ~ \\sqrt{a^2})","rC",8);
gr->Vect(a,b);
gr->EndFrame();
gr->NewFrame();
gr->Box(); gr->Axis("xy");
gr->Puts(mglPoint(0,1.2,1),"Flow chart (blue - source)","rC",8);
gr->Flow(a,b);
gr->EndFrame();
return gr->GetNumFrame();
}
//-----------------------------------------------------------------------------
//
// Dots series
//
//-----------------------------------------------------------------------------
void MGL_EXPORT mgl_dots_ca(HMGL gr, HCDT x, HCDT y, HCDT z, HCDT c, HCDT a, const char *sch, const char *opt)
{
long n = x->GetNN(), d, k=1;
if(x->GetNz()>1) k=3; else if(x->GetNy()>1) k=2;
if(y->GetNN()!=n || z->GetNN()!=n || c->GetNN()!=n || (a && a->GetNN()!=n))
{ gr->SetWarn(mglWarnDim,"Dots"); return; }
gr->SaveState(opt);
d = gr->MeshNum>0 ? mgl_ipow(gr->MeshNum+1,k) : n;
d = n>d ? n/d:1;
static int cgid=1; gr->StartGroup("Dots",cgid++);
char mk=gr->SetPenPal(sch);
long ss=gr->AddTexture(sch);
if(mk==0) mk='.';
gr->Reserve(n);
for(long i=0;i<n;i+=d)
{
mglPoint p = mglPoint(x->vthr(i),y->vthr(i),z->vthr(i));
long pp = gr->AddPnt(p,gr->GetC(ss,c->vthr(i)),mglPoint(NAN),a?gr->GetA(a->vthr(i)):-1);
gr->mark_plot(pp, mk);
}
gr->EndGroup();
}
int Draw(mglGraph *gr)
{
gr->Line(mglPoint(),pnt,"Ar2");
char str[16]; snprintf(str,15,"i=%ld",i);
gr->Puts(mglPoint(),str);
return 0;
}
//-----------------------------------------------------------------------------
int sample(mglGraph *gr)
{
gr->Rotate(20,40);
gr->SetRanges(-2,2,-2,2,-1,3);
gr->FSurf("cos(2*pi*(x^2+y^2))/(x^2+y^2+1)^2/(x^2+y^2<4)");
gr->Drop(mglPoint(0,0,3),mglPoint(0,0,-1),0.7,"b");
return 0;
}
//-----------------------------------------------------------------------------
int static mgls_cut(mglGraph *gr, long , mglArg *a, const char *k, const char *)
{
int res=0;
if(!strcmp(k,"n")) gr->SetCut(a[0].v != 0);
else if(!strcmp(k,"nnnnnn"))
gr->SetCutBox(mglPoint(a[0].v,a[1].v,a[2].v), mglPoint(a[3].v,a[4].v,a[5].v));
else if(!strcmp(k,"s")) gr->CutOff(a[0].s.s);
else res = 1;
return res;
}
//-----------------------------------------------------------------------------
int static mgls_tickshift(mglGraph *gr, long , mglArg *a, const char *k, const char *)
{
int res=0;
if(!strcmp(k,"n")) gr->SetTickShift(mglPoint(a[0].v));
else if(!strcmp(k,"nn")) gr->SetTickShift(mglPoint(a[0].v, a[1].v));
else if(!strcmp(k,"nnn")) gr->SetTickShift(mglPoint(a[0].v, a[1].v, a[2].v));
else if(!strcmp(k,"nnnn")) gr->SetTickShift(mglPoint(a[0].v, a[1].v, a[2].v, a[3].v));
else res = 1;
return res;
}
void LearningCurve::ShowImage()
{
mglData y(episode_);
y.Set(steps_);
gr_->Box();
gr_->Plot(y, "b2");
//gr_->SetTicks('x', 1, -1);
gr_->Axis(mglPoint(0,0), mglPoint(y.nx, y.Maximal() * 1.25));
gr_->Axis();
gr_->Label('x',"Episode Number", 0);
gr_->Label('y',"Time Steps", 0);
gr_->Title("Learning Curve");
gr_->WritePNG("learningCurve.png");
}
void LearningCurve::Plot(mglData y)
{
gr_->NewFrame();
gr_->Box();
gr_->Plot(y, "b2");
//gr_->SetTicks('x', 1, -1);
gr_->Axis(mglPoint(0,0), mglPoint(y.nx, y.Maximal() * 1.25));
//gr_->Axis();
gr_->Label('x',"Episode Number", 0);
gr_->Label('y',"Time Steps", 0);
gr_->Title("Learning Curve");
gr_->ShowImage("eog", true);
gr_->EndFrame();
}
int main(int argc,char **argv)
{
mglFLTK gr("test");
gr.RunThr(); // <-- need MathGL version which use pthread
for(int i=0;i<10;i++) // do calculation
{
long_calculations();// which can be very long
pnt = mglPoint(2*mgl_rnd()-1,2*mgl_rnd()-1);
gr.Clf(); // make new drawing
gr.Line(mglPoint(),pnt,"Ar2");
char str[10] = "i=0"; str[3] = '0'+i;
gr.Update(); // update window
}
return 0; // finish calculations and close the window
}
//-----------------------------------------------------------------------------
void MainWindow::paintGL()
{
gr->Clf();
gr->SubPlot(1,1,0);
gr->Rotate(40,60);
gr->Light(true);
gr->AddLight(0,mglPoint(0,0,10),mglPoint(0,0,-1));
gr->Axis();
gr->Box();
gr->FPlot("sin(pi*x)","i2");
gr->FPlot("cos(pi*x)","|");
gr->FSurf("cos(2*pi*(x^2+y^2))");
gr->Finish();
swapBuffers();
}
//-----------------------------------------------------------------------------
int test2(mglGraph *gr, long , mglArg *a, const char *k, const char *)
{
int res=0;
if(!strcmp(k,"nnnns"))
{
gr->FaceZ(mglPoint(a[0].v-a[2].v/2,a[1].v-a[3].v/2),a[2].v,a[3].v,"r");
gr->Putsw(mglPoint(a[0].v,a[1].v),a[4].w.c_str());
}
else if(!strcmp(k,"nnnnss"))
{
gr->FaceZ(mglPoint(a[0].v-a[2].v/2,a[1].v-a[3].v/2),a[2].v,a[3].v,a[5].s.c_str());
gr->Putsw(mglPoint(a[0].v,a[1].v),a[4].w.c_str());
}
else res = 1; return res;
}
//-----------------------------------------------------------------------------
void mglGraphGLUT::Window(int argc, char **argv,int (*draw)(mglGraph *gr, void *p),const char *title, void *par, void (*reload)(int next, void *p), bool maximize)
{
NumFig=0; curr_fig=1; tt=0;
_mgl_glwnd = this;
CurFrameId = 1;
char *tmp[1]; tmp[0]=new char[1]; tmp[0][0]=0;
glutInit(&argc, argv ? argv:tmp);
delete []tmp[0];
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize(600, 600);
glutCreateWindow("MathPlotLibrary");
Light(0,mglPoint(0,0,3),false);
NumFig = draw(this,par)-1; Finish();
DrawFunc = draw; FuncPar = par;
LoadFunc = reload;
glutSetWindowTitle(title);
glutDisplayFunc(_mgl_display);
glutKeyboardUpFunc(_mgl_key_up);
glutTimerFunc(int(1000*Delay),_mgl_timer,0);
// TODO Add window maximazing at start up ???
glutMainLoop();
glDeleteLists(1,NumFig);
}
//-----------------------------------------------------------------------------
int test_wnd(mglGraph *gr)
{
mgl_set_test_mode(true);
// gr->SetQuality(6);
gr->NewFrame(); // 0
gr->Box();
gr->EndFrame();
gr->NewFrame(); // 1
gr->Axis();
gr->EndFrame();
gr->NewFrame(); // 2
gr->Label('x',"XXXX",0);
gr->Label('y',"YYYY",0);
gr->EndFrame();
gr->NewFrame(); // 3
gr->Puts(mglPoint(0,0),"0");
gr->EndFrame();
gr->Clf();
gr->ShowFrame(0);
gr->ShowFrame(1);
gr->ShowFrame(2);
gr->ShowFrame(3);
// gr->Puts(mglPoint(0,1),"1");
gr->Finish();
return 0;
}
//-----------------------------------------------------------------------------
void mglCanvas::trig_pix(long i, long j, const mglPnt &p1, const mglPnt &p2, const mglPnt &p3, bool anorm, const mglDrawReg *d)
{
if(!visible(i,j,d->m, d->PenWidth,d->angle)) return;
mglPnt d1(p2-p1), d2(p3-p1);
float dd = d2.x*d1.y - d1.x*d2.y;
if(fabs(dd)<1e-5) return; // points lies on the same line
float dyv =-d1.x/dd, dxv = d1.y/dd, dyu = d2.x/dd, dxu =-d2.y/dd;
float xx = (i-p1.x), yy = (j-p1.y);
float u = dxu*xx+dyu*yy, v = dxv*xx+dyv*yy;
if(u<0 || v<0 || u+v>1) return;
mglPnt p(p1+d1*u+d2*v);
if(mgl_isnan(p.u) && mgl_isnum(p.v) && anorm)
{ mglPoint nr(mglPoint(p2.x-p1.x,p2.y-p1.y,p2.z-p1.z)^mglPoint(p3.x-p1.x,p3.y-p1.y,p3.z-p1.z));
p.u = nr.x; p.v = nr.y; p.w = nr.z; }
unsigned char r[4];
if(r[3]) pnt_plot(i,j,p.z,col2int(p,r,d->ObjId),d->ObjId);
}
void *calc(void *)
{
mglPoint pnt;
for(int i=0;i<10;i++) // do calculation
{
long_calculations(); // which can be very long
pnt.Set(2*mgl_rnd()-1,2*mgl_rnd()-1);
if(gr)
{
gr->Clf(); // make new drawing
gr->Line(mglPoint(),pnt,"Ar2");
char str[10] = "i=0"; str[2] = '0'+i;
gr->Puts(mglPoint(),str);
gr->Update(); // update window
}
}
exit(0);
}
//-----------------------------------------------------------------------------
//
// DataGrid
//
//-----------------------------------------------------------------------------
MGL_NO_EXPORT void *mgl_grid_t(void *par)
{
mglThreadD *t=(mglThreadD *)par;
long nx=t->p[0],ny=t->p[1];
mreal *b=t->a;
const mreal *x=t->b, *y=t->c, *d=t->d;
HCDT zdat = (HCDT) t->v;
#if !MGL_HAVE_PTHREAD
#pragma omp parallel for
#endif
for(long i0=t->id;i0<t->n;i0+=mglNumThr)
{
register long k1 = long(d[3*i0]+0.5), k2 = long(d[3*i0+1]+0.5), k3 = long(d[3*i0+2]+0.5);
mreal dxu,dxv,dyu,dyv;
mreal z1=zdat->vthr(k1), z2=zdat->vthr(k2), z3=zdat->vthr(k3);
mglPoint d1=mglPoint(x[k2]-x[k1],y[k2]-y[k1],z2-z1), d2=mglPoint(x[k3]-x[k1],y[k3]-y[k1],z3-z1), p;
dxu = d2.x*d1.y - d1.x*d2.y;
if(fabs(dxu)<1e-5) continue; // points lies on the same line
dyv =-d1.x/dxu; dxv = d1.y/dxu;
dyu = d2.x/dxu; dxu =-d2.y/dxu;
long x1,y1,x2,y2;
x1 = long(mgl_min(mgl_min(x[k1],x[k2]),x[k3])); // bounding box
y1 = long(mgl_min(mgl_min(y[k1],y[k2]),y[k3]));
x2 = long(mgl_max(mgl_max(x[k1],x[k2]),x[k3]));
y2 = long(mgl_max(mgl_max(y[k1],y[k2]),y[k3]));
x1 = x1>0 ? x1:0; x2 = x2<nx ? x2:nx-1;
y1 = y1>0 ? y1:0; y2 = y2<ny ? y2:ny-1;
if((x1>x2) | (y1>y2)) continue;
register mreal u,v,xx,yy, x0 = x[k1], y0 = y[k1];
register long i,j;
for(i=x1;i<=x2;i++) for(j=y1;j<=y2;j++)
{
xx = (i-x0); yy = (j-y0);
u = dxu*xx+dyu*yy; v = dxv*xx+dyv*yy;
if((u<0) | (v<0) | (u+v>1)) continue;
b[i+nx*j] = z1 + d1.z*u + d2.z*v;
}
}
return 0;
}
int message::Draw(mglGraph *gr)
{
pmesg(DEBUG,"message::Draw()\n");
if(this->tmessage==0)
return 1;
gr->SubPlot(1,this->npin,this->pin);
gr->FaceZ(this->t0,0.0,-1,this->tmessage,3.0,"y9");
gr->Puts(mglPoint(this->t0+this->tmessage/2,2.25,1.0),this->label);
return 0;
}
//-----------------------------------------------------------------------------
void mglCanvas::quad_pix(long i, long j, const mglPnt &p1, const mglPnt &p2, const mglPnt &p3, const mglPnt &p4, const mglDrawReg *d)
{
if(!visible(i,j,d->m, d->PenWidth,d->angle)) return;
mglPnt d1(p2-p1), d2(p3-p1), d3(p4+p1-p2-p3);
float dd = d1.x*d2.y-d1.y*d2.x;
float dsx =-4*(d2.y*d3.x - d2.x*d3.y)*d1.y;
float dsy = 4*(d2.y*d3.x - d2.x*d3.y)*d1.x;
float xx = (i-p1.x), yy = (j-p1.y), s;
s = dsx*xx + dsy*yy + (dd+d3.y*xx-d3.x*yy)*(dd+d3.y*xx-d3.x*yy);
if(s<0) return; // no solution
s = sqrt(s);
float qu = d3.x*yy - d3.y*xx + dd + s, u=-1;
float qv = d3.y*xx - d3.x*yy + dd + s, v=-1;
if(qu && qv)
{
u = 2.f*(d2.y*xx - d2.x*yy)/qu;
v = 2.f*(d1.x*yy - d1.y*xx)/qv;
}
if(u*(1.f-u)<0.f || v*(1.f-v)<0.f) // first root bad
{
qu = d3.x*yy - d3.y*xx + dd - s;
qv = d3.y*xx - d3.x*yy + dd - s;
u = v = -1.f;
if(qu && qv)
{
u = 2.f*(d2.y*xx - d2.x*yy)/qu;
v = 2.f*(d1.x*yy - d1.y*xx)/qv;
}
if(u*(1.f-u)<0.f || v*(1.f-v)<0.f) return; // second root bad
}
mglPnt p(p1+d1*u+d2*v+d3*(u*v));
if(mgl_isnan(p.u) && mgl_isnum(p.v))
{
mglPoint n1(mglPoint(p2.x-p1.x,p2.y-p1.y,p2.z-p1.z)^mglPoint(p3.x-p1.x,p3.y-p1.y,p3.z-p1.z));
mglPoint n2(mglPoint(p2.x-p4.x,p2.y-p4.y,p2.z-p4.z)^mglPoint(p3.x-p4.x,p3.y-p4.y,p3.z-p4.z));
p.u = (n1.x+n2.x)*0.5;
p.v = (n1.y+n2.y)*0.5;
p.w = (n1.z+n2.z)*0.5;
}
unsigned char r[4]; col2int(p,r,d->ObjId);
if(r[3]) pnt_plot(i,j,p.z,r,d->ObjId);
}
//-----------------------------------------------------------------------------
mglCanvas::mglCanvas(int w, int h) : mglBase()
{
clr(MGL_DISABLE_SCALE);
set(MGL_VECT_FRAME); // NOTE: require a lot of memory!
Z=0; C=G=G4=GB=0; OI=0; gif=0;
CurFrameId=0; Delay=0.5;
Width=Height=Depth=0; ObjId=-1;
fscl=ftet=0; PlotId = "frame";
pnt_col = 0;
ac.ch='c';
ax.dir = mglPoint(1,0,0); ax.a = mglPoint(0,1,0); ax.b = mglPoint(0,0,1); ax.ch='x';
ay.dir = mglPoint(0,1,0); ay.a = mglPoint(1,0,0); ay.b = mglPoint(0,0,1); ay.ch='y';
az.dir = mglPoint(0,0,1); az.a = mglPoint(0,1,0); az.b = mglPoint(1,0,0); az.ch='z';
SetSize(w,h); SetQuality(MGL_DRAW_NORM); DefaultPlotParam();
}
void mglCanvas::DefaultPlotParam()
{
/* NOTE: following variables and mutex will not be changed by DefaultPlotParam()
long InUse; ///< Smart pointer (number of users)
mglFont *fnt; ///< Class for printing vector text
int Quality; ///< Quality of plot (0x0-pure, 0x1-fast; 0x2-fine; 0x4 - low memory)
int Width; ///< Width of the image
int Height; ///< Height of the image
int Depth; ///< Depth of the image
int CurFrameId; ///< Number of automaticle created frames
GifFileType *gif;*/
SetDrawReg(1,1,0); Perspective(0);
memcpy(mgl_mask_val, mgl_mask_def, 16*sizeof(uint64_t)); // should be > 16*8
ax.Clear(); ay.Clear(); az.Clear(); ac.Clear();
mgl_clear_fft(); DefMaskAn=0; ResetMask();
SetTickRotate(true); SetTickSkip(true);
SetWarn(mglWarnNone,""); mglGlobalMess = "";
ObjId = -1; HighId = INT_MIN;
SetFunc(0,0); CutOff(0); Ternary(0);
Stop=false; event_cb = NULL; event_par=NULL;
SetRanges(mglPoint(-1,-1,-1,-1), mglPoint(1,1,1,1));
SetOrigin(NAN,NAN,NAN,NAN);
SetBarWidth(0.7); SetMarkSize(1); SetArrowSize(1);
SetAlphaDef(0.5); FontDef[0]=0;
SetTranspType(0); SetMeshNum(0); // NOTE: default MeshNum=0
SetRotatedText(true); CurrPal = 0;
SetLegendMarks(); SetFontSize(4);
SetTuneTicks(3); SetAmbient(); SetDiffuse();
clr(MGL_DISABLE_SCALE);
clr(MGL_USE_GMTIME); clr(MGL_NOSUBTICKS);
SetDifLight(false); SetReduceAcc(false);
SetDefScheme(MGL_DEF_SCH); SetPalette(MGL_DEF_PAL);
SetPenPal("k-1"); Alpha(false);
stack.clear(); Restore(); DefColor('k');
SetPlotFactor(0); InPlot(0,1,0,1,false);
SetTickLen(0); SetCut(true);
AdjustTicks("xyzc",true); Clf('w');
for(int i=0;i<10;i++) { AddLight(i, mglPoint(0,0,1)); Light(i,false); }
Light(0,true); Light(false); SetDifLight(true);
}
//-----------------------------------------------------------------------------
int static mgls_zoomaxis(mglGraph *gr, long , mglArg *a, const char *k, const char *)
{
int res=0;
if(!strcmp(k,"nn")) gr->ZoomAxis(mglPoint(a[0].v), mglPoint(a[1].v));
else if(!strcmp(k,"nnnn")) gr->ZoomAxis(mglPoint(a[0].v, a[1].v), mglPoint(a[2].v, a[3].v));
else if(!strcmp(k,"nnnnnn")) gr->ZoomAxis(mglPoint(a[0].v, a[1].v, a[2].v), mglPoint(a[3].v, a[4].v, a[5].v));
else if(!strcmp(k,"nnnnnnnn")) gr->ZoomAxis(mglPoint(a[0].v, a[1].v, a[2].v, a[3].v), mglPoint(a[4].v, a[5].v, a[6].v, a[7].v));
else res = 1;
return res;
}
//-----------------------------------------------------------------------------
std::vector<mglSegment> MGL_NO_EXPORT mgl_tri_lines(mreal val, HCDT nums, HCDT a, HCDT x, HCDT y, HCDT z)
{
long n = x->GetNx(), m = nums->GetNy();
std::vector<mglSegment> lines;
for(long i=0;i<m;i++)
{
register long k1 = long(nums->v(0,i)+0.1); if(k1<0 || k1>=n) continue;
register long k2 = long(nums->v(1,i)+0.1); if(k2<0 || k2>=n) continue;
register long k3 = long(nums->v(2,i)+0.1); if(k3<0 || k3>=n) continue;
register mreal v1 = a->v(k1), v2 = a->v(k2), v3 = a->v(k3);
register mreal d1 = mgl_d(val,v1,v2), d2 = mgl_d(val,v1,v3), d3 = mgl_d(val,v2,v3);
mglSegment line;
if(d1>=0 && d1<=1 && d2>=0 && d2<=1)
{
line.p1 = mglPoint(x->v(k1)*(1-d1)+x->v(k2)*d1, y->v(k1)*(1-d1)+y->v(k2)*d1, z->v(k1)*(1-d1)+z->v(k2)*d1);
line.p2 = mglPoint(x->v(k1)*(1-d2)+x->v(k3)*d2, y->v(k1)*(1-d2)+y->v(k3)*d2, z->v(k1)*(1-d2)+z->v(k3)*d2);
}
else if(d1>=0 && d1<=1 && d3>=0 && d3<=1)
{
line.p1 = mglPoint(x->v(k1)*(1-d1)+x->v(k2)*d1, y->v(k1)*(1-d1)+y->v(k2)*d1, z->v(k1)*(1-d1)+z->v(k2)*d1);
line.p2 = mglPoint(x->v(k2)*(1-d3)+x->v(k3)*d3, y->v(k2)*(1-d3)+y->v(k3)*d3, z->v(k2)*(1-d3)+z->v(k3)*d3);
}
else if(d3>=0 && d3<=1 && d2>=0 && d2<=1)
{
line.p1 = mglPoint(x->v(k1)*(1-d2)+x->v(k3)*d2, y->v(k1)*(1-d2)+y->v(k3)*d2, z->v(k1)*(1-d2)+z->v(k3)*d2);
line.p2 = mglPoint(x->v(k2)*(1-d3)+x->v(k3)*d3, y->v(k2)*(1-d3)+y->v(k3)*d3, z->v(k2)*(1-d3)+z->v(k3)*d3);
}
if(line.p1!=line.p2) lines.push_back(line);
}
return lines;
}
//-----------------------------------------------------------------------------
// Optimal axis position
//-----------------------------------------------------------------------------
mreal mglCanvas::FindOptOrg(char dir, int ind) const
{
static mglPoint px, py, pz;
static mglMatrix bb;
mglPoint nn[8]={mglPoint(0,0,0), mglPoint(0,0,1), mglPoint(0,1,0,0), mglPoint(0,1,1),
mglPoint(1,0,0), mglPoint(1,0,1), mglPoint(1,1,0), mglPoint(1,1,1)}, pp[8];
memcpy(pp, nn, 8*sizeof(mglPoint));
// do nothing if transformation matrix is the same
if(B!=bb)
{
bb = B;
for(long i=0;i<8;i++) PostScale(&B,pp[i]);
// find point with minimal y
long j=0;
for(long i=1;i<8;i++) if(pp[i].y<pp[j].y) j=i;
pp[0]=pp[j];
// first select 3 closest points
pp[1].x=1-nn[j].x; pp[1].y=nn[j].y; pp[1].z=nn[j].z; PostScale(&B,pp[1]); pp[1]-=pp[0];
pp[2].x=nn[j].x; pp[2].y=1-nn[j].y; pp[2].z=nn[j].z; PostScale(&B,pp[2]); pp[2]-=pp[0];
pp[3].x=nn[j].x; pp[3].y=nn[j].y; pp[3].z=1-nn[j].z; PostScale(&B,pp[3]); pp[3]-=pp[0];
// find cosine of axis projection
register mreal tx=fabs(pp[1].x/pp[1].y), ty=fabs(pp[2].x/pp[2].y), tz=fabs(pp[3].x/pp[3].y);
px=py=pz=nn[j];
if(tz==0 && (ty==0 || tx==0)) // (x- & z-) or (y- & z-) axis are vertical
{ if(pp[1].x>pp[2].x) pz.y=1-pz.y; else pz.x=1-pz.x; }
else if(tx==0 && ty==0) // x- && y-axis is vertical
{
py.x=1-py.x;
if(pp[1].x>pp[3].x)
{ px.z=1-px.z; py.z=1-py.z; }
}
else if(tz<tx && tz<ty) // z-axis is vertical
{ if(pp[1].x>pp[2].x) pz.y=1-pz.y; else pz.x=1-pz.x; }
else if(ty<tx && ty<tz) // y-axis is vertical
{ if(pp[1].x>pp[3].x) py.z=1-py.z; else py.x=1-py.x; }
else if(tx<ty && tx<tz) // x-axis is vertical
{ if(pp[3].x>pp[2].x) px.y=1-px.y; else px.z=1-px.z; }
}
// return to normal variables
mglPoint rx = Min+(Max-Min)/px;
mglPoint ry = Min+(Max-Min)/py;
mglPoint rz = Min+(Max-Min)/pz;
mreal res = rx.val(ind);
if(dir=='y') res = ry.val(ind);
if(dir=='z') res = rz.val(ind);
return res;
}
//-----------------------------------------------------------------------------
int main(int argc,char **argv)
{
#ifdef PTHREAD_SAMPLE
mglGraphFLTK gr;
gr.Window(argc,argv,NULL,"test",0,0); // create window
gr.ClfOnUpdate = false;
static pthread_t tmp;
pthread_create(&tmp, 0, mgl_fltk_tmp, 0);
pthread_detach(tmp); // run window handling in the separate thread
for(int i=0;i<10;i++) // do calculation
{
sleep(2); // which can be very long
pnt = mglPoint(2*mgl_rnd()-1,2*mgl_rnd()-1);
gr.Clf(); // make new drawing
gr.Line(mglPoint(),pnt,"Ar2");
char str[10] = "i=0"; str[3] = '0'+i;
gr.Text(mglPoint(),"");
gr.Update(); // update window
}
return 0; // finish calculations and close the window*/
#else
mglGraphFLTK gr;
char key = 0;
if(argc>1 && argv[1][0]!='-') key = argv[1][0];
else printf("You may specify argument '1', '2', '3' or 'd' for viewing examples of 1d, 2d, 3d or dual plotting\n");
switch(key)
{
case '1': gr.Window(argc,argv,sample_1,"1D plots"); break;
case '2': gr.Window(argc,argv,sample_2,"2D plots"); break;
case '3': gr.Window(argc,argv,sample_3,"3D plots"); break;
case 'd': gr.Window(argc,argv,sample_d,"Dual plots"); break;
case 't': gr.Window(argc,argv,test,"Testing"); break;
default: gr.Window(argc,argv,sample,"Example of molecules"); break;
}
return mglFlRun();
#endif
}
HMDT MGL_EXPORT mgl_triangulation_3d(HCDT x, HCDT y, HCDT z)
{
mglData *nums=0;
long n = x->GetNx(), m;
if(y->GetNx()!=n || z->GetNx()!=n) return nums;
mglPoint *pp = new mglPoint[n];
long *nn=0;
for(long i=0;i<n;i++) pp[i] = mglPoint(x->v(i), y->v(i), z->v(i));
m = mgl_crust(n,pp,&nn,0);
if(m>0)
{
nums=new mglData(3,m);
for(long i=0;i<3*m;i++) nums->a[i]=nn[i];
}
delete []pp; free(nn); return nums;
}
//-----------------------------------------------------------------------------
void StyleDialog::updatePic()
{
static mglGraph gr(0,128,30);
static bool f = true;
mglData x(3), y(3), a(32,2);
x.Fill(-1,1); a.Fill(-1,1);
if(!f) gr.Clf();
if(f)
{
gr.SubPlot(1,1,0,"");
gr.SetMarkSize(15);
gr.SetArrowSize(20);
f = false;
}
result = "";
int i,j;
QString col="wbgrcmylenuqphkWBGRCMYLENUQPH", mrk=".+x*sdv^<>o.*+xsdv^<>o", dsh="|;=ji: ", arw="AVIKTSDO", s;
QString msk="-+=;oOsS~<>jdD*^", dir="/\\I";
switch(tab->currentIndex())
{
case 0: // line style
i = a2->currentIndex(); if(i>0) result += arw[i-1];
j = a1->currentIndex(); if(j>0)
{
if(i==0) result += '_';
result += arw[j-1];
}
i = dash->currentIndex();
if(i>0 && i<8) result += dsh[i-1];
else if(i==8) // manual
{
int d=0;
for(int i=0;i<16;i++) if(dash_bit[i]->isChecked()) d += 1<<i;
result += "{d"+QString::number(d,16)+"}";
}
i = mark->currentIndex(); if(i>0) result += mrk[i-1];
if(i>11) result += '#';
i = cline->currentIndex();
if(i>0)
{
j = nline->value();
if(j!=5) result += "{"+col[i-1]+char('0'+j)+"}";
else result += col[i-1];
}
i = width->value(); if(i>1) result += char('0'+i);
gr.Plot(x,y,result.toLocal8Bit().constData());
break;
case 1: // color sceheme
case 3: // manual mask
for(j=0;j<7;j++)
{
i = cc[j]->currentIndex();
if(i<1) break;
QCharRef c = col[i-1];
i = nn[j]->value();
if(i!=5) result += "{"+c+char('0'+i)+"}";
else result += c;
}
if(swire->isChecked()) result += '#';
i = ctext->currentIndex();
if(i==1) result += 't';
if(i==2) result += 'T';
i = mask->currentIndex();
if(i>0 && i<17)
{
result += msk[i-1];
i = angle->currentIndex();
if(i>0) result += dir[i-1];
i = msize->value();
if(i>1) result += char('0'+i);
}
else if(i==17)
{
uint64_t t=0;
for(int j=0;j<64;j++) if(mask_bit[j]->isChecked()) t += uint64_t(1)<<j;
result += "{s"+QString::number(t,16)+"}";
// TODO get hex-mask
i = angle->currentIndex();
if(i>0) result += dir[i-1];
i = msize->value();
if(i>1) result += char('0'+i);
}
i = axial->currentIndex();
if(i>0) result = result+':'+char('x'+i-1);
gr.Surf(a,result.toLocal8Bit().constData());
break;
case 2: // text style
if(font_sch->isChecked()) for(j=0;j<7;j++)
{
i = cc[j]->currentIndex();
if(i<1) break;
QCharRef c = col[i-1];
i = nn[j]->value();
if(i!=5) result += "{"+c+char('0'+i)+"}";
else result += c;
}
else
{
i = cfont->currentIndex();
if(i>1) result += col[i-1];
}
result += ':';
if(bold->isChecked()) result += 'b';
if(ital->isChecked()) result += 'i';
if(wire->isChecked()) result += 'w';
if(uline->isChecked()) result += 'u';
if(oline->isChecked()) result += 'o';
if(rbL->isChecked()) result += 'L';
if(rbC->isChecked()) result += 'C';
if(rbR->isChecked()) result += 'R';
gr.Puts(mglPoint(0,-0.5),"Font test",result.toLocal8Bit().constData(),-10);
break;
}
result = "'" + result + "'";
res->setText(result);
QPixmap p;
convertFromGraph(p, &gr, &grBuf);
pic->setPixmap(p);
}
//-----------------------------------------------------------------------------
void _mgl_key_up(unsigned char ch,int ,int )
{
if(!_mgl_glwnd) return;
static bool Alpha=false;
static bool Light=false;
static mreal rL=3,tL=0,pL=0;
if(ch=='h')
{
printf("Use 'a', 'd', 'w', 's', 'q', 'e' for changing view angles\n");
printf("Use 'j', 'l', 'i', 'k' for changing light angles\n");
printf("Use 'u', 'o' for changing distance to light\n");
printf("Use 'r' for switching transparency\n");
printf("Use 'f' for switching lightning\n");
printf("Use 'T' for exporting to TIFF file\n");
printf("Use 'J' for exporting to JPEG file\n");
printf("Use 'P' for exporting to PNG file\n");
printf("Use ',', '.' for show other frames\n");
printf("Use 'm' for view movie\n");
printf("Use 'h' for view this text\n");
printf("Use 'x' for exit\n");
}
if(ch=='w') _mgl_glwnd->View(-10,0,0);
if(ch=='s') _mgl_glwnd->View(10,0,0);
if(ch=='a') _mgl_glwnd->View(0,-10,0);
if(ch=='d') _mgl_glwnd->View(0,10,0);
if(ch=='q') _mgl_glwnd->View(0,0,-10);
if(ch=='e') _mgl_glwnd->View(0,0,10);
if(ch=='n') _mgl_glwnd->Identity();
if(ch==',')
_mgl_glwnd->curr_fig = _mgl_glwnd->curr_fig == 1 ? _mgl_glwnd->NumFig : _mgl_glwnd->curr_fig-1;
if(ch=='.')
_mgl_glwnd->curr_fig = _mgl_glwnd->curr_fig == _mgl_glwnd->NumFig ? 1 : _mgl_glwnd->curr_fig+1;
if(ch=='r') Alpha = !Alpha;
if(ch=='f') Light = !Light;
if(ch=='u') rL += 0.1;
if(ch=='o') rL -= 0.1;
if(ch=='i') tL += M_PI*0.1;
if(ch=='k') tL -= M_PI*0.1;
if(ch=='l') pL += 2*M_PI*0.1;
if(ch=='j') pL -= 2*M_PI*0.1;
if(ch=='[' && _mgl_glwnd->LoadFunc)
{
glDeleteLists(1,_mgl_glwnd->NumFig);
_mgl_glwnd->LoadFunc(false, 0);
(_mgl_glwnd->DrawFunc)(_mgl_glwnd,_mgl_glwnd->FuncPar);
_mgl_glwnd->Finish();
}
if(ch==']' && _mgl_glwnd->LoadFunc)
{
glDeleteLists(1,_mgl_glwnd->NumFig);
_mgl_glwnd->LoadFunc(true, 0);
(_mgl_glwnd->DrawFunc)(_mgl_glwnd,_mgl_glwnd->FuncPar);
_mgl_glwnd->Finish();
}
if(ch=='P')
{
char str[128];
sprintf(str,"%s_%d.png",_mgl_glwnd->PlotId,_mgl_glwnd->curr_fig);
_mgl_glwnd->WritePNG(str, "Math GL");
}
if(ch=='J')
{
char str[128];
sprintf(str,"%s_%d.jpg",_mgl_glwnd->PlotId,_mgl_glwnd->curr_fig);
_mgl_glwnd->WriteJPEG(str, "Math GL");
}
if(ch=='E')
{
char str[128];
sprintf(str,"%s_%d.eps",_mgl_glwnd->PlotId,_mgl_glwnd->curr_fig);
_mgl_glwnd->WriteEPS(str, "Math GL");
}
if(ch==' ') _mgl_glwnd->Clf();
if(ch=='m') _mgl_glwnd->tt = 1-_mgl_glwnd->tt;
rL = rL<0 ? 0 : (rL>5 ? 5 : rL);
_mgl_glwnd->Light(0,mglPoint(rL*cos(pL)*sin(tL), rL*sin(pL)*sin(tL), rL*cos(tL)),false);
_mgl_glwnd->Alpha(Alpha);
_mgl_glwnd->Light(Light);
// glEnable(GL_BLEND);
if(strchr("ijkl",ch))
printf("Light: %g, %g, %g\n",rL*cos(pL)*sin(tL), rL*sin(pL)*sin(tL), rL*cos(tL));
if(ch=='x') exit(0);
else glutPostRedisplay();
}
//-----------------------------------------------------------------------------
//
// TriPlot series
//
//-----------------------------------------------------------------------------
void MGL_EXPORT mgl_triplot_xyzc(HMGL gr, HCDT nums, HCDT x, HCDT y, HCDT z, HCDT a, const char *sch, const char *opt)
{
long n = x->GetNx(), m = nums->GetNy();
if(mgl_check_trig(gr,nums,x,y,z,a,"TriPlot")) return;
long ss=gr->AddTexture(sch);
gr->SaveState(opt); gr->SetPenPal("-");
static int cgid=1; gr->StartGroup("TriPlot",cgid++);
bool wire = mglchr(sch,'#');
long nc = a->GetNx();
if(nc!=n && nc>=m) // colors per triangle
{
mglPoint p1,p2,p3,q;
gr->Reserve(m*3);
for(long i=0;i<m;i++)
{
register long k1 = long(nums->v(0,i)+0.5);
p1 = mglPoint(x->v(k1), y->v(k1), z->v(k1));
register long k2 = long(nums->v(1,i)+0.5);
p2 = mglPoint(x->v(k2), y->v(k2), z->v(k2));
register long k3 = long(nums->v(2,i)+0.5);
p3 = mglPoint(x->v(k3), y->v(k3), z->v(k3));
q = wire ? mglPoint(NAN,NAN) : (p2-p1) ^ (p3-p1);
k1 = gr->AddPnt(p1,gr->GetC(ss,a->v(k1)),q);
k2 = gr->AddPnt(p2,gr->GetC(ss,a->v(k2)),q);
k3 = gr->AddPnt(p3,gr->GetC(ss,a->v(k3)),q);
gr->trig_plot(k1,k2,k3);
}
}
else if(nc>=n) // colors per point
{
gr->Reserve(n);
long *kk = new long[n];
mglPoint *pp = new mglPoint[n];
for(long i=0;i<m;i++) // add averaged normales
{
register long k1 = long(nums->v(0,i)+0.5);
register long k2 = long(nums->v(1,i)+0.5);
register long k3 = long(nums->v(2,i)+0.5);
if(!wire)
{
mglPoint q = mglPoint(x->v(k2)-x->v(k1), y->v(k2)-y->v(k1), z->v(k2)-z->v(k1)) ^
mglPoint(x->v(k3)-x->v(k1), y->v(k3)-y->v(k1), z->v(k3)-z->v(k1));
q.Normalize();
// try be sure that in the same direction ...
if(q.z<0) q *= -1;
pp[k1] += q; pp[k2] += q; pp[k3] += q;
}
else pp[k1]=pp[k2]=pp[k3]=mglPoint(NAN,NAN);
}
for(long i=0;i<n;i++) // add points
kk[i] = gr->AddPnt(mglPoint(x->v(i), y->v(i), z->v(i)), gr->GetC(ss,a->v(i)), pp[i]);
for(long i=0;i<m;i++) // draw triangles
{
register long k1 = long(nums->v(0,i)+0.5);
register long k2 = long(nums->v(1,i)+0.5);
register long k3 = long(nums->v(2,i)+0.5);
if(wire)
{
gr->line_plot(kk[k1],kk[k2]); gr->line_plot(kk[k1],kk[k3]);
gr->line_plot(kk[k3],kk[k2]);
}
else gr->trig_plot(kk[k1],kk[k2],kk[k3]);
}
delete []kk; delete []pp;
}
gr->EndGroup();
}
int Foo::Draw(mglGraph *gr)
{
gr->Line(mglPoint(),pnt,"Ar2");
gr->Box();
return 0;
}
//-----------------------------------------------------------------------------
int static mgls_light(mglGraph *gr, long , mglArg *a, const char *k, const char *)
{
int res=0;
if(k[0]==0) gr->Light(true);
else if(!strcmp(k,"n")) gr->Light(a[0].v!=0);
else if(!strcmp(k,"nn")) gr->Light(mgl_int(a[0].v),a[1].v!=0);
else if(!strcmp(k,"nnnn")) gr->AddLight(mgl_int(a[0].v),mglPoint(a[1].v,a[2].v,a[3].v));
else if(!strcmp(k,"nnnns")) gr->AddLight(mgl_int(a[0].v),mglPoint(a[1].v,a[2].v,a[3].v), a[4].s.s[0]);
else if(!strcmp(k,"nnnnsn"))gr->AddLight(mgl_int(a[0].v),mglPoint(a[1].v,a[2].v,a[3].v), a[4].s.s[0],a[5].v);
else if(!strcmp(k,"nnnnsnn"))
gr->AddLight(mgl_int(a[0].v), mglPoint(a[1].v,a[2].v,a[3].v), a[4].s.s[0],a[5].v,a[6].v);
else if(!strcmp(k,"nnnnnnn"))
gr->AddLight(mgl_int(a[0].v), mglPoint(a[1].v,a[2].v,a[3].v), mglPoint(a[4].v,a[5].v,a[6].v));
else if(!strcmp(k,"nnnnnnns"))
gr->AddLight(mgl_int(a[0].v), mglPoint(a[1].v,a[2].v,a[3].v), mglPoint(a[4].v,a[5].v,a[6].v), a[7].s.s[0]);
else if(!strcmp(k,"nnnnnnnsn"))
gr->AddLight(mgl_int(a[0].v), mglPoint(a[1].v,a[2].v,a[3].v), mglPoint(a[4].v,a[5].v,a[6].v), a[7].s.s[0],a[8].v);
else if(!strcmp(k,"nnnnnnnsnn"))
gr->AddLight(mgl_int(a[0].v), mglPoint(a[1].v,a[2].v,a[3].v), mglPoint(a[4].v,a[5].v,a[6].v), a[7].s.s[0],a[8].v,a[9].v);
return res;
}
