void QickSortRec (const Array<double> & values,
Array<int> & order,
int left, int right)
{
int i, j;
double midval;
i = left;
j = right;
midval = values.Get(order.Get((i+j)/2));
do
{
while (values.Get(order.Get(i)) < midval) i++;
while (midval < values.Get(order.Get(j))) j--;
if (i <= j)
{
Swap (order.Elem(i), order.Elem(j));
i++; j--;
}
}
while (i <= j);
if (left < j) QickSortRec (values, order, left, j);
if (i < right) QickSortRec (values, order, i, right);
}
void referencetransform :: ToPlain (const Array<Point3d> & p,
Array<Point3d> & pp) const
{
Vec3d v;
int i;
pp.SetSize (p.Size());
for (i = 1; i <= p.Size(); i++)
{
v = p.Get(i) - rp;
pp.Elem(i).X() = (ex_h * v);
pp.Elem(i).Y() = (ey_h * v);
pp.Elem(i).Z() = (ez_h * v);
}
}
void Set (const INDEX & ahash, const T & acont)
{
int pos;
PositionCreate (ahash, pos);
hash.Elem(pos) = ahash;
cont.Elem(pos) = acont;
}
void Sort (const Array<double> & values,
Array<int> & order)
{
int n = values.Size();
int i, j;
order.SetSize (n);
for (i = 1; i <= n; i++)
order.Elem(i) = i;
for (i = 1; i <= n-1; i++)
for (j = 1; j <= n-1; j++)
if (values.Get(order.Elem(j)) > values.Get(order.Elem(j+1)))
{
Swap (order.Elem(j), order.Elem(j+1));
}
}
void QickSort (const Array<double> & values,
Array<int> & order)
{
int i, n = values.Size();
order.SetSize (n);
for (i = 1; i <= n; i++)
order.Elem(i) = i;
QickSortRec (values, order, 1, order.Size());
}
// returns 1, if new postion is created
int PositionCreate (const INDEX_2 & ind, int & apos)
{
int i = HashValue (ind);
if (hash.Get(i) == ind)
{
apos = i;
return 0;
}
if (hash.Get(i).I1() == invalid)
{
hash.Elem(i) = ind;
apos = i;
return 1;
}
return PositionCreate2 (ind, apos);
}
void ADTree3M :: GetIntersecting (const float * bmin,
const float * bmax,
Array<int> & pis) const
{
static Array<ADTreeNode3M*> stack(1000);
static Array<int> stackdir(1000);
ADTreeNode3M * node;
int dir, i, stacks;
stack.SetSize (1000);
stackdir.SetSize(1000);
pis.SetSize(0);
stack.Elem(1) = root;
stackdir.Elem(1) = 0;
stacks = 1;
while (stacks)
{
node = stack.Get(stacks);
dir = stackdir.Get(stacks);
stacks--;
int * hpi = node->pi;
for (i = 0; i < ADTN_SIZE; i++)
if (hpi[i])
{
float * datai = &node->data[i][0];
if (datai[0] >= bmin[0] && datai[0] <= bmax[0] &&
datai[1] >= bmin[1] && datai[1] <= bmax[1] &&
datai[2] >= bmin[2] && datai[2] <= bmax[2])
pis.Append (node->pi[i]);
}
int ndir = dir+1;
if (ndir == 3)
ndir = 0;
if (node->left && bmin[dir] <= node->sep)
{
stacks++;
stack.Elem(stacks) = node->left;
stackdir.Elem(stacks) = ndir;
}
if (node->right && bmax[dir] >= node->sep)
{
stacks++;
stack.Elem(stacks) = node->right;
stackdir.Elem(stacks) = ndir;
}
}
}
void Brick :: SetPrimitiveData (Array<double> & coeffs)
{
p1(0) = coeffs.Elem(1);
p1(1) = coeffs.Elem(2);
p1(2) = coeffs.Elem(3);
p2(0) = coeffs.Elem(4);
p2(1) = coeffs.Elem(5);
p2(2) = coeffs.Elem(6);
p3(0) = coeffs.Elem(7);
p3(1) = coeffs.Elem(8);
p3(2) = coeffs.Elem(9);
p4(0) = coeffs.Elem(10);
p4(1) = coeffs.Elem(11);
p4(2) = coeffs.Elem(12);
CalcData();
}
void ADTree3 :: GetIntersecting (const float * bmin,
const float * bmax,
Array<int> & pis) const
{
static Array<ADTreeNode3*> stack(1000);
static Array<int> stackdir(1000);
ADTreeNode3 * node;
int dir, stacks;
stack.SetSize (1000);
stackdir.SetSize(1000);
pis.SetSize(0);
stack.Elem(1) = root;
stackdir.Elem(1) = 0;
stacks = 1;
while (stacks)
{
node = stack.Get(stacks);
dir = stackdir.Get(stacks);
stacks--;
if (node->pi != -1)
{
if (node->data[0] >= bmin[0] && node->data[0] <= bmax[0] &&
node->data[1] >= bmin[1] && node->data[1] <= bmax[1] &&
node->data[2] >= bmin[2] && node->data[2] <= bmax[2])
pis.Append (node->pi);
}
int ndir = dir+1;
if (ndir == 3)
ndir = 0;
if (node->left && bmin[dir] <= node->sep)
{
stacks++;
stack.Elem(stacks) = node->left;
stackdir.Elem(stacks) = ndir;
}
if (node->right && bmax[dir] >= node->sep)
{
stacks++;
stack.Elem(stacks) = node->right;
stackdir.Elem(stacks) = ndir;
}
}
}
void Brick ::
GetPrimitiveData (const char *& classname, Array<double> & coeffs) const
{
classname = "brick";
coeffs.SetSize(12);
coeffs.Elem(1) = p1(0);
coeffs.Elem(2) = p1(1);
coeffs.Elem(3) = p1(2);
coeffs.Elem(4) = p2(0);
coeffs.Elem(5) = p2(1);
coeffs.Elem(6) = p2(2);
coeffs.Elem(7) = p3(0);
coeffs.Elem(8) = p3(1);
coeffs.Elem(9) = p3(2);
coeffs.Elem(10) = p4(0);
coeffs.Elem(11) = p4(1);
coeffs.Elem(12) = p4(2);
}
void ADTree6F :: GetIntersecting (const float * bmin,
const float * bmax,
Array<int> & pis) const
{
static Array<ADTreeNode6F*> stack(1000);
ADTreeNode6F * node;
int dir, i, stacks;
stack.SetSize (1000);
pis.SetSize(0);
stack.Elem(1) = root;
stacks = 1;
while (stacks)
{
node = stack.Get(stacks);
stacks--;
if (node->pi)
{
if (
node->data[0] >= bmin[0] && node->data[0] <= bmax[0] &&
node->data[1] >= bmin[1] && node->data[1] <= bmax[1] &&
node->data[2] >= bmin[2] && node->data[2] <= bmax[2] &&
node->data[3] >= bmin[3] && node->data[3] <= bmax[3] &&
node->data[4] >= bmin[4] && node->data[4] <= bmax[4] &&
node->data[5] >= bmin[5] && node->data[5] <= bmax[5]
)
pis.Append (node->pi);
}
int i1min = (bmin[0] <= node->sep[0]) ? 0 : 1;
int i1max = (bmax[0] < node->sep[0]) ? 0 : 1;
int i2min = (bmin[1] <= node->sep[1]) ? 0 : 1;
int i2max = (bmax[1] < node->sep[1]) ? 0 : 1;
int i3min = (bmin[2] <= node->sep[2]) ? 0 : 1;
int i3max = (bmax[2] < node->sep[2]) ? 0 : 1;
int i4min = (bmin[3] <= node->sep[3]) ? 0 : 1;
int i4max = (bmax[3] < node->sep[3]) ? 0 : 1;
int i5min = (bmin[4] <= node->sep[4]) ? 0 : 1;
int i5max = (bmax[4] < node->sep[4]) ? 0 : 1;
int i6min = (bmin[5] <= node->sep[5]) ? 0 : 1;
int i6max = (bmax[5] < node->sep[5]) ? 0 : 1;
int i1, i2, i3, i4, i5, i6;
for (i1 = i1min; i1 <= i1max; i1++)
for (i2 = i2min; i2 <= i2max; i2++)
for (i3 = i3min; i3 <= i3max; i3++)
for (i4 = i4min; i4 <= i4max; i4++)
for (i5 = i5min; i5 <= i5max; i5++)
for (i6 = i6min; i6 <= i6max; i6++)
{
i = i1 + 2*i2 + 4*i3 + 8*i4 + 16*i5 +32*i6;
if (node->childs[i])
{
stacks++;
stack.Elem(stacks) = node->childs[i];
}
}
/*
if (node->left && bmin[dir] <= node->sep)
{
stacks++;
stack.Elem(stacks) = node->left;
stackdir.Elem(stacks) = ndir;
}
if (node->right && bmax[dir] >= node->sep)
{
stacks++;
stack.Elem(stacks) = node->right;
stackdir.Elem(stacks) = ndir;
}
*/
}
}
inline void SetData (int pos, const T & acont)
{
cont.Elem(pos) = acont;
}
inline void SetData (int pos, const INDEX & ahash, const T & acont)
{
hash.Elem(pos) = ahash;
cont.Elem(pos) = acont;
}
STLTriangle & GetTriangle (int nr) { return trias.Elem(nr); }
STLTopEdge & GetTopEdge (int nr) { return topedges.Elem(nr); }
/*
Philippose Rajan - 11 June 2009
Added an initial experimental function for
generating prismatic boundary layers on
a given set of surfaces.
The number of layers, height of the first layer
and the growth / shrink factor can be specified
by the user
Currently, the layer height is calculated using:
height = h_first_layer * (growth_factor^(num_layers - 1))
*/
void GenerateBoundaryLayer (Mesh & mesh, MeshingParameters & mp)
{
int i, j;
ofstream dbg("BndLayerDebug.log");
// Angle between a surface element and a growth-vector below which
// a prism is project onto that surface as a quad
// (in degrees)
double angleThreshold = 5.0;
cout << "Generate Prismatic Boundary Layers (Experimental)...." << endl;
// Use an array to support creation of boundary
// layers for multiple surfaces in the future...
Array<int> surfid;
int surfinp = 0;
int prismlayers = 1;
double hfirst = 0.01;
double growthfactor = 1.0;
// Monitor and print out the number of prism and quad elements
// added to the mesh
int numprisms = 0;
int numquads = 0;
while(surfinp >= 0)
{
cout << "Enter Surface ID (-1 to end list): ";
cin >> surfinp;
if(surfinp >= 0) surfid.Append(surfinp);
}
cout << "Number of surfaces entered = " << surfid.Size() << endl;
cout << "Selected surfaces are:" << endl;
for(i = 1; i <= surfid.Size(); i++)
{
cout << "Surface " << i << ": " << surfid.Elem(i) << endl;
}
cout << endl << "Enter number of prism layers: ";
cin >> prismlayers;
if(prismlayers < 1) prismlayers = 1;
cout << "Enter height of first layer: ";
cin >> hfirst;
if(hfirst <= 0.0) hfirst = 0.01;
cout << "Enter layer growth / shrink factor: ";
cin >> growthfactor;
if(growthfactor <= 0.0) growthfactor = 0.5;
cout << "Old NP: " << mesh.GetNP() << endl;
cout << "Old NSE: " << mesh.GetNSE() << endl;
for(int layer = prismlayers; layer >= 1; layer--)
{
cout << "Generating layer: " << layer << endl;
const MeshTopology& meshtopo = mesh.GetTopology();
const_cast<MeshTopology &> (meshtopo).SetBuildEdges(true);
const_cast<MeshTopology &> (meshtopo).SetBuildFaces(true);
const_cast<MeshTopology &> (meshtopo).Update();
double layerht = hfirst;
if(growthfactor == 1)
{
layerht = layer * hfirst;
}
else
{
layerht = hfirst*(pow(growthfactor,(layer+1)) - 1)/(growthfactor - 1);
}
cout << "Layer Height = " << layerht << endl;
// Need to store the old number of points and
// surface elements because there are new points and
// surface elements being added during the process
int np = mesh.GetNP();
int nse = mesh.GetNSE();
// Safety measure to ensure no issues with mesh
// consistency
int nseg = mesh.GetNSeg();
// Indicate which points need to be remapped
BitArray bndnodes(np);
// Map of the old points to the new points
Array<int> mapto(np);
// Growth vectors for the prismatic layer based on
// the effective surface normal at a given point
Array<Vec3d> growthvectors(np);
// Bit array to identify all the points belonging
// to the surface of interest
bndnodes.Clear();
// Run through all the surface elements and mark the points
// belonging to those where a boundary layer has to be created.
// In addition, also calculate the effective surface normal
// vectors at each of those points to determine the mesh motion
// direction
cout << "Marking points for remapping...." << endl;
for (i = 1; i <= nse; i++)
{
int snr = mesh.SurfaceElement(i).GetIndex();
// cout << "snr = " << snr << endl;
if (surfid.Contains(snr))
{
Element2d & sel = mesh.SurfaceElement(i);
int selNP = sel.GetNP();
for(j = 1; j <= selNP; j++)
{
// Set the bitarray to indicate that the
// point is part of the required set
bndnodes.Set(sel.PNum(j));
// Vec3d& surfacenormal = Vec3d(); ????
Vec3d surfacenormal;
// Calculate the surface normal at the current point
// with respect to the current surface element
GetSurfaceNormal(mesh,sel,j,surfacenormal);
// Add the surface normal to the already existent one
// (This gives the effective normal direction at corners
// and curved areas)
growthvectors.Elem(sel.PNum(j)) = growthvectors.Elem(sel.PNum(j))
+ surfacenormal;
}
}
}
// Add additional points into the mesh structure in order to
// clone the surface elements.
// Also invert the growth vectors so that they point inwards,
// and normalize them
cout << "Cloning points and calculating growth vectors...." << endl;
for (i = 1; i <= np; i++)
{
if (bndnodes.Test(i))
{
mapto.Elem(i) = mesh.AddPoint (mesh.Point (i));
growthvectors.Elem(i).Normalize();
growthvectors.Elem(i) *= -1.0;
}
else
{
mapto.Elem(i) = 0;
growthvectors.Elem(i) = Vec3d(0,0,0);
}
}
// Add quad surface elements at edges for surfaces which
// dont have boundary layers
// Bit array to keep track of segments already processed
BitArray segsel(nseg);
// Set them all to "1" to initially activate all segments
segsel.Set();
cout << "Adding 2D Quad elements on required surfaces...." << endl;
for (i = 1; i <= nseg; i++)
{
int seg_p1 = mesh.LineSegment(i)[0];
int seg_p2 = mesh.LineSegment(i)[1];
// Only go in if the segment is still active, and if both its
// surface index is part of the "hit-list"
if(segsel.Test(i) && surfid.Contains(mesh.LineSegment(i).si))
{
// clear the bit to indicate that this segment has been processed
segsel.Clear(i);
// Find matching segment pair on other surface
for(j = 1; j <= nseg; j++)
{
int segpair_p1 = mesh.LineSegment(j)[1];
int segpair_p2 = mesh.LineSegment(j)[0];
// Find the segment pair on the neighbouring surface element
// Identified by: seg1[0] = seg_pair[1] and seg1[1] = seg_pair[0]
if(segsel.Test(j) && ((segpair_p1 == seg_p1) && (segpair_p2 == seg_p2)))
{
// clear bit to indicate that processing of this segment is done
segsel.Clear(j);
// Only worry about those surfaces which are not in the
// boundary layer list
if(!surfid.Contains(mesh.LineSegment(j).si))
{
int pnt_commelem = 0;
int pnum_commelem = 0;
Array<int> pnt1_elems;
Array<int> pnt2_elems;
meshtopo.GetVertexSurfaceElements(segpair_p1,pnt1_elems);
meshtopo.GetVertexSurfaceElements(segpair_p2,pnt2_elems);
for(int k = 1; k <= pnt1_elems.Size(); k++)
{
Element2d pnt1_sel = mesh.SurfaceElement(pnt1_elems.Elem(k));
for(int l = 1; l <= pnt2_elems.Size(); l++)
{
Element2d pnt2_sel = mesh.SurfaceElement(pnt2_elems.Elem(l));
if((pnt1_sel.GetIndex() == mesh.LineSegment(j).si)
&& (pnt2_sel.GetIndex() == mesh.LineSegment(j).si)
&& (pnt1_elems.Elem(k) == pnt2_elems.Elem(l)))
{
pnt_commelem = pnt1_elems.Elem(k);
}
}
}
for(int k = 1; k <= mesh.SurfaceElement(pnt_commelem).GetNP(); k++)
{
if((mesh.SurfaceElement(pnt_commelem).PNum(k) != segpair_p1)
&& (mesh.SurfaceElement(pnt_commelem).PNum(k) != segpair_p2))
{
pnum_commelem = mesh.SurfaceElement(pnt_commelem).PNum(k);
}
}
Vec3d surfelem_vect, surfelem_vect1;
Element2d & commsel = mesh.SurfaceElement(pnt_commelem);
dbg << "NP= " << commsel.GetNP() << " : ";
for(int k = 1; k <= commsel.GetNP(); k++)
{
GetSurfaceNormal(mesh,commsel,k,surfelem_vect1);
surfelem_vect += surfelem_vect1;
}
surfelem_vect.Normalize();
double surfangle = Angle(growthvectors.Elem(segpair_p1),surfelem_vect);
dbg << "V1= " << surfelem_vect1
<< " : V2= " << surfelem_vect1
<< " : V= " << surfelem_vect
<< " : GV= " << growthvectors.Elem(segpair_p1)
<< " : Angle= " << surfangle * 180 / 3.141592;
// remap the segments to the new points
mesh.LineSegment(i)[0] = mapto.Get(seg_p1);
mesh.LineSegment(i)[1] = mapto.Get(seg_p2);
mesh.LineSegment(j)[1] = mapto.Get(seg_p1);
mesh.LineSegment(j)[0] = mapto.Get(seg_p2);
if((surfangle < (90 + angleThreshold) * 3.141592 / 180.0)
&& (surfangle > (90 - angleThreshold) * 3.141592 / 180.0))
{
dbg << " : quad\n";
// Since the surface is lower than the threshold, change the effective
// prism growth vector to match with the surface vector, so that
// the Quad which is created lies on the original surface
//growthvectors.Elem(segpair_p1) = surfelem_vect;
// Add a quad element to account for the prism volume
// element which is going to be added
Element2d sel(QUAD);
sel.PNum(4) = mapto.Get(seg_p1);
sel.PNum(3) = mapto.Get(seg_p2);
sel.PNum(2) = segpair_p2;
sel.PNum(1) = segpair_p1;
sel.SetIndex(mesh.LineSegment(j).si);
mesh.AddSurfaceElement(sel);
numquads++;
}
else
{
dbg << "\n";
for (int k = 1; k <= pnt1_elems.Size(); k++)
{
Element2d & pnt_sel = mesh.SurfaceElement(pnt1_elems.Elem(k));
if(pnt_sel.GetIndex() == mesh.LineSegment(j).si)
{
for(int l = 1; l <= pnt_sel.GetNP(); l++)
{
if(pnt_sel.PNum(l) == segpair_p1)
{
pnt_sel.PNum(l) = mapto.Get(seg_p1);
}
else if(pnt_sel.PNum(l) == segpair_p2)
{
pnt_sel.PNum(l) = mapto.Get(seg_p2);
}
}
}
}
for (int k = 1; k <= pnt2_elems.Size(); k++)
{
Element2d & pnt_sel = mesh.SurfaceElement(pnt2_elems.Elem(k));
if(pnt_sel.GetIndex() == mesh.LineSegment(j).si)
{
for(int l = 1; l <= pnt_sel.GetNP(); l++)
{
if(pnt_sel.PNum(l) == segpair_p1)
{
pnt_sel.PNum(l) = mapto.Get(seg_p1);
}
else if(pnt_sel.PNum(l) == segpair_p2)
{
pnt_sel.PNum(l) = mapto.Get(seg_p2);
}
}
}
}
}
}
else
{
// If the code comes here, it indicates that we are at
// a line segment pair which is at the intersection
// of two surfaces, both of which have to grow boundary
// layers.... here too, remapping the segments to the
// new points is required
mesh.LineSegment(i)[0] = mapto.Get(seg_p1);
mesh.LineSegment(i)[1] = mapto.Get(seg_p2);
mesh.LineSegment(j)[1] = mapto.Get(seg_p1);
mesh.LineSegment(j)[0] = mapto.Get(seg_p2);
}
}
}
}
}
// Add prismatic cells at the boundaries
cout << "Generating prism boundary layer volume elements...." << endl;
for (i = 1; i <= nse; i++)
{
Element2d & sel = mesh.SurfaceElement(i);
if(surfid.Contains(sel.GetIndex()))
{
Element el(PRISM);
for (j = 1; j <= sel.GetNP(); j++)
{
// Check (Doublecheck) if the corresponding point has a
// copy available for remapping
if (mapto.Get(sel.PNum(j)))
{
// Define the points of the newly added Prism cell
el.PNum(j+3) = mapto.Get(sel.PNum(j));
el.PNum(j) = sel.PNum(j);
}
}
el.SetIndex(1);
el.Invert();
mesh.AddVolumeElement(el);
numprisms++;
}
}
// Finally switch the point indices of the surface elements
// to the newly added ones
cout << "Transferring boundary layer surface elements to new vertex references...." << endl;
for (i = 1; i <= nse; i++)
{
Element2d & sel = mesh.SurfaceElement(i);
if(surfid.Contains(sel.GetIndex()))
{
for (j = 1; j <= sel.GetNP(); j++)
{
// Check (Doublecheck) if the corresponding point has a
// copy available for remapping
if (mapto.Get(sel.PNum(j)))
{
// Map the surface elements to the new points
sel.PNum(j) = mapto.Get(sel.PNum(j));
}
}
}
}
// Lock all the prism points so that the rest of the mesh can be
// optimised without invalidating the entire mesh
for (PointIndex pi = mesh.Points().Begin(); pi < mesh.Points().End(); pi++)
{
if(bndnodes.Test(i)) mesh.AddLockedPoint(pi);
}
// Now, actually pull back the old surface points to create
// the actual boundary layers
cout << "Moving and optimising boundary layer points...." << endl;
for (i = 1; i <= np; i++)
{
Array<ElementIndex> vertelems;
if(bndnodes.Test(i))
{
MeshPoint pointtomove;
pointtomove = mesh.Point(i);
if(layer == prismlayers)
{
mesh.Point(i).SetPoint(pointtomove + layerht * growthvectors.Elem(i));
meshtopo.GetVertexElements(i,vertelems);
for(j = 1; j <= vertelems.Size(); j++)
{
// double sfact = 0.9;
Element volel = mesh.VolumeElement(vertelems.Elem(j));
if(((volel.GetType() == TET) || (volel.GetType() == TET10)) && (!volel.IsDeleted()))
{
//while((volel.Volume(mesh.Points()) <= 0.0) && (sfact >= 0.0))
//{
// mesh.Point(i).SetPoint(pointtomove + (sfact * layerht * growthvectors.Elem(i)));
// mesh.ImproveMesh();
// // Try to move the point back by one step but
// // if the volume drops to below zero, double back
// mesh.Point(i).SetPoint(pointtomove + ((sfact + 0.1) * layerht * growthvectors.Elem(i)));
// if(volel.Volume(mesh.Points()) <= 0.0)
// {
// mesh.Point(i).SetPoint(pointtomove + (sfact * layerht * growthvectors.Elem(i)));
// }
// sfact -= 0.1;
//}
volel.Delete();
}
}
mesh.Compress();
}
else
{
mesh.Point(i).SetPoint(pointtomove + layerht * growthvectors.Elem(i));
}
}
}
}
// Optimise the tet part of the volume mesh after all the modifications
// to the system are completed
//OptimizeVolume(mparam,mesh);
cout << "New NP: " << mesh.GetNP() << endl;
cout << "Num of Quads: " << numquads << endl;
cout << "Num of Prisms: " << numprisms << endl;
cout << "Boundary Layer Generation....Done!" << endl;
dbg.close();
}
int AdFront2 :: GetLocals (int baselineindex,
Array<Point3d> & locpoints,
Array<MultiPointGeomInfo> & pgeominfo,
Array<INDEX_2> & loclines, // local index
Array<INDEX> & pindex,
Array<INDEX> & lindex,
double xh)
{
static int timer = NgProfiler::CreateTimer ("adfront2::GetLocals");
NgProfiler::RegionTimer reg (timer);
int pstind;
Point<3> midp, p0;
pstind = lines[baselineindex].L().I1();
p0 = points[pstind].P();
loclines.Append(lines[baselineindex].L());
lindex.Append(baselineindex);
ArrayMem<int, 1000> nearlines(0);
ArrayMem<int, 1000> nearpoints(0);
// dominating costs !!
linesearchtree.GetIntersecting (p0 - Vec3d(xh, xh, xh),
p0 + Vec3d(xh, xh, xh),
nearlines);
pointsearchtree.GetIntersecting (p0 - Vec3d(xh, xh, xh),
p0 + Vec3d(xh, xh, xh),
nearpoints);
for (int ii = 0; ii < nearlines.Size(); ii++)
{
int i = nearlines[ii];
if (lines[i].Valid() && i != baselineindex)
{
loclines.Append(lines[i].L());
lindex.Append(i);
}
}
// static Array<int> invpindex;
invpindex.SetSize (points.Size());
// invpindex = -1;
for (int i = 0; i < nearpoints.Size(); i++)
invpindex[nearpoints[i]] = -1;
for (int i = 0; i < loclines.Size(); i++)
{
invpindex[loclines[i].I1()] = 0;
invpindex[loclines[i].I2()] = 0;
}
for (int i = 0; i < loclines.Size(); i++)
{
for (int j = 0; j < 2; j++)
{
int pi = loclines[i][j];
if (invpindex[pi] == 0)
{
pindex.Append (pi);
invpindex[pi] = pindex.Size();
loclines[i][j] = locpoints.Append (points[pi].P());
}
else
loclines[i][j] = invpindex[pi];
}
}
// double xh2 = xh*xh;
for (int ii = 0; ii < nearpoints.Size(); ii++)
{
int i = nearpoints[ii];
if (points[i].Valid() &&
points[i].OnSurface() &&
// Dist2 (points.Get(i).P(), p0) <= xh2 &&
invpindex[i] <= 0)
{
invpindex[i] = locpoints.Append (points[i].P());
pindex.Append(i);
}
}
/*
double xh2 = xh*xh;
for (i = 1; i <= points.Size(); i++)
{
if (points.Get(i).Valid() &&
points.Get(i).OnSurface() &&
Dist2 (points.Get(i).P(), p0) <= xh2 &&
invpindex.Get(i) <= 0)
{
invpindex.Elem(i) =
locpoints.Append (points.Get(i).P());
pindex.Append(i);
}
}
*/
pgeominfo.SetSize (locpoints.Size());
for (int i = 0; i < pgeominfo.Size(); i++)
pgeominfo[i].Init();
for (int i = 0; i < loclines.Size(); i++)
for (int j = 0; j < 2; j++)
{
int lpi = loclines[i][j];
const PointGeomInfo & gi =
lines[lindex[i]].GetGeomInfo (j+1);
pgeominfo.Elem(lpi).AddPointGeomInfo (gi);
/*
if (pgeominfo.Elem(lpi).cnt == MULTIPOINTGEOMINFO_MAX)
break;
const PointGeomInfo & gi =
lines.Get(lindex.Get(i)).GetGeomInfo (j);
PointGeomInfo * pgi = pgeominfo.Elem(lpi).mgi;
int found = 0;
for (k = 0; k < pgeominfo.Elem(lpi).cnt; k++)
if (pgi[k].trignum == gi.trignum)
found = 1;
if (!found)
{
pgi[pgeominfo.Elem(lpi).cnt] = gi;
pgeominfo.Elem(lpi).cnt++;
}
*/
}
for (int i = 0; i < locpoints.Size(); i++)
{
int pi = pindex[i];
if (points[pi].mgi)
for (int j = 1; j <= points[pi].mgi->GetNPGI(); j++)
pgeominfo[i].AddPointGeomInfo (points[pi].mgi->GetPGI(j));
}
if (loclines.Size() == 1)
{
(*testout) << "loclines.size = 1" << endl
<< " h = " << xh << endl
<< " nearline.size = " << nearlines.Size() << endl
<< " p0 = " << p0 << endl;
}
return lines[baselineindex].LineClass();
}
void SetPoint(int nr, const Point<3> & p) { points.Elem(nr) = p; }
void SetNormal(int nr, const Vec3d& n) {normals.Elem(nr) = n;}
void IncrementClass (INDEX fi)
{ faces.Elem(fi).IncrementQualClass(); }
void ADTree3FM :: GetIntersecting (const float * bmin,
const float * bmax,
Array<int> & pis) const
{
static Array<ADTreeNode3FM*> stack(1000);
ADTreeNode3FM * node;
int dir, i, stacks;
stack.SetSize (1000);
pis.SetSize(0);
stack.Elem(1) = root;
stacks = 1;
while (stacks)
{
node = stack.Get(stacks);
stacks--;
int * hpi = node->pi;
for (i = 0; i < ADTN_SIZE; i++)
if (hpi[i])
{
float * datai = &node->data[i][0];
if (datai[0] >= bmin[0] && datai[0] <= bmax[0] &&
datai[1] >= bmin[1] && datai[1] <= bmax[1] &&
datai[2] >= bmin[2] && datai[2] <= bmax[2])
pis.Append (node->pi[i]);
}
/*
if (node->pi)
{
if (node->data[0] >= bmin[0] && node->data[0] <= bmax[0] &&
node->data[1] >= bmin[1] && node->data[1] <= bmax[1] &&
node->data[2] >= bmin[2] && node->data[2] <= bmax[2])
pis.Append (node->pi);
}
*/
int i1min = (bmin[0] <= node->sep[0]) ? 0 : 1;
int i1max = (bmax[0] < node->sep[0]) ? 0 : 1;
int i2min = (bmin[1] <= node->sep[1]) ? 0 : 1;
int i2max = (bmax[1] < node->sep[1]) ? 0 : 1;
int i3min = (bmin[2] <= node->sep[2]) ? 0 : 1;
int i3max = (bmax[2] < node->sep[2]) ? 0 : 1;
int i1, i2, i3;
for (i1 = i1min; i1 <= i1max; i1++)
for (i2 = i2min; i2 <= i2max; i2++)
for (i3 = i3min; i3 <= i3max; i3++)
{
i = i1+2*i2+4*i3;
if (node->childs[i])
{
stacks++;
stack.Elem(stacks) = node->childs[i];
}
}
/*
if (node->left && bmin[dir] <= node->sep)
{
stacks++;
stack.Elem(stacks) = node->left;
stackdir.Elem(stacks) = ndir;
}
if (node->right && bmax[dir] >= node->sep)
{
stacks++;
stack.Elem(stacks) = node->right;
stackdir.Elem(stacks) = ndir;
}
*/
}
}
void ResetClass (INDEX fi)
{ faces.Elem(fi).ResetQualClass(); }
void ADTree3Div :: GetIntersecting (const float * bmin,
const float * bmax,
Array<int> & pis) const
{
static Array<ADTreeNode3Div*> stack(1000);
static Array<int> stackdir(1000);
ADTreeNode3Div * node;
int dir, i, stacks;
stack.SetSize (1000);
stackdir.SetSize(1000);
pis.SetSize(0);
stack.Elem(1) = root;
stackdir.Elem(1) = 0;
stacks = 1;
while (stacks)
{
node = stack.Get(stacks);
dir = stackdir.Get(stacks);
stacks--;
if (node->pi)
{
if (node->data[0] >= bmin[0] && node->data[0] <= bmax[0] &&
node->data[1] >= bmin[1] && node->data[1] <= bmax[1] &&
node->data[2] >= bmin[2] && node->data[2] <= bmax[2])
pis.Append (node->pi);
}
int ndir = dir+1;
if (ndir == 3)
ndir = 0;
int mini = int ( (bmin[dir] - node->minx) / node->dist );
int maxi = int ( (bmax[dir] - node->minx) / node->dist );
// (*testout) << "get int, mini, maxi = " << mini << ", " << maxi << endl;
if (mini < 0) mini = 0;
if (maxi >= ADTN_DIV) maxi = ADTN_DIV-1;
for (i = mini; i <= maxi; i++)
if (node->childs[i])
{
stacks++;
stack.Elem(stacks) = node->childs[i];
stackdir.Elem(stacks) = ndir;
}
/*
if (node->left && bmin[dir] <= node->sep)
{
stacks++;
stack.Elem(stacks) = node->left;
stackdir.Elem(stacks) = ndir;
}
if (node->right && bmax[dir] >= node->sep)
{
stacks++;
stack.Elem(stacks) = node->right;
stackdir.Elem(stacks) = ndir;
}
*/
}
}
void SetSpiralPoint(int pn) {spiralpoints.Elem(pn) = 1;};
int AdFront2 :: GetLocals (int baselineindex,
Array<Point3d> & locpoints,
Array<MultiPointGeomInfo> & pgeominfo,
Array<INDEX_2> & loclines, // local index
Array<INDEX> & pindex,
Array<INDEX> & lindex,
double xh)
{
int pstind;
Point<3> midp, p0;
pstind = lines[baselineindex].L().I1();
p0 = points[pstind].P();
loclines.Append(lines[baselineindex].L());
lindex.Append(baselineindex);
ArrayMem<int, 1000> nearlines(0);
ArrayMem<int, 1000> nearpoints(0);
// dominating costs !!
linesearchtree.GetIntersecting (p0 - Vec3d(xh, xh, xh),
p0 + Vec3d(xh, xh, xh),
nearlines);
pointsearchtree.GetIntersecting (p0 - Vec3d(xh, xh, xh),
p0 + Vec3d(xh, xh, xh),
nearpoints);
for (int ii = 0; ii < nearlines.Size(); ii++)
{
int i = nearlines[ii];
if (lines[i].Valid() && i != baselineindex)
{
loclines.Append(lines[i].L());
lindex.Append(i);
}
}
// static Array<int> invpindex;
invpindex.SetSize (points.Size());
// invpindex = -1;
for (int i = 0; i < nearpoints.Size(); i++)
invpindex[nearpoints[i]] = -1;
for (int i = 0; i < loclines.Size(); i++)
{
invpindex[loclines[i].I1()] = 0;
invpindex[loclines[i].I2()] = 0;
}
for (int i = 0; i < loclines.Size(); i++)
{
for (int j = 0; j < 2; j++)
{
int pi = loclines[i][j];
if (invpindex[pi] == 0)
{
pindex.Append (pi);
invpindex[pi] = pindex.Size();
loclines[i][j] = locpoints.Append (points[pi].P());
}
else
loclines[i][j] = invpindex[pi];
}
}
// double xh2 = xh*xh;
for (int ii = 0; ii < nearpoints.Size(); ii++)
{
int i = nearpoints[ii];
if (points[i].Valid() &&
points[i].OnSurface() &&
// Dist2 (points.Get(i).P(), p0) <= xh2 &&
invpindex[i] <= 0)
{
invpindex[i] = locpoints.Append (points[i].P());
pindex.Append(i);
}
}
pgeominfo.SetSize (locpoints.Size());
for (int i = 0; i < pgeominfo.Size(); i++)
pgeominfo[i].Init();
for (int i = 0; i < loclines.Size(); i++)
for (int j = 0; j < 2; j++)
{
int lpi = loclines[i][j];
const PointGeomInfo & gi =
lines[lindex[i]].GetGeomInfo (j+1);
pgeominfo.Elem(lpi).AddPointGeomInfo (gi);
}
for (int i = 0; i < locpoints.Size(); i++)
{
int pi = pindex[i];
if (points[pi].mgi)
for (int j = 1; j <= points[pi].mgi->GetNPGI(); j++)
pgeominfo[i].AddPointGeomInfo (points[pi].mgi->GetPGI(j));
}
if (loclines.Size() == 1)
{
cout << "loclines.size = 1" << endl
<< " h = " << xh << endl
<< " nearline.size = " << nearlines.Size() << endl
<< " p0 = " << p0 << endl;
}
return lines[baselineindex].LineClass();
}
