netgen/libsrc/meshing/meshing2.cpp
2009-09-22 07:12:00 +00:00

1893 lines
43 KiB
C++

#include <mystdlib.h>
#include "meshing.hpp"
namespace netgen
{
static void glrender (int wait);
// global variable for visualization
static Array<Point3d> locpoints;
static Array<int> legalpoints;
static Array<Point2d> plainpoints;
static Array<int> plainzones;
static Array<INDEX_2> loclines;
// static int geomtrig;
//static const char * rname;
static int cntelem, trials, nfaces;
static int oldnl;
static int qualclass;
Meshing2 :: Meshing2 (const Box<3> & aboundingbox)
{
boundingbox = aboundingbox;
LoadRules (NULL);
// LoadRules ("rules/quad.rls");
// LoadRules ("rules/triangle.rls");
adfront = new AdFront2(boundingbox);
starttime = GetTime();
maxarea = -1;
}
Meshing2 :: ~Meshing2 ()
{
delete adfront;
for (int i = 0; i < rules.Size(); i++)
delete rules[i];
}
void Meshing2 :: AddPoint (const Point3d & p, PointIndex globind,
MultiPointGeomInfo * mgi,
bool pointonsurface)
{
//(*testout) << "add point " << globind << endl;
adfront ->AddPoint (p, globind, mgi, pointonsurface);
}
void Meshing2 :: AddBoundaryElement (int i1, int i2,
const PointGeomInfo & gi1, const PointGeomInfo & gi2)
{
// (*testout) << "add line " << i1 << " - " << i2 << endl;
if (!gi1.trignum || !gi2.trignum)
{
PrintSysError ("addboundaryelement: illegal geominfo");
}
adfront -> AddLine (i1-1, i2-1, gi1, gi2);
}
void Meshing2 :: StartMesh ()
{
foundmap.SetSize (rules.Size());
canuse.SetSize (rules.Size());
ruleused.SetSize (rules.Size());
foundmap = 0;
canuse = 0;
ruleused = 0;
cntelem = 0;
trials = 0;
}
void Meshing2 :: EndMesh ()
{
for (int i = 0; i < ruleused.Size(); i++)
(*testout) << setw(4) << ruleused[i]
<< " times used rule " << rules[i] -> Name() << endl;
}
void Meshing2 :: SetStartTime (double astarttime)
{
starttime = astarttime;
}
void Meshing2 :: SetMaxArea (double amaxarea)
{
maxarea = amaxarea;
}
double Meshing2 :: CalcLocalH (const Point3d & /* p */, double gh) const
{
return gh;
}
// should be class variables !!(?)
static Vec3d ex, ey;
static Point3d globp1;
void Meshing2 :: DefineTransformation (const Point3d & p1, const Point3d & p2,
const PointGeomInfo * geominfo1,
const PointGeomInfo * geominfo2)
{
globp1 = p1;
ex = p2 - p1;
ex /= ex.Length();
ey.X() = -ex.Y();
ey.Y() = ex.X();
ey.Z() = 0;
}
void Meshing2 :: TransformToPlain (const Point3d & locpoint,
const MultiPointGeomInfo & geominf,
Point2d & plainpoint, double h, int & zone)
{
Vec3d p1p (globp1, locpoint);
// p1p = locpoint - globp1;
p1p /= h;
plainpoint.X() = p1p * ex;
plainpoint.Y() = p1p * ey;
zone = 0;
}
int Meshing2 :: TransformFromPlain (Point2d & plainpoint,
Point3d & locpoint,
PointGeomInfo & gi,
double h)
{
Vec3d p1p;
gi.trignum = 1;
p1p = plainpoint.X() * ex + plainpoint.Y() * ey;
p1p *= h;
locpoint = globp1 + p1p;
return 0;
}
int Meshing2 :: BelongsToActiveChart (const Point3d & p,
const PointGeomInfo & gi)
{
return 1;
}
int Meshing2 :: ComputePointGeomInfo (const Point3d & p, PointGeomInfo & gi)
{
gi.trignum = 1;
return 0;
}
int Meshing2 :: ChooseChartPointGeomInfo (const MultiPointGeomInfo & mpgi,
PointGeomInfo & pgi)
{
pgi = mpgi.GetPGI(1);
return 0;
}
int Meshing2 ::
IsLineVertexOnChart (const Point3d & p1, const Point3d & p2,
int endpoint, const PointGeomInfo & geominfo)
{
return 1;
}
void Meshing2 ::
GetChartBoundary (Array<Point2d> & points,
Array<Point3d> & points3d,
Array<INDEX_2> & lines, double h) const
{
points.SetSize (0);
points3d.SetSize (0);
lines.SetSize (0);
}
double Meshing2 :: Area () const
{
return -1;
}
MESHING2_RESULT Meshing2 :: GenerateMesh (Mesh & mesh, double gh, int facenr)
{
Array<int> pindex, lindex;
Array<int> delpoints, dellines;
Array<PointGeomInfo> upgeominfo; // unique info
Array<MultiPointGeomInfo> mpgeominfo; // multiple info
Array<Element2d> locelements;
int z1, z2, oldnp(-1);
SurfaceElementIndex sei;
bool found;
int rulenr(-1);
int globind;
Point<3> p1, p2;
const PointGeomInfo * blgeominfo1;
const PointGeomInfo * blgeominfo2;
bool morerisc;
bool debugflag;
double h, his, hshould;
// test for 3d overlaps
Box3dTree surfeltree (boundingbox.PMin(),
boundingbox.PMax());
Array<int> intersecttrias;
Array<Point3d> critpoints;
// test for doubled edges
//INDEX_2_HASHTABLE<int> doubleedge(300000);
testmode = 0;
StartMesh();
Array<Point2d> chartboundpoints;
Array<Point3d> chartboundpoints3d;
Array<INDEX_2> chartboundlines;
// illegal points: points with more then 50 elements per node
int maxlegalpoint(-1), maxlegalline(-1);
Array<int,PointIndex::BASE> trigsonnode;
Array<int,PointIndex::BASE> illegalpoint;
trigsonnode.SetSize (mesh.GetNP());
illegalpoint.SetSize (mesh.GetNP());
trigsonnode = 0;
illegalpoint = 0;
double totalarea = Area ();
double meshedarea = 0;
// search tree for surface elements:
for (sei = 0; sei < mesh.GetNSE(); sei++)
{
const Element2d & sel = mesh[sei];
if (sel.IsDeleted()) continue;
if (sel.GetIndex() == facenr)
{
Box<3> box;
box.Set ( mesh[sel[0]] );
box.Add ( mesh[sel[1]] );
box.Add ( mesh[sel[2]] );
surfeltree.Insert (box, sei);
}
double trigarea = Cross ( mesh[sel[1]]-mesh[sel[0]],
mesh[sel[2]]-mesh[sel[0]] ).Length() / 2;
if (sel.GetNP() == 4)
trigarea += Cross (Vec3d (mesh.Point (sel.PNum(1)),
mesh.Point (sel.PNum(3))),
Vec3d (mesh.Point (sel.PNum(1)),
mesh.Point (sel.PNum(4)))).Length() / 2;;
meshedarea += trigarea;
}
const char * savetask = multithread.task;
multithread.task = "Surface meshing";
adfront ->SetStartFront ();
int plotnexttrial = 999;
double meshedarea_before = meshedarea;
while (!adfront ->Empty() && !multithread.terminate)
{
if (multithread.terminate)
throw NgException ("Meshing stopped");
// known for STL meshing
if (totalarea > 0)
multithread.percent = 100 * meshedarea / totalarea;
/*
else
multithread.percent = 0;
*/
locpoints.SetSize(0);
loclines.SetSize(0);
pindex.SetSize(0);
lindex.SetSize(0);
delpoints.SetSize(0);
dellines.SetSize(0);
locelements.SetSize(0);
// plot statistics
if (trials > plotnexttrial)
{
PrintMessage (5,
"faces = ", nfaces,
" trials = ", trials,
" elements = ", mesh.GetNSE(),
" els/sec = ",
(mesh.GetNSE() / (GetTime() - starttime + 0.0001)));
plotnexttrial += 1000;
}
// unique-pgi, multi-pgi
upgeominfo.SetSize(0);
mpgeominfo.SetSize(0);
nfaces = adfront->GetNFL();
trials ++;
if (trials % 1000 == 0)
{
(*testout) << "\n";
for (int i = 1; i <= canuse.Size(); i++)
{
(*testout) << foundmap.Get(i) << "/"
<< canuse.Get(i) << "/"
<< ruleused.Get(i) << " map/can/use rule " << rules.Get(i)->Name() << "\n";
}
(*testout) << "\n";
}
int baselineindex = adfront -> SelectBaseLine (p1, p2, blgeominfo1, blgeominfo2, qualclass);
found = 1;
his = Dist (p1, p2);
Point3d pmid = Center (p1, p2);
hshould = CalcLocalH (pmid, mesh.GetH (pmid));
if (gh < hshould) hshould = gh;
mesh.RestrictLocalH (pmid, hshould);
h = hshould;
double hinner = (3 + qualclass) * max2 (his, hshould);
adfront ->GetLocals (baselineindex, locpoints, mpgeominfo, loclines,
pindex, lindex, 2*hinner);
//(*testout) << "h for locals: " << 2*hinner << endl;
//(*testout) << "locpoints " << locpoints << endl;
if (qualclass > mparam.giveuptol2d)
{
PrintMessage (3, "give up with qualclass ", qualclass);
PrintMessage (3, "number of frontlines = ", adfront->GetNFL());
// throw NgException ("Give up 2d meshing");
break;
}
/*
if (found && qualclass > 60)
{
found = 0;
}
*/
// morerisc = ((qualclass > 20) && (qualclass % 2 == 1));
// morerisc = 1;
morerisc = 0;
PointIndex gpi1 = adfront -> GetGlobalIndex (pindex.Get(loclines[0].I1()));
PointIndex gpi2 = adfront -> GetGlobalIndex (pindex.Get(loclines[0].I2()));
debugflag =
(
debugparam.haltsegment &&
( ((debugparam.haltsegmentp1 == gpi1) && (debugparam.haltsegmentp2 == gpi2)) ||
((debugparam.haltsegmentp1 == gpi2) && (debugparam.haltsegmentp2 == gpi1)))
)
||
(
debugparam.haltnode &&
( (debugparam.haltsegmentp1 == gpi1) || (debugparam.haltsegmentp2 == gpi1))
);
if (debugparam.haltface && debugparam.haltfacenr == facenr)
{
debugflag = 1;
cout << "set debugflag" << endl;
}
if (debugparam.haltlargequalclass && qualclass > 50)
debugflag = 1;
// problem recognition !
if (found &&
(gpi1 < illegalpoint.Size()+PointIndex::BASE) &&
(gpi2 < illegalpoint.Size()+PointIndex::BASE) )
{
if (illegalpoint[gpi1] || illegalpoint[gpi2])
found = 0;
}
Point2d p12d, p22d;
if (found)
{
oldnp = locpoints.Size();
oldnl = loclines.Size();
if (debugflag)
(*testout) << "define new transformation" << endl;
DefineTransformation (p1, p2, blgeominfo1, blgeominfo2);
plainpoints.SetSize (locpoints.Size());
plainzones.SetSize (locpoints.Size());
// (*testout) << endl;
// (*testout) << "3d->2d transformation" << endl;
for (int i = 1; i <= locpoints.Size(); i++)
{
// (*testout) << "pindex(i) = " << pindex[i-1] << endl;
TransformToPlain (locpoints.Get(i),
mpgeominfo.Get(i),
plainpoints.Elem(i), h, plainzones.Elem(i));
// (*testout) << mpgeominfo.Get(i).GetPGI(1).u << " " << mpgeominfo.Get(i).GetPGI(1).v << " ";
// (*testout) << plainpoints.Get(i).X() << " " << plainpoints.Get(i).Y() << endl;
//(*testout) << "transform " << locpoints.Get(i) << " to " << plainpoints.Get(i).X() << " " << plainpoints.Get(i).Y() << endl;
}
// (*testout) << endl << endl << endl;
p12d = plainpoints.Get(1);
p22d = plainpoints.Get(2);
/*
// last idea on friday
plainzones.Elem(1) = 0;
plainzones.Elem(2) = 0;
*/
/*
// old netgen:
for (i = 2; i <= loclines.Size(); i++) // don't remove first line
{
z1 = plainzones.Get(loclines.Get(i).I1());
z2 = plainzones.Get(loclines.Get(i).I2());
if (z1 && z2 && (z1 != z2) || (z1 == -1) || (z2 == -1) )
{
loclines.DeleteElement(i);
lindex.DeleteElement(i);
oldnl--;
i--;
}
}
// for (i = 1; i <= plainpoints.Size(); i++)
// if (plainzones.Elem(i) == -1)
// plainpoints.Elem(i) = Point2d (1e4, 1e4);
*/
for (int i = 2; i <= loclines.Size(); i++) // don't remove first line
{
// (*testout) << "loclines(i) = " << loclines.Get(i).I1() << " - " << loclines.Get(i).I2() << endl;
z1 = plainzones.Get(loclines.Get(i).I1());
z2 = plainzones.Get(loclines.Get(i).I2());
// one inner point, one outer
if ( (z1 >= 0) != (z2 >= 0))
{
int innerp = (z1 >= 0) ? 1 : 2;
if (IsLineVertexOnChart (locpoints.Get(loclines.Get(i).I1()),
locpoints.Get(loclines.Get(i).I2()),
innerp,
adfront->GetLineGeomInfo (lindex.Get(i), innerp)))
// pgeominfo.Get(loclines.Get(i).I(innerp))))
{
if (!morerisc)
{
// use one end of line
int pini, pouti;
Vec2d v;
pini = loclines.Get(i).I(innerp);
pouti = loclines.Get(i).I(3-innerp);
Point2d pin (plainpoints.Get(pini));
Point2d pout (plainpoints.Get(pouti));
v = pout - pin;
double len = v.Length();
if (len <= 1e-6)
(*testout) << "WARNING(js): inner-outer: short vector" << endl;
else
v /= len;
/*
// don't elongate line towards base-line !!
if (Vec2d (pin, p12d) * v > 0 &&
Vec2d (pin, p22d) * v > 0)
v *= -1;
*/
Point2d newpout = pin + 1000 * v;
newpout = pout;
plainpoints.Append (newpout);
Point3d pout3d = locpoints.Get(pouti);
locpoints.Append (pout3d);
plainzones.Append (0);
pindex.Append (-1);
oldnp++;
loclines.Elem(i).I(3-innerp) = oldnp;
}
else
plainzones.Elem(loclines.Get(i).I(3-innerp)) = 0;
// (*testout) << "inner - outer correction" << endl;
}
else
{
// remove line
loclines.DeleteElement(i);
lindex.DeleteElement(i);
oldnl--;
i--;
}
}
else if ( (z1 > 0 && z2 > 0 && (z1 != z2)) || ((z1 < 0) && (z2 < 0)) )
{
loclines.DeleteElement(i);
lindex.DeleteElement(i);
oldnl--;
i--;
}
}
legalpoints.SetSize(plainpoints.Size());
for (int i = 1; i <= legalpoints.Size(); i++)
legalpoints.Elem(i) = 1;
double avy = 0;
for (int i = 1; i <= plainpoints.Size(); i++)
avy += plainpoints.Elem(i).Y();
avy *= 1./plainpoints.Size();
for (int i = 1; i <= plainpoints.Size(); i++)
{
if (plainzones.Elem(i) < 0)
{
plainpoints.Elem(i) = Point2d (1e4, 1e4);
legalpoints.Elem(i) = 0;
}
if (pindex.Elem(i) == -1)
{
legalpoints.Elem(i) = 0;
}
if (plainpoints.Elem(i).Y() < -1e-10*avy) // changed
{
legalpoints.Elem(i) = 0;
}
}
/*
for (i = 3; i <= plainpoints.Size(); i++)
if (sqr (plainpoints.Get(i).X()) + sqr (plainpoints.Get(i).Y())
> sqr (2 + 0.2 * qualclass))
legalpoints.Elem(i) = 0;
*/
/*
int clp = 0;
for (i = 1; i <= plainpoints.Size(); i++)
if (legalpoints.Get(i))
clp++;
(*testout) << "legalpts: " << clp << "/" << plainpoints.Size() << endl;
// sort legal/illegal lines
int lastleg = 2;
int firstilleg = oldnl;
while (lastleg < firstilleg)
{
while (legalpoints.Get(loclines.Get(lastleg).I1()) &&
legalpoints.Get(loclines.Get(lastleg).I2()) &&
lastleg < firstilleg)
lastleg++;
while ( ( !legalpoints.Get(loclines.Get(firstilleg).I1()) ||
!legalpoints.Get(loclines.Get(firstilleg).I2())) &&
lastleg < firstilleg)
firstilleg--;
if (lastleg < firstilleg)
{
swap (loclines.Elem(lastleg), loclines.Elem(firstilleg));
swap (lindex.Elem(lastleg), lindex.Elem(firstilleg));
}
}
(*testout) << "leglines " << lastleg << "/" << oldnl << endl;
*/
GetChartBoundary (chartboundpoints,
chartboundpoints3d,
chartboundlines, h);
oldnp = plainpoints.Size();
maxlegalpoint = locpoints.Size();
maxlegalline = loclines.Size();
if (mparam.checkchartboundary)
{
for (int i = 1; i <= chartboundpoints.Size(); i++)
{
plainpoints.Append (chartboundpoints.Get(i));
locpoints.Append (chartboundpoints3d.Get(i));
legalpoints.Append (0);
}
for (int i = 1; i <= chartboundlines.Size(); i++)
{
INDEX_2 line (chartboundlines.Get(i).I1()+oldnp,
chartboundlines.Get(i).I2()+oldnp);
loclines.Append (line);
// (*testout) << "line: " << line.I1() << "-" << line.I2() << endl;
}
}
oldnl = loclines.Size();
oldnp = plainpoints.Size();
}
/*
if (qualclass > 100)
{
multithread.drawing = 1;
glrender(1);
cout << "qualclass 100, nfl = " << adfront->GetNFL() << endl;
}
*/
if (found)
{
rulenr = ApplyRules (plainpoints, legalpoints, maxlegalpoint,
loclines, maxlegalline, locelements,
dellines, qualclass);
// (*testout) << "Rule Nr = " << rulenr << endl;
if (!rulenr)
{
found = 0;
if ( debugflag || debugparam.haltnosuccess )
PrintWarning ("no rule found");
}
}
for (int i = 1; i <= locelements.Size() && found; i++)
{
const Element2d & el = locelements.Get(i);
for (int j = 1; j <= el.GetNP(); j++)
if (el.PNum(j) <= oldnp && pindex.Get(el.PNum(j)) == -1)
{
found = 0;
PrintSysError ("meshing2, index missing");
}
}
if (found)
{
locpoints.SetSize (plainpoints.Size());
upgeominfo.SetSize(locpoints.Size());
for (int i = oldnp+1; i <= plainpoints.Size(); i++)
{
int err =
TransformFromPlain (plainpoints.Elem(i), locpoints.Elem(i),
upgeominfo.Elem(i), h);
if (err)
{
found = 0;
if ( debugflag || debugparam.haltnosuccess )
PrintSysError ("meshing2, Backtransformation failed");
break;
}
}
}
// for (i = 1; i <= oldnl; i++)
// adfront -> ResetClass (lindex[i]);
/*
double violateminh;
if (qualclass <= 10)
violateminh = 3;
else
violateminh = 3 * qualclass;
if (uselocalh && found) // && qualclass <= 10)
{
for (i = 1; i <= locelements.Size(); i++)
{
Point3d pmin = locpoints.Get(locelements.Get(i).PNum(1));
Point3d pmax = pmin;
for (j = 2; j <= 3; j++)
{
const Point3d & hp =
locpoints.Get(locelements.Get(i).PNum(j));
pmin.SetToMin (hp);
pmax.SetToMax (hp);
}
double minh = mesh.GetMinH (pmin, pmax);
if (h > violateminh * minh)
{
found = 0;
loclines.SetSize (oldnl);
locpoints.SetSize (oldnp);
}
}
}
*/
if (found)
{
double violateminh = 3 + 0.1 * sqr (qualclass);
double minh = 1e8;
double newedgemaxh = 0;
for (int i = oldnl+1; i <= loclines.Size(); i++)
{
double eh = Dist (locpoints.Get(loclines.Get(i).I1()),
locpoints.Get(loclines.Get(i).I2()));
// Markus (brute force method to avoid bad elements on geometries like \_/ )
//if(eh > 4.*mesh.GetH(locpoints.Get(loclines.Get(i).I1()))) found = 0;
//if(eh > 4.*mesh.GetH(locpoints.Get(loclines.Get(i).I2()))) found = 0;
// Markus end
if (eh > newedgemaxh)
newedgemaxh = eh;
}
for (int i = 1; i <= locelements.Size(); i++)
{
Point3d pmin = locpoints.Get(locelements.Get(i).PNum(1));
Point3d pmax = pmin;
for (int j = 2; j <= locelements.Get(i).GetNP(); j++)
{
const Point3d & hp =
locpoints.Get(locelements.Get(i).PNum(j));
pmin.SetToMin (hp);
pmax.SetToMax (hp);
}
double eh = mesh.GetMinH (pmin, pmax);
if (eh < minh)
minh = eh;
}
for (int i = 1; i <= locelements.Size(); i++)
for (int j = 1; j <= locelements.Get(i).GetNP(); j++)
if (Dist2 (locpoints.Get(locelements.Get(i).PNum(j)), pmid) > hinner*hinner)
found = 0;
// cout << "violate = " << newedgemaxh / minh << endl;
static double maxviolate = 0;
if (newedgemaxh / minh > maxviolate)
{
maxviolate = newedgemaxh / minh;
// cout << "max minhviolate = " << maxviolate << endl;
}
if (newedgemaxh > violateminh * minh)
{
found = 0;
loclines.SetSize (oldnl);
locpoints.SetSize (oldnp);
if ( debugflag || debugparam.haltnosuccess )
PrintSysError ("meshing2, maxh too large");
}
}
/*
// test good ComputeLineGeoInfo
if (found)
{
// is line on chart ?
for (i = oldnl+1; i <= loclines.Size(); i++)
{
int gisize;
void *geominfo;
if (ComputeLineGeoInfo (locpoints.Get(loclines.Get(i).I1()),
locpoints.Get(loclines.Get(i).I2()),
gisize, geominfo))
found = 0;
}
}
*/
// changed for OCC meshing
if (found)
{
// take geominfo from dellines
// upgeominfo.SetSize(locpoints.Size());
/*
for (i = 1; i <= dellines.Size(); i++)
for (j = 1; j <= 2; j++)
{
upgeominfo.Elem(loclines.Get(dellines.Get(i)).I(j)) =
adfront -> GetLineGeomInfo (lindex.Get(dellines.Get(i)), j);
}
*/
for (int i = 1; i <= locelements.Size(); i++)
for (int j = 1; j <= locelements.Get(i).GetNP(); j++)
{
int pi = locelements.Get(i).PNum(j);
if (pi <= oldnp)
{
if (ChooseChartPointGeomInfo (mpgeominfo.Get(pi), upgeominfo.Elem(pi)))
{
// cannot select, compute new one
PrintWarning ("calc point geominfo instead of using");
if (ComputePointGeomInfo (locpoints.Get(pi), upgeominfo.Elem(pi)))
{
found = 0;
PrintSysError ("meshing2d, geominfo failed");
}
}
}
}
/*
// use upgeominfo from ProjectFromPlane
for (i = oldnp+1; i <= locpoints.Size(); i++)
{
if (ComputePointGeomInfo (locpoints.Get(i), upgeominfo.Elem(i)))
{
found = 0;
if ( debugflag || debugparam.haltnosuccess )
PrintSysError ("meshing2d, compute geominfo failed");
}
}
*/
}
if (found && mparam.checkoverlap)
{
// cout << "checkoverlap" << endl;
// test for overlaps
Point3d hullmin(1e10, 1e10, 1e10);
Point3d hullmax(-1e10, -1e10, -1e10);
for (int i = 1; i <= locelements.Size(); i++)
for (int j = 1; j <= locelements.Get(i).GetNP(); j++)
{
const Point3d & p = locpoints.Get(locelements.Get(i).PNum(j));
hullmin.SetToMin (p);
hullmax.SetToMax (p);
}
hullmin += Vec3d (-his, -his, -his);
hullmax += Vec3d ( his, his, his);
surfeltree.GetIntersecting (hullmin, hullmax, intersecttrias);
critpoints.SetSize (0);
for (int i = oldnp+1; i <= locpoints.Size(); i++)
critpoints.Append (locpoints.Get(i));
for (int i = 1; i <= locelements.Size(); i++)
{
const Element2d & tri = locelements.Get(i);
if (tri.GetNP() == 3)
{
const Point3d & tp1 = locpoints.Get(tri.PNum(1));
const Point3d & tp2 = locpoints.Get(tri.PNum(2));
const Point3d & tp3 = locpoints.Get(tri.PNum(3));
Vec3d tv1 (tp1, tp2);
Vec3d tv2 (tp1, tp3);
double lam1, lam2;
for (lam1 = 0.2; lam1 <= 0.8; lam1 += 0.2)
for (lam2 = 0.2; lam2 + lam1 <= 0.8; lam2 += 0.2)
{
Point3d hp = tp1 + lam1 * tv1 + lam2 * tv2;
critpoints.Append (hp);
}
}
else if (tri.GetNP() == 4)
{
const Point3d & tp1 = locpoints.Get(tri.PNum(1));
const Point3d & tp2 = locpoints.Get(tri.PNum(2));
const Point3d & tp3 = locpoints.Get(tri.PNum(3));
const Point3d & tp4 = locpoints.Get(tri.PNum(4));
double l1, l2;
for (l1 = 0.1; l1 <= 0.9; l1 += 0.1)
for (l2 = 0.1; l2 <= 0.9; l2 += 0.1)
{
Point3d hp;
hp.X() =
(1-l1)*(1-l2) * tp1.X() +
l1*(1-l2) * tp2.X() +
l1*l2 * tp3.X() +
(1-l1)*l2 * tp4.X();
hp.Y() =
(1-l1)*(1-l2) * tp1.Y() +
l1*(1-l2) * tp2.Y() +
l1*l2 * tp3.Y() +
(1-l1)*l2 * tp4.Y();
hp.Z() =
(1-l1)*(1-l2) * tp1.Z() +
l1*(1-l2) * tp2.Z() +
l1*l2 * tp3.Z() +
(1-l1)*l2 * tp4.Z();
critpoints.Append (hp);
}
}
}
/*
for (i = oldnl+1; i <= loclines.Size(); i++)
{
Point3d hp = locpoints.Get(loclines.Get(i).I1());
Vec3d hv(hp, locpoints.Get(loclines.Get(i).I2()));
int ncp = 2;
for (j = 1; j <= ncp; j++)
critpoints.Append ( hp + (double(j)/(ncp+1)) * hv);
}
*/
/*
for (i = oldnp+1; i <= locpoints.Size(); i++)
{
const Point3d & p = locpoints.Get(i);
*/
for (int i = 1; i <= critpoints.Size(); i++)
{
const Point3d & p = critpoints.Get(i);
/*
for (j = 1; j <= mesh.GetNSE(); j++)
{
*/
int jj;
for (jj = 1; jj <= intersecttrias.Size(); jj++)
{
int j = intersecttrias.Get(jj);
const Element2d & el = mesh.SurfaceElement(j);
int ntrig = (el.GetNP() == 3) ? 1 : 2;
int jl;
for (jl = 1; jl <= ntrig; jl++)
{
Point3d tp1, tp2, tp3;
if (jl == 1)
{
tp1 = mesh.Point(el.PNum(1));
tp2 = mesh.Point(el.PNum(2));
tp3 = mesh.Point(el.PNum(3));
}
else
{
tp1 = mesh.Point(el.PNum(1));
tp2 = mesh.Point(el.PNum(3));
tp3 = mesh.Point(el.PNum(4));
}
int onchart = 0;
for (int k = 1; k <= el.GetNP(); k++)
if (BelongsToActiveChart (mesh.Point(el.PNum(k)),
el.GeomInfoPi(k)))
onchart = 1;
if (!onchart)
continue;
Vec3d e1(tp1, tp2);
Vec3d e2(tp1, tp3);
Vec3d n = Cross (e1, e2);
n /= n.Length();
double lam1, lam2, lam3;
lam3 = n * Vec3d (tp1, p);
LocalCoordinates (e1, e2, Vec3d (tp1, p), lam1, lam2);
if (fabs (lam3) < 0.1 * hshould &&
lam1 > 0 && lam2 > 0 && (lam1 + lam2) < 1)
{
#ifdef DEVELOP
cout << "overlap" << endl;
(*testout) << "overlap:" << endl
<< "tri = " << tp1 << "-" << tp2 << "-" << tp3 << endl
<< "point = " << p << endl
<< "lam1, 2 = " << lam1 << ", " << lam2 << endl
<< "lam3 = " << lam3 << endl;
// cout << "overlap !!!" << endl;
#endif
for (int k = 1; k <= 5; k++)
adfront -> IncrementClass (lindex.Get(1));
found = 0;
if ( debugflag || debugparam.haltnosuccess )
PrintWarning ("overlapping");
if (debugparam.haltoverlap)
{
debugflag = 1;
}
/*
multithread.drawing = 1;
glrender(1);
*/
}
}
}
}
}
if (found)
{
// check, whether new front line already exists
for (int i = oldnl+1; i <= loclines.Size(); i++)
{
int nlgpi1 = loclines.Get(i).I1();
int nlgpi2 = loclines.Get(i).I2();
if (nlgpi1 <= pindex.Size() && nlgpi2 <= pindex.Size())
{
nlgpi1 = adfront->GetGlobalIndex (pindex.Get(nlgpi1));
nlgpi2 = adfront->GetGlobalIndex (pindex.Get(nlgpi2));
int exval = adfront->ExistsLine (nlgpi1, nlgpi2);
if (exval)
{
cout << "ERROR: new line exits, val = " << exval << endl;
(*testout) << "ERROR: new line exits, val = " << exval << endl;
found = 0;
if (debugparam.haltexistingline)
debugflag = 1;
}
}
}
}
/*
if (found)
{
// check, whether new triangles insert edges twice
for (i = 1; i <= locelements.Size(); i++)
for (j = 1; j <= 3; j++)
{
int tpi1 = locelements.Get(i).PNumMod (j);
int tpi2 = locelements.Get(i).PNumMod (j+1);
if (tpi1 <= pindex.Size() && tpi2 <= pindex.Size())
{
tpi1 = adfront->GetGlobalIndex (pindex.Get(tpi1));
tpi2 = adfront->GetGlobalIndex (pindex.Get(tpi2));
if (doubleedge.Used (INDEX_2(tpi1, tpi2)))
{
if (debugparam.haltexistingline)
debugflag = 1;
cerr << "ERROR Insert edge "
<< tpi1 << " - " << tpi2 << " twice !!!" << endl;
found = 0;
}
doubleedge.Set (INDEX_2(tpi1, tpi2), 1);
}
}
}
*/
if (found)
{
// everything is ok, perform mesh update
ruleused.Elem(rulenr)++;
pindex.SetSize(locpoints.Size());
for (int i = oldnp+1; i <= locpoints.Size(); i++)
{
globind = mesh.AddPoint (locpoints.Get(i));
pindex.Elem(i) = adfront -> AddPoint (locpoints.Get(i), globind);
}
for (int i = oldnl+1; i <= loclines.Size(); i++)
{
/*
for (j = 1; j <= locpoints.Size(); j++)
{
(*testout) << j << ": " << locpoints.Get(j) << endl;
}
*/
/*
ComputeLineGeoInfo (locpoints.Get(loclines.Get(i).I1()),
locpoints.Get(loclines.Get(i).I2()),
gisize, geominfo);
*/
if (pindex.Get(loclines.Get(i).I1()) == -1 ||
pindex.Get(loclines.Get(i).I2()) == -1)
{
(*testout) << "pindex is 0" << endl;
}
if (!upgeominfo.Get(loclines.Get(i).I1()).trignum ||
!upgeominfo.Get(loclines.Get(i).I2()).trignum)
{
cout << "new el: illegal geominfo" << endl;
}
adfront -> AddLine (pindex.Get(loclines.Get(i).I1()),
pindex.Get(loclines.Get(i).I2()),
upgeominfo.Get(loclines.Get(i).I1()),
upgeominfo.Get(loclines.Get(i).I2()));
}
for (int i = 1; i <= locelements.Size(); i++)
{
Element2d mtri(locelements.Get(i).GetNP());
mtri = locelements.Get(i);
mtri.SetIndex (facenr);
// compute triangle geominfo:
// (*testout) << "triggeominfo: ";
for (int j = 1; j <= locelements.Get(i).GetNP(); j++)
{
mtri.GeomInfoPi(j) = upgeominfo.Get(locelements.Get(i).PNum(j));
// (*testout) << mtri.GeomInfoPi(j).trignum << " ";
}
// (*testout) << endl;
for (int j = 1; j <= locelements.Get(i).GetNP(); j++)
{
mtri.PNum(j) =
locelements.Elem(i).PNum(j) =
adfront -> GetGlobalIndex (pindex.Get(locelements.Get(i).PNum(j)));
}
mesh.AddSurfaceElement (mtri);
cntelem++;
// cout << "elements: " << cntelem << endl;
Box<3> box;
box.Set (mesh[mtri[0]]);
box.Add (mesh[mtri[1]]);
box.Add (mesh[mtri[2]]);
surfeltree.Insert (box, mesh.GetNSE());
const Point3d & sep1 = mesh.Point (mtri.PNum(1));
const Point3d & sep2 = mesh.Point (mtri.PNum(2));
const Point3d & sep3 = mesh.Point (mtri.PNum(3));
double trigarea = Cross (Vec3d (sep1, sep2),
Vec3d (sep1, sep3)).Length() / 2;
if (mtri.GetNP() == 4)
{
const Point3d & sep4 = mesh.Point (mtri.PNum(4));
trigarea += Cross (Vec3d (sep1, sep3),
Vec3d (sep1, sep4)).Length() / 2;
}
meshedarea += trigarea;
if(maxarea > 0 && meshedarea-meshedarea_before > maxarea)
{
cerr << "meshed area = " << meshedarea-meshedarea_before << endl
<< "maximal area = " << maxarea << endl
<< "GIVING UP" << endl;
return MESHING2_GIVEUP;
}
for (int j = 1; j <= locelements.Get(i).GetNP(); j++)
{
int gpi = locelements.Get(i).PNum(j);
int oldts = trigsonnode.Size();
if (gpi >= oldts+PointIndex::BASE)
{
trigsonnode.SetSize (gpi+1-PointIndex::BASE);
illegalpoint.SetSize (gpi+1-PointIndex::BASE);
for (int k = oldts+PointIndex::BASE;
k <= gpi; k++)
{
trigsonnode[k] = 0;
illegalpoint[k] = 0;
}
}
trigsonnode[gpi]++;
if (trigsonnode[gpi] > 20)
{
illegalpoint[gpi] = 1;
// cout << "illegal point: " << gpi << endl;
(*testout) << "illegal point: " << gpi << endl;
}
static int mtonnode = 0;
if (trigsonnode[gpi] > mtonnode)
mtonnode = trigsonnode[gpi];
}
// cout << "els = " << cntelem << " trials = " << trials << endl;
// if (trials > 100) return;
}
for (int i = 1; i <= dellines.Size(); i++)
adfront -> DeleteLine (lindex.Get(dellines.Get(i)));
// rname = rules.Get(rulenr)->Name();
#ifdef MYGRAPH
if (silentflag<3)
{
plotsurf.DrawPnL(locpoints, loclines);
plotsurf.Plot(testmode, testmode);
}
#endif
if (morerisc)
{
cout << "generated due to morerisc" << endl;
// multithread.drawing = 1;
// glrender(1);
}
if ( debugparam.haltsuccess || debugflag )
{
// adfront -> PrintOpenSegments (*testout);
cout << "success of rule" << rules.Get(rulenr)->Name() << endl;
multithread.drawing = 1;
multithread.testmode = 1;
multithread.pause = 1;
/*
extern STLGeometry * stlgeometry;
stlgeometry->ClearMarkedSegs();
for (i = 1; i <= loclines.Size(); i++)
{
stlgeometry->AddMarkedSeg(locpoints.Get(loclines.Get(i).I1()),
locpoints.Get(loclines.Get(i).I2()));
}
*/
(*testout) << "success of rule" << rules.Get(rulenr)->Name() << endl;
(*testout) << "trials = " << trials << endl;
(*testout) << "locpoints " << endl;
for (int i = 1; i <= pindex.Size(); i++)
(*testout) << adfront->GetGlobalIndex (pindex.Get(i)) << endl;
(*testout) << "old number of lines = " << oldnl << endl;
for (int i = 1; i <= loclines.Size(); i++)
{
(*testout) << "line ";
for (int j = 1; j <= 2; j++)
{
int hi = 0;
if (loclines.Get(i).I(j) >= 1 &&
loclines.Get(i).I(j) <= pindex.Size())
hi = adfront->GetGlobalIndex (pindex.Get(loclines.Get(i).I(j)));
(*testout) << hi << " ";
}
(*testout) << " : "
<< plainpoints.Get(loclines.Get(i).I1()) << " - "
<< plainpoints.Get(loclines.Get(i).I2()) << " 3d: "
<< locpoints.Get(loclines.Get(i).I1()) << " - "
<< locpoints.Get(loclines.Get(i).I2())
<< endl;
}
glrender(1);
}
}
else
{
adfront -> IncrementClass (lindex.Get(1));
if ( debugparam.haltnosuccess || debugflag )
{
cout << "Problem with seg " << gpi1 << " - " << gpi2
<< ", class = " << qualclass << endl;
(*testout) << "Problem with seg " << gpi1 << " - " << gpi2
<< ", class = " << qualclass << endl;
multithread.drawing = 1;
multithread.testmode = 1;
multithread.pause = 1;
/*
extern STLGeometry * stlgeometry;
stlgeometry->ClearMarkedSegs();
for (i = 1; i <= loclines.Size(); i++)
{
stlgeometry->AddMarkedSeg(locpoints.Get(loclines.Get(i).I1()),
locpoints.Get(loclines.Get(i).I2()));
}
*/
for (int i = 1; i <= loclines.Size(); i++)
{
(*testout) << "line ";
for (int j = 1; j <= 2; j++)
{
int hi = 0;
if (loclines.Get(i).I(j) >= 1 &&
loclines.Get(i).I(j) <= pindex.Size())
hi = adfront->GetGlobalIndex (pindex.Get(loclines.Get(i).I(j)));
(*testout) << hi << " ";
}
(*testout) << " : "
<< plainpoints.Get(loclines.Get(i).I1()) << " - "
<< plainpoints.Get(loclines.Get(i).I2()) << " 3d: "
<< locpoints.Get(loclines.Get(i).I1()) << " - "
<< locpoints.Get(loclines.Get(i).I2())
<< endl;
}
/*
cout << "p1gi = " << blgeominfo[0].trignum
<< ", p2gi = " << blgeominfo[1].trignum << endl;
*/
glrender(1);
}
#ifdef MYGRAPH
if (silentflag<3)
{
if (testmode || trials%2 == 0)
{
plotsurf.DrawPnL(locpoints, loclines);
plotsurf.Plot(testmode, testmode);
}
}
#endif
}
}
PrintMessage (3, "Surface meshing done");
adfront->PrintOpenSegments (*testout);
multithread.task = savetask;
// cout << "surfeltree.depth = " << surfeltree.Tree().Depth() << endl;
EndMesh ();
if (!adfront->Empty())
return MESHING2_GIVEUP;
return MESHING2_OK;
}
}
// #define OPENGL
#ifdef OPENGL
/* *********************** Draw Surface Meshing **************** */
#include <visual.hpp>
#include <stlgeom.hpp>
namespace netgen
{
extern STLGeometry * stlgeometry;
extern Mesh * mesh;
VisualSceneSurfaceMeshing vssurfacemeshing;
void glrender (int wait)
{
// cout << "plot adfront" << endl;
if (multithread.drawing)
{
// vssurfacemeshing.Render();
Render ();
if (wait || multithread.testmode)
{
multithread.pause = 1;
}
while (multithread.pause);
}
}
VisualSceneSurfaceMeshing :: VisualSceneSurfaceMeshing ()
: VisualScene()
{
;
}
VisualSceneSurfaceMeshing :: ~VisualSceneSurfaceMeshing ()
{
;
}
void VisualSceneSurfaceMeshing :: DrawScene ()
{
int i, j, k;
if (loclines.Size() != changeval)
{
center = Point<3>(0,0,-5);
rad = 0.1;
CalcTransformationMatrices();
changeval = loclines.Size();
}
glClearColor(backcolor, backcolor, backcolor, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
SetLight();
// glEnable (GL_COLOR_MATERIAL);
// glDisable (GL_SHADING);
// glColor3f (0.0f, 1.0f, 1.0f);
// glLineWidth (1.0f);
// glShadeModel (GL_SMOOTH);
// glCallList (linelists.Get(1));
// SetLight();
glPushMatrix();
glMultMatrixf (transformationmat);
glShadeModel (GL_SMOOTH);
// glDisable (GL_COLOR_MATERIAL);
glEnable (GL_COLOR_MATERIAL);
glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// glEnable (GL_LIGHTING);
double shine = vispar.shininess;
double transp = vispar.transp;
glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, shine);
glLogicOp (GL_COPY);
/*
float mat_col[] = { 0.2, 0.2, 0.8, 1 };
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_col);
glPolygonOffset (1, 1);
glEnable (GL_POLYGON_OFFSET_FILL);
float mat_colbl[] = { 0.8, 0.2, 0.2, 1 };
float mat_cololdl[] = { 0.2, 0.8, 0.2, 1 };
float mat_colnewl[] = { 0.8, 0.8, 0.2, 1 };
glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
glPolygonOffset (1, -1);
glLineWidth (3);
for (i = 1; i <= loclines.Size(); i++)
{
if (i == 1)
{
glEnable (GL_POLYGON_OFFSET_FILL);
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colbl);
}
else if (i <= oldnl)
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_cololdl);
else
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colnewl);
int pi1 = loclines.Get(i).I1();
int pi2 = loclines.Get(i).I2();
if (pi1 >= 1 && pi2 >= 1)
{
Point3d p1 = locpoints.Get(pi1);
Point3d p2 = locpoints.Get(pi2);
glBegin (GL_LINES);
glVertex3f (p1.X(), p1.Y(), p1.Z());
glVertex3f (p2.X(), p2.Y(), p2.Z());
glEnd();
}
glDisable (GL_POLYGON_OFFSET_FILL);
}
glLineWidth (1);
glPointSize (5);
float mat_colp[] = { 1, 0, 0, 1 };
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colp);
glBegin (GL_POINTS);
for (i = 1; i <= locpoints.Size(); i++)
{
Point3d p = locpoints.Get(i);
glVertex3f (p.X(), p.Y(), p.Z());
}
glEnd();
glPopMatrix();
*/
float mat_colp[] = { 1, 0, 0, 1 };
float mat_col2d1[] = { 1, 0.5, 0.5, 1 };
float mat_col2d[] = { 1, 1, 1, 1 };
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_col2d);
double scalex = 0.1, scaley = 0.1;
glBegin (GL_LINES);
for (i = 1; i <= loclines.Size(); i++)
{
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_col2d);
if (i == 1)
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_col2d1);
int pi1 = loclines.Get(i).I1();
int pi2 = loclines.Get(i).I2();
if (pi1 >= 1 && pi2 >= 1)
{
Point2d p1 = plainpoints.Get(pi1);
Point2d p2 = plainpoints.Get(pi2);
glBegin (GL_LINES);
glVertex3f (scalex * p1.X(), scaley * p1.Y(), -5);
glVertex3f (scalex * p2.X(), scaley * p2.Y(), -5);
glEnd();
}
}
glEnd ();
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colp);
glBegin (GL_POINTS);
for (i = 1; i <= plainpoints.Size(); i++)
{
Point2d p = plainpoints.Get(i);
glVertex3f (scalex * p.X(), scaley * p.Y(), -5);
}
glEnd();
glDisable (GL_POLYGON_OFFSET_FILL);
glPopMatrix();
DrawCoordinateCross ();
DrawNetgenLogo ();
glFinish();
/*
glDisable (GL_POLYGON_OFFSET_FILL);
// cout << "draw surfacemeshing" << endl;
//
// if (changeval != stlgeometry->GetNT())
// BuildScene();
// changeval = stlgeometry->GetNT();
glClearColor(backcolor, backcolor, backcolor, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
SetLight();
glPushMatrix();
glLoadMatrixf (transmat);
glMultMatrixf (rotmat);
glShadeModel (GL_SMOOTH);
glDisable (GL_COLOR_MATERIAL);
glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
float mat_spec_col[] = { 1, 1, 1, 1 };
glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, mat_spec_col);
double shine = vispar.shininess;
double transp = vispar.transp;
glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, shine);
glLogicOp (GL_COPY);
float mat_col[] = { 0.2, 0.2, 0.8, transp };
float mat_colrt[] = { 0.2, 0.8, 0.8, transp };
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_col);
glPolygonOffset (1, 1);
glEnable (GL_POLYGON_OFFSET_FILL);
glColor3f (1.0f, 1.0f, 1.0f);
glEnable (GL_NORMALIZE);
// glBegin (GL_TRIANGLES);
// for (j = 1; j <= stlgeometry -> GetNT(); j++)
// {
// glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_col);
// if (j == geomtrig)
// glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colrt);
// const STLReadTriangle & tria = stlgeometry -> GetReadTriangle(j);
// glNormal3f (tria.normal.X(),
// tria.normal.Y(),
// tria.normal.Z());
// for (k = 0; k < 3; k++)
// {
// glVertex3f (tria.pts[k].X(),
// tria.pts[k].Y(),
// tria.pts[k].Z());
// }
// }
// glEnd ();
glDisable (GL_POLYGON_OFFSET_FILL);
float mat_colbl[] = { 0.8, 0.2, 0.2, 1 };
float mat_cololdl[] = { 0.2, 0.8, 0.2, 1 };
float mat_colnewl[] = { 0.8, 0.8, 0.2, 1 };
glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
glPolygonOffset (1, -1);
glLineWidth (3);
for (i = 1; i <= loclines.Size(); i++)
{
if (i == 1)
{
glEnable (GL_POLYGON_OFFSET_FILL);
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colbl);
}
else if (i <= oldnl)
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_cololdl);
else
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colnewl);
int pi1 = loclines.Get(i).I1();
int pi2 = loclines.Get(i).I2();
if (pi1 >= 1 && pi2 >= 1)
{
Point3d p1 = locpoints.Get(pi1);
Point3d p2 = locpoints.Get(pi2);
glBegin (GL_LINES);
glVertex3f (p1.X(), p1.Y(), p1.Z());
glVertex3f (p2.X(), p2.Y(), p2.Z());
glEnd();
}
glDisable (GL_POLYGON_OFFSET_FILL);
}
glLineWidth (1);
glPointSize (5);
float mat_colp[] = { 1, 0, 0, 1 };
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colp);
glBegin (GL_POINTS);
for (i = 1; i <= locpoints.Size(); i++)
{
Point3d p = locpoints.Get(i);
glVertex3f (p.X(), p.Y(), p.Z());
}
glEnd();
glPopMatrix();
float mat_col2d1[] = { 1, 0.5, 0.5, 1 };
float mat_col2d[] = { 1, 1, 1, 1 };
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_col2d);
double scalex = 0.1, scaley = 0.1;
glBegin (GL_LINES);
for (i = 1; i <= loclines.Size(); i++)
{
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_col2d);
if (i == 1)
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_col2d1);
int pi1 = loclines.Get(i).I1();
int pi2 = loclines.Get(i).I2();
if (pi1 >= 1 && pi2 >= 1)
{
Point2d p1 = plainpoints.Get(pi1);
Point2d p2 = plainpoints.Get(pi2);
glBegin (GL_LINES);
glVertex3f (scalex * p1.X(), scaley * p1.Y(), -5);
glVertex3f (scalex * p2.X(), scaley * p2.Y(), -5);
glEnd();
}
}
glEnd ();
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_colp);
glBegin (GL_POINTS);
for (i = 1; i <= plainpoints.Size(); i++)
{
Point2d p = plainpoints.Get(i);
glVertex3f (scalex * p.X(), scaley * p.Y(), -5);
}
glEnd();
glFinish();
*/
}
void VisualSceneSurfaceMeshing :: BuildScene (int zoomall)
{
int i, j, k;
/*
center = stlgeometry -> GetBoundingBox().Center();
rad = stlgeometry -> GetBoundingBox().Diam() / 2;
CalcTransformationMatrices();
*/
}
}
#else
namespace netgen
{
void glrender (int wait)
{ ; }
}
#endif