zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

ENH: Add extra octree functionality

Browse Source 
+ Make intersection and nearest functions functors. This makes adding
  different intersection and nearest routines easier.
+ treeDataPrimitivePatch takes its tolerance as a constructor argument
+ Make treeDataTriSurface a typedef of treeDataPrimitivePatch

Conflicts:
	src/OpenFOAM/algorithms/indexedOctree/indexedOctree.C
	src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
	src/meshTools/indexedOctree/treeDataTriSurface.C
This commit is contained in:
laurence
2013-03-15 12:38:57 +00:00
parent 24e36ddf3f
commit 8ed95d4750
22 changed files with 968 additions and 967 deletions
Download Patch File Download Diff File Expand all files Collapse all files

149
src/OpenFOAM/algorithms/indexedOctree/indexedOctree.C
View File

@ -576,6 +576,7 @@ Foam::indexedOctree<Type>::getSide
// Find nearest point starting from nodeI
template<class Type>
template<class FindNearestOp>
void Foam::indexedOctree<Type>::findNearest
(
const label nodeI,
@ -583,7 +584,9 @@ void Foam::indexedOctree<Type>::findNearest
scalar& nearestDistSqr,
label& nearestShapeI,
point& nearestPoint
point& nearestPoint,
const FindNearestOp& fnOp
) const
{
const node& nod = nodes_[nodeI];
@ -614,7 +617,9 @@ void Foam::indexedOctree<Type>::findNearest
nearestDistSqr,
nearestShapeI,
nearestPoint
nearestPoint,
fnOp
);
}
}
@ -631,7 +636,7 @@ void Foam::indexedOctree<Type>::findNearest
)
)
{
shapes_.findNearest
fnOp
(
contents_[getContent(index)],
sample,
@ -648,6 +653,7 @@ void Foam::indexedOctree<Type>::findNearest
// Find nearest point to line.
template<class Type>
template<class FindNearestOp>
void Foam::indexedOctree<Type>::findNearest
(
const label nodeI,
@ -656,7 +662,9 @@ void Foam::indexedOctree<Type>::findNearest
treeBoundBox& tightest,
label& nearestShapeI,
point& linePoint,
point& nearestPoint
point& nearestPoint,
const FindNearestOp& fnOp
) const
{
const node& nod = nodes_[nodeI];
@ -687,7 +695,9 @@ void Foam::indexedOctree<Type>::findNearest
tightest,
nearestShapeI,
linePoint,
nearestPoint
nearestPoint,
fnOp
);
}
}
@ -697,7 +707,7 @@ void Foam::indexedOctree<Type>::findNearest
if (subBb.overlaps(tightest))
{
shapes_.findNearest
fnOp
(
contents_[getContent(index)],
ln,
@ -1620,6 +1630,7 @@ Foam::word Foam::indexedOctree<Type>::faceString
// hitInfo.point = coordinate of intersection of ray with bounding box
// hitBits = posbits of point on bounding box
template<class Type>
template<class FindIntersectOp>
void Foam::indexedOctree<Type>::traverseNode
(
const bool findAny,
@ -1632,7 +1643,9 @@ void Foam::indexedOctree<Type>::traverseNode
const direction octant,
pointIndexHit& hitInfo,
direction& hitBits
direction& hitBits,
const FindIntersectOp& fiOp
) const
{
if (debug)
@ -1667,7 +1680,7 @@ void Foam::indexedOctree<Type>::traverseNode
label shapeI = indices[elemI];
point pt;
bool hit = shapes_.intersects(shapeI, start, end, pt);
bool hit = fiOp(shapeI, start, end, pt);
// Note that intersection of shape might actually be
// in a neighbouring box. For findAny this is not important.
@ -1695,13 +1708,7 @@ void Foam::indexedOctree<Type>::traverseNode
label shapeI = indices[elemI];
point pt;
bool hit = shapes_.intersects
(
shapeI,
start,
nearestPoint,
pt
);
bool hit = fiOp(shapeI, start, nearestPoint, pt);
// Note that intersection of shape might actually be
// in a neighbouring box. Since we need to maintain strict
@ -1774,7 +1781,9 @@ void Foam::indexedOctree<Type>::traverseNode
octant,
hitInfo,
hitBits
hitBits,
fiOp
);
}
}
@ -1782,6 +1791,7 @@ void Foam::indexedOctree<Type>::traverseNode
// Find first intersection
template<class Type>
template<class FindIntersectOp>
Foam::pointIndexHit Foam::indexedOctree<Type>::findLine
(
const bool findAny,
@ -1789,6 +1799,7 @@ Foam::pointIndexHit Foam::indexedOctree<Type>::findLine
const point& treeEnd,
const label startNodeI,
const direction startOctant,
const FindIntersectOp& fiOp,
const bool verbose
) const
{
@ -1864,7 +1875,9 @@ Foam::pointIndexHit Foam::indexedOctree<Type>::findLine
octant,
hitInfo,
hitFaceID
hitFaceID,
fiOp
);
// Did we hit a triangle?
@ -1948,7 +1961,8 @@ Foam::pointIndexHit Foam::indexedOctree<Type>::findLine
treeEnd,
startNodeI,
startOctant,
true //verbose
fiOp,
true //verbose,
);
}
if (debug)
@ -2007,11 +2021,13 @@ Foam::pointIndexHit Foam::indexedOctree<Type>::findLine
// Find first intersection
template<class Type>
template<class FindIntersectOp>
Foam::pointIndexHit Foam::indexedOctree<Type>::findLine
(
const bool findAny,
const point& start,
const point& end
const point& end,
const FindIntersectOp& fiOp
) const
{
pointIndexHit hitInfo;
@ -2069,7 +2085,8 @@ Foam::pointIndexHit Foam::indexedOctree<Type>::findLine
trackStart,
trackEnd,
parentNodeI,
octant
octant,
fiOp
);
}
@ -2656,6 +2673,25 @@ Foam::pointIndexHit Foam::indexedOctree<Type>::findNearest
const point& sample,
const scalar startDistSqr
) const
{
return findNearest
(
sample,
startDistSqr,
typename Type::findNearestOp(*this)
);
}
template <class Type>
template <class FindNearestOp>
Foam::pointIndexHit Foam::indexedOctree<Type>::findNearest
(
const point& sample,
const scalar startDistSqr,
const FindNearestOp& fnOp
) const
{
scalar nearestDistSqr = startDistSqr;
label nearestShapeI = -1;
@ -2670,7 +2706,9 @@ Foam::pointIndexHit Foam::indexedOctree<Type>::findNearest
nearestDistSqr,
nearestShapeI,
nearestPoint
nearestPoint,
fnOp
);
}
@ -2685,6 +2723,27 @@ Foam::pointIndexHit Foam::indexedOctree<Type>::findNearest
treeBoundBox& tightest,
point& linePoint
) const
{
return findNearest
(
ln,
tightest,
linePoint,
typename Type::findNearestOp(*this)
);
}
template <class Type>
template <class FindNearestOp>
Foam::pointIndexHit Foam::indexedOctree<Type>::findNearest
(
const linePointRef& ln,
treeBoundBox& tightest,
point& linePoint,
const FindNearestOp& fnOp
) const
{
label nearestShapeI = -1;
point nearestPoint = vector::zero;
@ -2699,7 +2758,9 @@ Foam::pointIndexHit Foam::indexedOctree<Type>::findNearest
tightest,
nearestShapeI,
linePoint,
nearestPoint
nearestPoint,
fnOp
);
}
@ -2715,7 +2776,13 @@ Foam::pointIndexHit Foam::indexedOctree<Type>::findLine
const point& end
) const
{
return findLine(false, start, end);
return findLine
(
false,
start,
end,
typename Type::findIntersectOp(*this)
);
}
@ -2727,7 +2794,41 @@ Foam::pointIndexHit Foam::indexedOctree<Type>::findLineAny
const point& end
) const
{
return findLine(true, start, end);
return findLine
(
true,
start,
end,
typename Type::findIntersectOp(*this)
);
}
// Find nearest intersection
template <class Type>
template <class FindIntersectOp>
Foam::pointIndexHit Foam::indexedOctree<Type>::findLine
(
const point& start,
const point& end,
const FindIntersectOp& fiOp
) const
{
return findLine(false, start, end, fiOp);
}
// Find nearest intersection
template <class Type>
template <class FindIntersectOp>
Foam::pointIndexHit Foam::indexedOctree<Type>::findLineAny
(
const point& start,
const point& end,
const FindIntersectOp& fiOp
) const
{
return findLine(true, start, end, fiOp);
}

60
src/OpenFOAM/algorithms/indexedOctree/indexedOctree.H
View File

@ -212,6 +212,7 @@ private:
// Query
//- Find nearest point to line.
template <class FindNearestOp>
void findNearest
(
const label nodeI,
@ -220,7 +221,9 @@ private:
treeBoundBox& tightest,
label& nearestShapeI,
point& linePoint,
point& nearestPoint
point& nearestPoint,
const FindNearestOp& fnOp
) const;
//- Return bbox of octant
@ -294,6 +297,7 @@ private:
// intersection point.
// findAny=true : return any intersection
// findAny=false: return nearest (to start) intersection
template <class FindIntersectOp>
void traverseNode
(
const bool findAny,
@ -306,10 +310,13 @@ private:
const direction octantI,
pointIndexHit& hitInfo,
direction& faceID
direction& faceID,
const FindIntersectOp& fiOp
) const;
//- Find any or nearest intersection
template <class FindIntersectOp>
pointIndexHit findLine
(
const bool findAny,
@ -317,6 +324,7 @@ private:
const point& treeEnd,
const label startNodeI,
const direction startOctantI,
const FindIntersectOp& fiOp,
const bool verbose = false
) const;
@ -328,11 +336,13 @@ private:
// ) const;
//- Find any or nearest intersection of line between start and end.
template <class FindIntersectOp>
pointIndexHit findLine
(
const bool findAny,
const point& start,
const point& end
const point& end,
const FindIntersectOp& fiOp
) const;
//- Find all elements intersecting box.
@ -528,15 +538,24 @@ public:
// Queries
pointIndexHit findNearest
(
const point& sample,
const scalar nearestDistSqr
) const;
//- Calculate nearest point on nearest shape.
// Returns
// - bool : any point found nearer than nearestDistSqr
// - label: index in shapes
// - point: actual nearest point found
template <class FindNearestOp>
pointIndexHit findNearest
(
const point& sample,
const scalar nearestDistSqr
const scalar nearestDistSqr,
const FindNearestOp& fnOp
) const;
// bool findAnyOverlap
@ -553,6 +572,7 @@ public:
// ) const;
//- Low level: calculate nearest starting from subnode.
template <class FindNearestOp>
void findNearest
(
const label nodeI,
@ -560,7 +580,9 @@ public:
scalar& nearestDistSqr,
label& nearestShapeI,
point& nearestPoint
point& nearestPoint,
const FindNearestOp& fnOp
) const;
//- Find nearest to line.
@ -577,6 +599,16 @@ public:
point& linePoint
) const;
template <class FindNearestOp>
pointIndexHit findNearest
(
const linePointRef& ln,
treeBoundBox& tightest,
point& linePoint,
const FindNearestOp& fnOp
) const;
//- Find nearest intersection of line between start and end.
pointIndexHit findLine
(
@ -591,6 +623,24 @@ public:
const point& end
) const;
//- Find nearest intersection of line between start and end.
template <class FindIntersectOp>
pointIndexHit findLine
(
const point& start,
const point& end,
const FindIntersectOp& fiOp
) const;
//- Find any intersection of line between start and end.
template <class FindIntersectOp>
pointIndexHit findLineAny
(
const point& start,
const point& end,
const FindIntersectOp& fiOp
) const;
//- Find (in no particular order) indices of all shapes inside or
// overlapping bounding box (i.e. all shapes not outside box)
labelList findBox(const treeBoundBox& bb) const;

72
src/OpenFOAM/algorithms/indexedOctree/treeDataCell.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -133,6 +133,24 @@ Foam::treeDataCell::treeDataCell
}
Foam::treeDataCell::findNearestOp::findNearestOp
(
const indexedOctree<treeDataCell>& tree
)
:
tree_(tree)
{}
Foam::treeDataCell::findIntersectOp::findIntersectOp
(
const indexedOctree<treeDataCell>& tree
)
:
tree_(tree)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::pointField Foam::treeDataCell::shapePoints() const
@ -175,7 +193,7 @@ bool Foam::treeDataCell::contains
}
void Foam::treeDataCell::findNearest
void Foam::treeDataCell::findNearestOp::operator()
(
const labelUList& indices,
const point& sample,
@ -185,23 +203,51 @@ void Foam::treeDataCell::findNearest
point& nearestPoint
) const
{
const treeDataCell& shape = tree_.shapes();
forAll(indices, i)
{
label index = indices[i];
label cellI = cellLabels_[index];
scalar distSqr = magSqr(sample - mesh_.cellCentres()[cellI]);
label cellI = shape.cellLabels()[index];
scalar distSqr = magSqr(sample - shape.mesh().cellCentres()[cellI]);
if (distSqr < nearestDistSqr)
{
nearestDistSqr = distSqr;
minIndex = index;
nearestPoint = mesh_.cellCentres()[cellI];
nearestPoint = shape.mesh().cellCentres()[cellI];
}
}
}
bool Foam::treeDataCell::intersects
void Foam::treeDataCell::findNearestOp::operator()
(
const labelUList& indices,
const linePointRef& ln,
treeBoundBox& tightest,
label& minIndex,
point& linePoint,
point& nearestPoint
) const
{
notImplemented
(
"treeDataCell::findNearestOp::operator()"
"("
" const labelUList&,"
" const linePointRef&,"
" treeBoundBox&,"
" label&,"
" point&,"
" point&"
") const"
);
}
bool Foam::treeDataCell::findIntersectOp::operator()
(
const label index,
const point& start,
@ -209,10 +255,12 @@ bool Foam::treeDataCell::intersects
point& intersectionPoint
) const
{
const treeDataCell& shape = tree_.shapes();
// Do quick rejection test
if (cacheBb_)
if (shape.cacheBb_)
{
const treeBoundBox& cellBb = bbs_[index];
const treeBoundBox& cellBb = shape.bbs_[index];
if ((cellBb.posBits(start) & cellBb.posBits(end)) != 0)
{
@ -222,7 +270,7 @@ bool Foam::treeDataCell::intersects
}
else
{
const treeBoundBox cellBb = calcCellBb(cellLabels_[index]);
const treeBoundBox cellBb = shape.calcCellBb(shape.cellLabels_[index]);
if ((cellBb.posBits(start) & cellBb.posBits(end)) != 0)
{
@ -238,7 +286,7 @@ bool Foam::treeDataCell::intersects
// Disable picking up intersections behind us.
scalar oldTol = intersection::setPlanarTol(0.0);
const cell& cFaces = mesh_.cells()[cellLabels_[index]];
const cell& cFaces = shape.mesh_.cells()[shape.cellLabels_[index]];
const vector dir(end - start);
scalar minDistSqr = magSqr(dir);
@ -246,13 +294,13 @@ bool Foam::treeDataCell::intersects
forAll(cFaces, i)
{
const face& f = mesh_.faces()[cFaces[i]];
const face& f = shape.mesh_.faces()[cFaces[i]];
pointHit inter = f.ray
(
start,
dir,
mesh_.points(),
shape.mesh_.points(),
intersection::HALF_RAY
);

95
src/OpenFOAM/algorithms/indexedOctree/treeDataCell.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -80,6 +80,56 @@ class treeDataCell
public:
class findNearestOp
{
const indexedOctree<treeDataCell>& tree_;
public:
findNearestOp(const indexedOctree<treeDataCell>& tree);
void operator()
(
const labelUList& indices,
const point& sample,
scalar& nearestDistSqr,
label& minIndex,
point& nearestPoint
) const;
void operator()
(
const labelUList& indices,
const linePointRef& ln,
treeBoundBox& tightest,
label& minIndex,
point& linePoint,
point& nearestPoint
) const;
};
class findIntersectOp
{
const indexedOctree<treeDataCell>& tree_;
public:
findIntersectOp(const indexedOctree<treeDataCell>& tree);
bool operator()
(
const label index,
const point& start,
const point& end,
point& intersectionPoint
) const;
};
// Declare name of the class and its debug switch
ClassName("treeDataCell");
@ -173,49 +223,6 @@ public:
const label index,
const point& sample
) const;
//- Calculates nearest (to sample) point in shape.
// Returns actual point and distance (squared)
void findNearest
(
const labelUList& indices,
const point& sample,
scalar& nearestDistSqr,
label& nearestIndex,
point& nearestPoint
) const;
//- Calculates nearest (to line) point in shape.
// Returns point and distance (squared)
void findNearest
(
const labelUList& indices,
const linePointRef& ln,
treeBoundBox& tightest,
label& minIndex,
point& linePoint,
point& nearestPoint
) const
{
notImplemented
(
"treeDataCell::findNearest"
"(const labelUList&, const linePointRef&, ..)"
);
}
//- Calculate intersection of shape with ray. Sets result
// accordingly
bool intersects
(
const label index,
const point& start,
const point& end,
point& result
) const;
};

13
src/dynamicMesh/boundaryMesh/boundaryMesh.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -924,6 +924,11 @@ Foam::labelList Foam::boundaryMesh::getNearest
bbMax.y() += 2*tol;
bbMax.z() += 2*tol;
const scalar planarTol =
indexedOctree<treeDataPrimitivePatch<uindirectPrimitivePatch> >::
perturbTol();
// Create the octrees
indexedOctree
<
@ -933,7 +938,8 @@ Foam::labelList Foam::boundaryMesh::getNearest
treeDataPrimitivePatch<uindirectPrimitivePatch>
(
false, // cacheBb
leftPatch
leftPatch,
planarTol
),
overallBb,
10, // maxLevel
@ -948,7 +954,8 @@ Foam::labelList Foam::boundaryMesh::getNearest
treeDataPrimitivePatch<uindirectPrimitivePatch>
(
false, // cacheBb
rightPatch
rightPatch,
planarTol
),
overallBb,
10, // maxLevel

2
src/finiteVolume/interpolation/surfaceInterpolation/surfaceInterpolationScheme/surfaceInterpolationScheme.C
View File

@ -241,7 +241,7 @@ surfaceInterpolationScheme<Type>::interpolate
//- Return the face-interpolate of the given cell field
// with the given weigting factors
// with the given weighting factors
template<class Type>
tmp<GeometricField<Type, fvsPatchField, surfaceMesh> >
surfaceInterpolationScheme<Type>::interpolate

3
src/meshTools/cellClassification/cellClassification.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -34,6 +34,7 @@ License
#include "ListOps.H"
#include "meshTools.H"
#include "cpuTime.H"
#include "triSurface.H"
#include "globalMeshData.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //

4
src/meshTools/cellClassification/cellClassification.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -107,9 +107,7 @@ namespace Foam
class triSurfaceSearch;
class meshSearch;
class polyMesh;
class polyMesh;
class primitiveMesh;
class triSurface;
/*---------------------------------------------------------------------------*\
Class cellClassification Declaration

57
src/meshTools/indexedOctree/treeDataEdge.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -96,6 +96,24 @@ Foam::treeDataEdge::treeDataEdge
}
Foam::treeDataEdge::findNearestOp::findNearestOp
(
const indexedOctree<treeDataEdge>& tree
)
:
tree_(tree)
{}
Foam::treeDataEdge::findIntersectOp::findIntersectOp
(
const indexedOctree<treeDataEdge>& tree
)
:
tree_(tree)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::pointField Foam::treeDataEdge::shapePoints() const
@ -165,9 +183,7 @@ bool Foam::treeDataEdge::overlaps
}
// Calculate nearest point to sample. Updates (if any) nearestDistSqr, minIndex,
// nearestPoint.
void Foam::treeDataEdge::findNearest
void Foam::treeDataEdge::findNearestOp::operator()
(
const labelUList& indices,
const point& sample,
@ -177,13 +193,15 @@ void Foam::treeDataEdge::findNearest
point& nearestPoint
) const
{
const treeDataEdge& shape = tree_.shapes();
forAll(indices, i)
{
const label index = indices[i];
const edge& e = edges_[edgeLabels_[index]];
const edge& e = shape.edges()[shape.edgeLabels()[index]];
pointHit nearHit = e.line(points_).nearestDist(sample);
pointHit nearHit = e.line(shape.points()).nearestDist(sample);
scalar distSqr = sqr(nearHit.distance());
@ -197,9 +215,7 @@ void Foam::treeDataEdge::findNearest
}
//- Calculates nearest (to line) point in shape.
// Returns point and distance (squared)
void Foam::treeDataEdge::findNearest
void Foam::treeDataEdge::findNearestOp::operator()
(
const labelUList& indices,
const linePointRef& ln,
@ -210,6 +226,8 @@ void Foam::treeDataEdge::findNearest
point& nearestPoint
) const
{
const treeDataEdge& shape = tree_.shapes();
// Best so far
scalar nearestDistSqr = magSqr(linePoint - nearestPoint);
@ -217,13 +235,13 @@ void Foam::treeDataEdge::findNearest
{
const label index = indices[i];
const edge& e = edges_[edgeLabels_[index]];
const edge& e = shape.edges()[shape.edgeLabels()[index]];
// Note: could do bb test ? Worthwhile?
// Nearest point on line
point ePoint, lnPt;
scalar dist = e.line(points_).nearestDist(ln, ePoint, lnPt);
scalar dist = e.line(shape.points()).nearestDist(ln, ePoint, lnPt);
scalar distSqr = sqr(dist);
if (distSqr < nearestDistSqr)
@ -252,4 +270,21 @@ void Foam::treeDataEdge::findNearest
}
bool Foam::treeDataEdge::findIntersectOp::operator()
(
const label index,
const point& start,
const point& end,
point& result
) const
{
notImplemented
(
"treeDataEdge::intersects(const label, const point&,"
"const point&, point&)"
);
return false;
}
// ************************************************************************* //

108
src/meshTools/indexedOctree/treeDataEdge.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -86,6 +86,58 @@ class treeDataEdge
public:
class findNearestOp
{
const indexedOctree<treeDataEdge>& tree_;
public:
findNearestOp(const indexedOctree<treeDataEdge>& tree);
void operator()
(
const labelUList& indices,
const point& sample,
scalar& nearestDistSqr,
label& minIndex,
point& nearestPoint
) const;
void operator()
(
const labelUList& indices,
const linePointRef& ln,
treeBoundBox& tightest,
label& minIndex,
point& linePoint,
point& nearestPoint
) const;
};
class findIntersectOp
{
const indexedOctree<treeDataEdge>& tree_;
public:
findIntersectOp(const indexedOctree<treeDataEdge>& tree);
//- Calculate intersection of triangle with ray. Sets result
// accordingly
bool operator()
(
const label index,
const point& start,
const point& end,
point& intersectionPoint
) const;
};
// Declare name of the class and its debug switch
ClassName("treeDataEdge");
@ -116,6 +168,16 @@ public:
// Access
const edgeList& edges() const
{
return edges_;
}
const pointField& points() const
{
return points_;
}
const labelList& edgeLabels() const
{
return edgeLabels_;
@ -155,50 +217,6 @@ public:
const point& centre,
const scalar radiusSqr
) const;
//- Calculates nearest (to sample) point in shape.
// Returns actual point and distance (squared)
void findNearest
(
const labelUList& indices,
const point& sample,
scalar& nearestDistSqr,
label& nearestIndex,
point& nearestPoint
) const;
//- Calculates nearest (to line) point in shape.
// Returns point and distance (squared)
void findNearest
(
const labelUList& indices,
const linePointRef& ln,
treeBoundBox& tightest,
label& minIndex,
point& linePoint,
point& nearestPoint
) const;
//- Calculate intersection of shape with ray. Sets result
// accordingly
bool intersects
(
const label index,
const point& start,
const point& end,
point& result
) const
{
notImplemented
(
"treeDataEdge::intersects(const label, const point&,"
"const point&, point&)"
);
return false;
}
};

72
src/meshTools/indexedOctree/treeDataFace.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -145,6 +145,24 @@ Foam::treeDataFace::treeDataFace
}
Foam::treeDataFace::findNearestOp::findNearestOp
(
const indexedOctree<treeDataFace>& tree
)
:
tree_(tree)
{}
Foam::treeDataFace::findIntersectOp::findIntersectOp
(
const indexedOctree<treeDataFace>& tree
)
:
tree_(tree)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::pointField Foam::treeDataFace::shapePoints() const
@ -477,9 +495,7 @@ bool Foam::treeDataFace::overlaps
}
// Calculate nearest point to sample. Updates (if any) nearestDistSqr, minIndex,
// nearestPoint.
void Foam::treeDataFace::findNearest
void Foam::treeDataFace::findNearestOp::operator()
(
const labelUList& indices,
const point& sample,
@ -489,13 +505,15 @@ void Foam::treeDataFace::findNearest
point& nearestPoint
) const
{
const treeDataFace& shape = tree_.shapes();
forAll(indices, i)
{
const label index = indices[i];
const face& f = mesh_.faces()[faceLabels_[index]];
const face& f = shape.mesh().faces()[shape.faceLabels()[index]];
pointHit nearHit = f.nearestPoint(sample, mesh_.points());
pointHit nearHit = f.nearestPoint(sample, shape.mesh().points());
scalar distSqr = sqr(nearHit.distance());
if (distSqr < nearestDistSqr)
@ -508,7 +526,33 @@ void Foam::treeDataFace::findNearest
}
bool Foam::treeDataFace::intersects
void Foam::treeDataFace::findNearestOp::operator()
(
const labelUList& indices,
const linePointRef& ln,
treeBoundBox& tightest,
label& minIndex,
point& linePoint,
point& nearestPoint
) const
{
notImplemented
(
"treeDataFace::findNearestOp::operator()"
"("
" const labelUList&,"
" const linePointRef&,"
" treeBoundBox&,"
" label&,"
" point&,"
" point&"
") const"
);
}
bool Foam::treeDataFace::findIntersectOp::operator()
(
const label index,
const point& start,
@ -516,10 +560,12 @@ bool Foam::treeDataFace::intersects
point& intersectionPoint
) const
{
const treeDataFace& shape = tree_.shapes();
// Do quick rejection test
if (cacheBb_)
if (shape.cacheBb_)
{
const treeBoundBox& faceBb = bbs_[index];
const treeBoundBox& faceBb = shape.bbs_[index];
if ((faceBb.posBits(start) & faceBb.posBits(end)) != 0)
{
@ -528,16 +574,16 @@ bool Foam::treeDataFace::intersects
}
}
const label faceI = faceLabels_[index];
const label faceI = shape.faceLabels_[index];
const vector dir(end - start);
pointHit inter = mesh_.faces()[faceI].intersection
pointHit inter = shape.mesh_.faces()[faceI].intersection
(
start,
dir,
mesh_.faceCentres()[faceI],
mesh_.points(),
shape.mesh_.faceCentres()[faceI],
shape.mesh_.points(),
intersection::HALF_RAY
);

100
src/meshTools/indexedOctree/treeDataFace.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -39,6 +39,7 @@ SourceFiles
#include "indexedOctree.H"
#include "treeBoundBoxList.H"
#include "PackedBoolList.H"
#include "primitiveMesh.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -46,7 +47,7 @@ namespace Foam
{
// Forward declaration of classes
class primitiveMesh;
//class primitiveMesh;
//template<class Type> class indexedOctree;
class polyPatch;
@ -90,6 +91,58 @@ class treeDataFace
public:
class findNearestOp
{
const indexedOctree<treeDataFace>& tree_;
public:
findNearestOp(const indexedOctree<treeDataFace>& tree);
void operator()
(
const labelUList& indices,
const point& sample,
scalar& nearestDistSqr,
label& minIndex,
point& nearestPoint
) const;
void operator()
(
const labelUList& indices,
const linePointRef& ln,
treeBoundBox& tightest,
label& minIndex,
point& linePoint,
point& nearestPoint
) const;
};
class findIntersectOp
{
const indexedOctree<treeDataFace>& tree_;
public:
findIntersectOp(const indexedOctree<treeDataFace>& tree);
//- Calculate intersection of triangle with ray. Sets result
// accordingly
bool operator()
(
const label index,
const point& start,
const point& end,
point& intersectionPoint
) const;
};
// Declare name of the class and its debug switch
ClassName("treeDataFace");
@ -159,49 +212,6 @@ public:
const label index,
const treeBoundBox& sampleBb
) const;
//- Calculates nearest (to sample) point in shape.
// Returns actual point and distance (squared)
void findNearest
(
const labelUList& indices,
const point& sample,
scalar& nearestDistSqr,
label& nearestIndex,
point& nearestPoint
) const;
//- Calculates nearest (to line) point in shape.
// Returns point and distance (squared)
void findNearest
(
const labelUList& indices,
const linePointRef& ln,
treeBoundBox& tightest,
label& minIndex,
point& linePoint,
point& nearestPoint
) const
{
notImplemented
(
"treeDataFace::findNearest"
"(const labelUList&, const linePointRef&, ..)"
);
}
//- Calculate intersection of shape with ray. Sets result
// accordingly
bool intersects
(
const label index,
const point& start,
const point& end,
point& result
) const;
};

65
src/meshTools/indexedOctree/treeDataPoint.C
View File

@ -57,6 +57,24 @@ Foam::treeDataPoint::treeDataPoint
{}
Foam::treeDataPoint::findNearestOp::findNearestOp
(
const indexedOctree<treeDataPoint>& tree
)
:
tree_(tree)
{}
Foam::treeDataPoint::findIntersectOp::findIntersectOp
(
const indexedOctree<treeDataPoint>& tree
)
:
tree_(tree)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::pointField Foam::treeDataPoint::shapePoints() const
@ -115,9 +133,7 @@ bool Foam::treeDataPoint::overlaps
}
// Calculate nearest point to sample. Updates (if any) nearestDistSqr, minIndex,
// nearestPoint.
void Foam::treeDataPoint::findNearest
void Foam::treeDataPoint::findNearestOp::operator()
(
const labelUList& indices,
const point& sample,
@ -127,12 +143,19 @@ void Foam::treeDataPoint::findNearest
point& nearestPoint
) const
{
const treeDataPoint& shape = tree_.shapes();
forAll(indices, i)
{
const label index = indices[i];
label pointI = (useSubset_ ? pointLabels_[index] : index);
label pointI =
(
shape.useSubset()
? shape.pointLabels()[index]
: index
);
const point& pt = points_[pointI];
const point& pt = shape.points()[pointI];
scalar distSqr = magSqr(pt - sample);
@ -146,9 +169,7 @@ void Foam::treeDataPoint::findNearest
}
//- Calculates nearest (to line) point in shape.
// Returns point and distance (squared)
void Foam::treeDataPoint::findNearest
void Foam::treeDataPoint::findNearestOp::operator()
(
const labelUList& indices,
const linePointRef& ln,
@ -159,6 +180,8 @@ void Foam::treeDataPoint::findNearest
point& nearestPoint
) const
{
const treeDataPoint& shape = tree_.shapes();
// Best so far
scalar nearestDistSqr = GREAT;
if (minIndex >= 0)
@ -169,9 +192,14 @@ void Foam::treeDataPoint::findNearest
forAll(indices, i)
{
const label index = indices[i];
label pointI = (useSubset_ ? pointLabels_[index] : index);
label pointI =
(
shape.useSubset()
? shape.pointLabels()[index]
: index
);
const point& shapePt = points_[pointI];
const point& shapePt = shape.points()[pointI];
if (tightest.contains(shapePt))
{
@ -206,4 +234,21 @@ void Foam::treeDataPoint::findNearest
}
bool Foam::treeDataPoint::findIntersectOp::operator()
(
const label index,
const point& start,
const point& end,
point& result
) const
{
notImplemented
(
"treeDataPoint::intersects(const label, const point&,"
"const point&, point&)"
);
return false;
}
// ************************************************************************* //

103
src/meshTools/indexedOctree/treeDataPoint.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -69,6 +69,58 @@ class treeDataPoint
public:
class findNearestOp
{
const indexedOctree<treeDataPoint>& tree_;
public:
findNearestOp(const indexedOctree<treeDataPoint>& tree);
void operator()
(
const labelUList& indices,
const point& sample,
scalar& nearestDistSqr,
label& minIndex,
point& nearestPoint
) const;
void operator()
(
const labelUList& indices,
const linePointRef& ln,
treeBoundBox& tightest,
label& minIndex,
point& linePoint,
point& nearestPoint
) const;
};
class findIntersectOp
{
const indexedOctree<treeDataPoint>& tree_;
public:
findIntersectOp(const indexedOctree<treeDataPoint>& tree);
//- Calculate intersection of triangle with ray. Sets result
// accordingly
bool operator()
(
const label index,
const point& start,
const point& end,
point& intersectionPoint
) const;
};
// Declare name of the class and its debug switch
ClassName("treeDataPoint");
@ -106,6 +158,11 @@ public:
return points_;
}
bool useSubset() const
{
return useSubset_;
}
//- Get representative point cloud for all shapes inside
// (one point per shape)
pointField shapePoints() const;
@ -135,50 +192,6 @@ public:
const point& centre,
const scalar radiusSqr
) const;
//- Calculates nearest (to sample) point in shape.
// Returns actual point and distance (squared)
void findNearest
(
const labelUList& indices,
const point& sample,
scalar& nearestDistSqr,
label& nearestIndex,
point& nearestPoint
) const;
//- Calculates nearest (to line) point in shape.
// Returns point and distance (squared)
void findNearest
(
const labelUList& indices,
const linePointRef& ln,
treeBoundBox& tightest,
label& minIndex,
point& linePoint,
point& nearestPoint
) const;
//- Calculate intersection of shape with ray. Sets result
// accordingly
bool intersects
(
const label index,
const point& start,
const point& end,
point& result
) const
{
notImplemented
(
"treeDataPoint::intersects(const label, const point&,"
"const point&, point&)"
);
return false;
}
};

250
src/meshTools/indexedOctree/treeDataPrimitivePatch.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -26,12 +26,8 @@ License
#include "treeDataPrimitivePatch.H"
#include "indexedOctree.H"
#include "triangleFuncs.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
template<class PatchType>
Foam::scalar Foam::treeDataPrimitivePatch<PatchType>::tolSqr = sqr(1e-6);
#include "triSurfaceTools.H"
#include "triFace.H"
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
@ -70,6 +66,75 @@ void Foam::treeDataPrimitivePatch<PatchType>::update()
}
template<class PatchType>
bool Foam::treeDataPrimitivePatch<PatchType>::findIntersection
(
const indexedOctree<treeDataPrimitivePatch<PatchType> >& tree,
const label index,
const point& start,
const point& end,
point& intersectionPoint
)
{
const treeDataPrimitivePatch<PatchType>& shape = tree.shapes();
const PatchType& patch = shape.patch();
const pointField& points = patch.points();
const typename PatchType::FaceType& f = patch[index];
// Do quick rejection test
if (shape.cacheBb_)
{
const treeBoundBox& faceBb = shape.bbs_[index];
if ((faceBb.posBits(start) & faceBb.posBits(end)) != 0)
{
// start and end in same block outside of faceBb.
return false;
}
}
const vector dir(end - start);
pointHit inter;
if (f.size() == 3)
{
inter = triPointRef
(
points[f[0]],
points[f[1]],
points[f[2]]
).intersection(start, dir, intersection::HALF_RAY, shape.planarTol_);
}
else
{
const pointField& faceCentres = patch.faceCentres();
inter = f.intersection
(
start,
dir,
faceCentres[index],
points,
intersection::HALF_RAY
);
}
if (inter.hit() && inter.distance() <= 1)
{
// Note: no extra test on whether intersection is in front of us
// since using half_ray
intersectionPoint = inter.hitPoint();
return true;
}
else
{
return false;
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// Construct from components
@ -77,16 +142,50 @@ template<class PatchType>
Foam::treeDataPrimitivePatch<PatchType>::treeDataPrimitivePatch
(
const bool cacheBb,
const PatchType& patch
const PatchType& patch,
const scalar planarTol
)
:
patch_(patch),
cacheBb_(cacheBb)
cacheBb_(cacheBb),
planarTol_(planarTol)
{
update();
}
template<class PatchType>
Foam::treeDataPrimitivePatch<PatchType>::findNearestOp::findNearestOp
(
const indexedOctree<treeDataPrimitivePatch<PatchType> >& tree
)
:
tree_(tree)
{}
template<class PatchType>
Foam::treeDataPrimitivePatch<PatchType>::findIntersectOp::findIntersectOp
(
const indexedOctree<treeDataPrimitivePatch<PatchType> >& tree
)
:
tree_(tree)
{}
template<class PatchType>
Foam::treeDataPrimitivePatch<PatchType>::findAllIntersectOp::findAllIntersectOp
(
const indexedOctree<treeDataPrimitivePatch<PatchType> >& tree,
DynamicList<label>& shapeMask
)
:
tree_(tree),
shapeMask_(shapeMask)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class PatchType>
@ -106,7 +205,7 @@ Foam::pointField Foam::treeDataPrimitivePatch<PatchType>::shapePoints() const
//- Get type (inside,outside,mixed,unknown) of point w.r.t. surface.
// Only makes sense for closed surfaces.
template<class PatchType>
Foam::label Foam::treeDataPrimitivePatch<PatchType>:: getVolumeType
Foam::label Foam::treeDataPrimitivePatch<PatchType>::getVolumeType
(
const indexedOctree<treeDataPrimitivePatch<PatchType> >& oc,
const point& sample
@ -136,7 +235,6 @@ Foam::label Foam::treeDataPrimitivePatch<PatchType>:: getVolumeType
<< abort(FatalError);
}
// Get actual intersection point on face
label faceI = info.index();
@ -147,7 +245,7 @@ Foam::label Foam::treeDataPrimitivePatch<PatchType>:: getVolumeType
}
const pointField& points = patch_.localPoints();
const face& f = patch_.localFaces()[faceI];
const typename PatchType::FaceType& f = patch_.localFaces()[faceI];
// Retest to classify where on face info is. Note: could be improved. We
// already have point.
@ -188,9 +286,10 @@ Foam::label Foam::treeDataPrimitivePatch<PatchType>:: getVolumeType
const scalar typDimSqr = mag(area) + VSMALL;
forAll(f, fp)
{
if ((magSqr(points[f[fp]] - curPt)/typDimSqr) < tolSqr)
if ((magSqr(points[f[fp]] - curPt)/typDimSqr) < planarTol_)
{
// Face intersection point equals face vertex fp
@ -207,7 +306,7 @@ Foam::label Foam::treeDataPrimitivePatch<PatchType>:: getVolumeType
const point fc(f.centre(points));
if ((magSqr(fc - curPt)/typDimSqr) < tolSqr)
if ((magSqr(fc - curPt)/typDimSqr) < planarTol_)
{
// Face intersection point equals face centre. Normal at face centre
// is already average of face normals
@ -240,7 +339,7 @@ Foam::label Foam::treeDataPrimitivePatch<PatchType>:: getVolumeType
pointHit edgeHit = e.line(points).nearestDist(sample);
if ((magSqr(edgeHit.rawPoint() - curPt)/typDimSqr) < tolSqr)
if ((magSqr(edgeHit.rawPoint() - curPt)/typDimSqr) < planarTol_)
{
// Face intersection point lies on edge e
@ -285,7 +384,7 @@ Foam::label Foam::treeDataPrimitivePatch<PatchType>:: getVolumeType
fc
).nearestDist(sample);
if ((magSqr(edgeHit.rawPoint() - curPt)/typDimSqr) < tolSqr)
if ((magSqr(edgeHit.rawPoint() - curPt)/typDimSqr) < planarTol_)
{
// Face intersection point lies on edge between two face triangles
@ -368,7 +467,7 @@ bool Foam::treeDataPrimitivePatch<PatchType>::overlaps
// 2. Check if one or more face points inside
const pointField& points = patch_.points();
const face& f = patch_[index];
const typename PatchType::FaceType& f = patch_[index];
if (cubeBb.containsAny(points, f))
{
@ -379,21 +478,35 @@ bool Foam::treeDataPrimitivePatch<PatchType>::overlaps
// go through cube. Use triangle-bounding box intersection.
const point fc = f.centre(points);
forAll(f, fp)
if (f.size() == 3)
{
bool triIntersects = triangleFuncs::intersectBb
return triangleFuncs::intersectBb
(
points[f[fp]],
points[f[f.fcIndex(fp)]],
fc,
points[f[0]],
points[f[1]],
points[f[2]],
cubeBb
);
if (triIntersects)
}
else
{
forAll(f, fp)
{
return true;
bool triIntersects = triangleFuncs::intersectBb
(
points[f[fp]],
points[f[f.fcIndex(fp)]],
fc,
cubeBb
);
if (triIntersects)
{
return true;
}
}
}
return false;
}
@ -439,10 +552,8 @@ bool Foam::treeDataPrimitivePatch<PatchType>::overlaps
}
// Calculate nearest point to sample. Updates (if any) nearestDistSqr, minIndex,
// nearestPoint.
template<class PatchType>
void Foam::treeDataPrimitivePatch<PatchType>::findNearest
void Foam::treeDataPrimitivePatch<PatchType>::findNearestOp::operator()
(
const labelUList& indices,
const point& sample,
@ -452,13 +563,15 @@ void Foam::treeDataPrimitivePatch<PatchType>::findNearest
point& nearestPoint
) const
{
const pointField& points = patch_.points();
const treeDataPrimitivePatch<PatchType>& shape = tree_.shapes();
const PatchType& patch = shape.patch();
const pointField& points = patch.points();
forAll(indices, i)
{
const label index = indices[i];
const face& f = patch_[index];
const typename PatchType::FaceType& f = patch[index];
pointHit nearHit = f.nearestPoint(sample, points);
scalar distSqr = sqr(nearHit.distance());
@ -474,7 +587,34 @@ void Foam::treeDataPrimitivePatch<PatchType>::findNearest
template<class PatchType>
bool Foam::treeDataPrimitivePatch<PatchType>::intersects
void Foam::treeDataPrimitivePatch<PatchType>::findNearestOp::operator()
(
const labelUList& indices,
const linePointRef& ln,
treeBoundBox& tightest,
label& minIndex,
point& linePoint,
point& nearestPoint
) const
{
notImplemented
(
"treeDataPrimitivePatch<PatchType>::findNearestOp::operator()"
"("
" const labelUList&,"
" const linePointRef&,"
" treeBoundBox&,"
" label&,"
" point&,"
" point&"
") const"
);
}
template<class PatchType>
bool Foam::treeDataPrimitivePatch<PatchType>::findIntersectOp::operator()
(
const label index,
const point& start,
@ -482,43 +622,25 @@ bool Foam::treeDataPrimitivePatch<PatchType>::intersects
point& intersectionPoint
) const
{
// Do quick rejection test
if (cacheBb_)
{
const treeBoundBox& faceBb = bbs_[index];
return findIntersection(tree_, index, start, end, intersectionPoint);
}
if ((faceBb.posBits(start) & faceBb.posBits(end)) != 0)
{
// start and end in same block outside of faceBb.
return false;
}
}
const pointField& points = patch_.points();
const face& f = patch_[index];
const point fc = f.centre(points);
const vector dir(end - start);
pointHit inter = patch_[index].intersection
(
start,
dir,
fc,
points,
intersection::HALF_RAY
);
if (inter.hit() && inter.distance() <= 1)
{
// Note: no extra test on whether intersection is in front of us
// since using half_ray
intersectionPoint = inter.hitPoint();
return true;
}
else
template<class PatchType>
bool Foam::treeDataPrimitivePatch<PatchType>::findAllIntersectOp::operator()
(
const label index,
const point& start,
const point& end,
point& intersectionPoint
) const
{
if (!shapeMask_.empty() && findIndex(shapeMask_, index) != -1)
{
return false;
}
return findIntersection(tree_, index, start, end, intersectionPoint);
}

149
src/meshTools/indexedOctree/treeDataPrimitivePatch.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -35,8 +35,6 @@ SourceFiles
#ifndef treeDataPrimitivePatch_H
#define treeDataPrimitivePatch_H
#include "PrimitivePatch.H"
//#include "indexedOctree.H"
#include "treeBoundBoxList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -64,11 +62,6 @@ class treeDataPrimitivePatch
:
public treeDataPrimitivePatchName
{
// Static data
//- tolerance on linear dimensions
static scalar tolSqr;
// Private data
//- Underlying geometry
@ -77,6 +70,9 @@ class treeDataPrimitivePatch
//- Whether to precalculate and store face bounding box
const bool cacheBb_;
//- Tolerance to use for intersection tests
const scalar planarTol_;
//- face bounding boxes (valid only if cacheBb_)
treeBoundBoxList bbs_;
@ -89,15 +85,107 @@ class treeDataPrimitivePatch
//- Initialise all member data
void update();
//- Find intersection of line with shapes
static bool findIntersection
(
const indexedOctree<treeDataPrimitivePatch<PatchType> >& tree,
const label index,
const point& start,
const point& end,
point& intersectionPoint
);
public:
class findNearestOp
{
const indexedOctree<treeDataPrimitivePatch>& tree_;
public:
findNearestOp(const indexedOctree<treeDataPrimitivePatch>& tree);
void operator()
(
const labelUList& indices,
const point& sample,
scalar& nearestDistSqr,
label& minIndex,
point& nearestPoint
) const;
//- Calculates nearest (to line) point in shape.
// Returns point and distance (squared)
void operator()
(
const labelUList& indices,
const linePointRef& ln,
treeBoundBox& tightest,
label& minIndex,
point& linePoint,
point& nearestPoint
) const;
};
class findIntersectOp
{
const indexedOctree<treeDataPrimitivePatch>& tree_;
public:
findIntersectOp(const indexedOctree<treeDataPrimitivePatch>& tree);
//- Calculate intersection of triangle with ray. Sets result
// accordingly
bool operator()
(
const label index,
const point& start,
const point& end,
point& intersectionPoint
) const;
};
class findAllIntersectOp
{
const indexedOctree<treeDataPrimitivePatch>& tree_;
DynamicList<label>& shapeMask_;
public:
findAllIntersectOp
(
const indexedOctree<treeDataPrimitivePatch>& tree,
DynamicList<label>& shapeMask
);
//- Calculate intersection of triangle with ray. Sets result
// accordingly
bool operator()
(
const label index,
const point& start,
const point& end,
point& intersectionPoint
) const;
};
// Constructors
//- Construct from patch.
treeDataPrimitivePatch
(
const bool cacheBb,
const PatchType&
const PatchType&,
const scalar planarTol
);
@ -145,49 +233,6 @@ public:
const point& centre,
const scalar radiusSqr
) const;
//- Calculates nearest (to sample) point in shape.
// Returns actual point and distance (squared)
void findNearest
(
const labelUList& indices,
const point& sample,
scalar& nearestDistSqr,
label& nearestIndex,
point& nearestPoint
) const;
//- Calculates nearest (to line) point in shape.
// Returns point and distance (squared)
void findNearest
(
const labelUList& indices,
const linePointRef& ln,
treeBoundBox& tightest,
label& minIndex,
point& linePoint,
point& nearestPoint
) const
{
notImplemented
(
"treeDataPrimitivePatch::findNearest"
"(const labelUList&, const linePointRef&, ..)"
);
}
//- Calculate intersection of shape with ray. Sets result
// accordingly
bool intersects
(
const label index,
const point& start,
const point& end,
point& result
) const;
};

477
src/meshTools/indexedOctree/treeDataTriSurface.C
View File

@ -25,491 +25,58 @@ License
#include "treeDataTriSurface.H"
#include "triSurfaceTools.H"
#include "triangleFuncs.H"
#include "indexedOctree.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(treeDataTriSurface, 0);
}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
// // Fast distance to triangle calculation. From
// // "Distance Between Point and Triangle in 3D"
// // David Eberly, Magic Software Inc. Aug. 2003.
// // Works on function Q giving distance to point and tries to minimize this.
// Foam::scalar Foam::treeDataTriSurface::nearestCoords
// (
// const point& base,
// const point& E0,
// const point& E1,
// const scalar a,
// const scalar b,
// const scalar c,
// const point& P,
// scalar& s,
// scalar& t
// )
// {
// // distance vector
// const vector D(base - P);
// // Precalculate distance factors.
// const scalar d = E0 & D;
// const scalar e = E1 & D;
// // Do classification
// const scalar det = a*c - b*b;
// s = b*e - c*d;
// t = b*d - a*e;
// if (s+t < det)
// {
// if (s < 0)
// {
// if (t < 0)
// {
// //region 4
// if (e > 0)
// {
// //min on edge t = 0
// t = 0;
// s = (d >= 0 ? 0 : (-d >= a ? 1 : -d/a));
// }
// else
// {
// //min on edge s=0
// s = 0;
// t = (e >= 0 ? 0 : (-e >= c ? 1 : -e/c));
// }
// }
// else
// {
// //region 3. Min on edge s = 0
// s = 0;
// t = (e >= 0 ? 0 : (-e >= c ? 1 : -e/c));
// }
// }
// else if (t < 0)
// {
// //region 5
// t = 0;
// s = (d >= 0 ? 0 : (-d >= a ? 1 : -d/a));
// }
// else
// {
// //region 0
// const scalar invDet = 1/det;
// s *= invDet;
// t *= invDet;
// }
// }
// else
// {
// if (s < 0)
// {
// //region 2
// const scalar tmp0 = b + d;
// const scalar tmp1 = c + e;
// if (tmp1 > tmp0)
// {
// //min on edge s+t=1
// const scalar numer = tmp1 - tmp0;
// const scalar denom = a-2*b+c;
// s = (numer >= denom ? 1 : numer/denom);
// t = 1 - s;
// }
// else
// {
// //min on edge s=0
// s = 0;
// t = (tmp1 <= 0 ? 1 : (e >= 0 ? 0 : - e/c));
// }
// }
// else if (t < 0)
// {
// //region 6
// const scalar tmp0 = b + d;
// const scalar tmp1 = c + e;
// if (tmp1 > tmp0)
// {
// //min on edge s+t=1
// const scalar numer = tmp1 - tmp0;
// const scalar denom = a-2*b+c;
// s = (numer >= denom ? 1 : numer/denom);
// t = 1 - s;
// }
// else
// {
// //min on edge t=0
// t = 0;
// s = (tmp1 <= 0 ? 1 : (d >= 0 ? 0 : - d/a));
// }
// }
// else
// {
// //region 1
// const scalar numer = c+e-(b+d);
// if (numer <= 0)
// {
// s = 0;
// }
// else
// {
// const scalar denom = a-2*b+c;
// s = (numer >= denom ? 1 : numer/denom);
// }
// }
// t = 1 - s;
// }
// // Calculate distance.
// // Note: abs should not be needed but truncation error causes problems
// // with points very close to one of the triangle vertices.
// // (seen up to -9e-15). Alternatively add some small value.
// const scalar f = D & D;
// return Foam::mag(a*s*s + 2*b*s*t + c*t*t + 2*d*s + 2*e*t + f);
// }
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// Construct from components
Foam::treeDataTriSurface::treeDataTriSurface
template<>
Foam::label Foam::treeDataPrimitivePatch<Foam::triSurface>::getVolumeType
(
const triSurface& surface,
const scalar planarTol
)
:
surface_(surface),
planarTol_(planarTol)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::pointField Foam::treeDataTriSurface::shapePoints() const
{
const pointField& points = surface_.points();
pointField centres(surface_.size());
forAll(surface_, triI)
{
centres[triI] = surface_[triI].centre(points);
}
return centres;
}
//- Get type of sample (inside/outside/mixed) w.r.t. surface.
Foam::label Foam::treeDataTriSurface::getVolumeType
(
const indexedOctree<treeDataTriSurface>& tree,
const indexedOctree<treeDataPrimitivePatch<triSurface> >& oc,
const point& sample
) const
{
// Find nearest point
const treeBoundBox& treeBb = tree.bb();
// Find nearest face to sample
pointIndexHit info = oc.findNearest(sample, sqr(GREAT));
pointIndexHit pHit = tree.findNearest
(
sample,
max
(
Foam::sqr(GREAT),
Foam::magSqr(treeBb.span())
)
);
if (!pHit.hit())
if (info.index() == -1)
{
FatalErrorIn("treeDataTriSurface::getVolumeType(..)")
<< "treeBb:" << treeBb
<< " sample:" << sample
<< " pHit:" << pHit
FatalErrorIn
(
"treeDataPrimitivePatch::getSampleType"
"(indexedOctree<treeDataPrimitivePatch>&, const point&)"
) << "Could not find " << sample << " in octree."
<< abort(FatalError);
}
// Get actual intersection point on face
label faceI = info.index();
triSurfaceTools::sideType t = triSurfaceTools::surfaceSide
(
surface_,
patch_,
sample,
pHit.index()
faceI
);
if (t == triSurfaceTools::UNKNOWN)
{
return indexedOctree<treeDataTriSurface>::UNKNOWN;
return indexedOctree<treeDataPrimitivePatch<triSurface> >::UNKNOWN;
}
else if (t == triSurfaceTools::INSIDE)
{
return indexedOctree<treeDataTriSurface>::INSIDE;
return indexedOctree<treeDataPrimitivePatch<triSurface> >::INSIDE;
}
else if (t == triSurfaceTools::OUTSIDE)
{
return indexedOctree<treeDataTriSurface>::OUTSIDE;
return indexedOctree<treeDataPrimitivePatch<triSurface> >::OUTSIDE;
}
else
{
FatalErrorIn("treeDataTriSurface::getVolumeType(..)")
FatalErrorIn("treeDataPrimitivePatch<PatchType>::getVolumeType(..)")
<< "problem" << abort(FatalError);
return indexedOctree<treeDataTriSurface>::UNKNOWN;
return indexedOctree<treeDataPrimitivePatch<triSurface> >::UNKNOWN;
}
}
// Check if any point on triangle is inside cubeBb.
bool Foam::treeDataTriSurface::overlaps
(
const label index,
const treeBoundBox& cubeBb
) const
{
const pointField& points = surface_.points();
const labelledTri& f = surface_[index];
treeBoundBox triBb(points, surface_[index]);
//- For testing: robust one
//return cubeBb.overlaps(triBb);
//- Exact test of triangle intersecting bb
// Quick rejection. If whole bounding box of tri is outside cubeBb then
// there will be no intersection.
if (!cubeBb.overlaps(triBb))
{
return false;
}
// Check if one or more triangle point inside
if (cubeBb.containsAny(points, f))
{
return true;
}
// Triangle points
const point& p0 = points[f[0]];
const point& p1 = points[f[1]];
const point& p2 = points[f[2]];
// Now we have the difficult case: all points are outside but connecting
// edges might go through cube. Use fast intersection of bounding box.
//return triangleFuncs::intersectBbExact(p0, p1, p2, cubeBb);
return triangleFuncs::intersectBb(p0, p1, p2, cubeBb);
}
// Calculate nearest point to sample. Updates (if any) nearestDistSqr, minIndex,
// nearestPoint.
void Foam::treeDataTriSurface::findNearest
(
const labelUList& indices,
const point& sample,
scalar& nearestDistSqr,
label& minIndex,
point& nearestPoint
) const
{
const pointField& points = surface_.points();
forAll(indices, i)
{
label index = indices[i];
const triSurface::FaceType& f = surface_[index];
////- Possible optimization: do quick rejection of triangle if bounding
//// sphere does not intersect triangle bounding box. From simplistic
//// test was not found to speed up things.
//
//// Triangle bounding box.
//point triBbMin = min(p0, min(p1, p2));
//point triBbMax = max(p0, max(p1, p2));
//
//if
//(
// indexedOctree<treeDataTriSurface>::intersects
// (
// triBbMin,
// triBbMax,
// nearestDistSqr,
// sample
// )
//)
{
// // Get spanning vectors of triangle
// vector base(p1);
// vector E0(p0 - p1);
// vector E1(p2 - p1);
// scalar a(E0& E0);
// scalar b(E0& E1);
// scalar c(E1& E1);
// // Get nearest point in s,t coordinates (s is along E0, t
// // is along E1)
// scalar s;
// scalar t;
// scalar distSqr = nearestCoords
// (
// base,
// E0,
// E1,
// a,
// b,
// c,
// sample,
// s,
// t
// );
pointHit pHit = f.nearestPoint(sample, points);
scalar distSqr = sqr(pHit.distance());
if (distSqr < nearestDistSqr)
{
nearestDistSqr = distSqr;
minIndex = index;
nearestPoint = pHit.rawPoint();
}
}
}
}
// Calculate nearest point to line. Updates (if any) nearestDistSqr, minIndex,
// nearestPoint.
void Foam::treeDataTriSurface::findNearest
(
const labelUList& indices,
const linePointRef& ln,
treeBoundBox& tightest,
label& minIndex,
point& linePoint,
point& nearestPoint
) const
{
// Best so far
scalar nearestDistSqr = VGREAT;
if (minIndex >= 0)
{
nearestDistSqr = magSqr(linePoint - nearestPoint);
}
const pointField& points = surface_.points();
forAll(indices, i)
{
label index = indices[i];
const triSurface::FaceType& f = surface_[index];
triPointRef tri(f.tri(points));
pointHit lineInfo(point::max);
pointHit pHit = tri.nearestPoint(ln, lineInfo);
scalar distSqr = sqr(pHit.distance());
if (distSqr < nearestDistSqr)
{
nearestDistSqr = distSqr;
minIndex = index;
linePoint = lineInfo.rawPoint();
nearestPoint = pHit.rawPoint();
{
point& minPt = tightest.min();
minPt = min(ln.start(), ln.end());
minPt.x() -= pHit.distance();
minPt.y() -= pHit.distance();
minPt.z() -= pHit.distance();
}
{
point& maxPt = tightest.max();
maxPt = max(ln.start(), ln.end());
maxPt.x() += pHit.distance();
maxPt.y() += pHit.distance();
maxPt.z() += pHit.distance();
}
}
}
}
bool Foam::treeDataTriSurface::intersects
(
const label index,
const point& start,
const point& end,
point& intersectionPoint
) const
{
const pointField& points = surface_.points();
const triSurface::FaceType& f = surface_[index];
// Do quick rejection test
treeBoundBox triBb(points, f);
const direction startBits(triBb.posBits(start));
const direction endBits(triBb.posBits(end));
if ((startBits & endBits) != 0)
{
// start and end in same block outside of triBb.
return false;
}
const vector dir(end - start);
// Use relative tolerance (from octree) to determine intersection.
pointHit inter = f.intersection
(
start,
dir,
points,
intersection::HALF_RAY,
planarTol_
);
if (inter.hit() && inter.distance() <= 1)
{
// Note: no extra test on whether intersection is in front of us
// since using half_ray.
intersectionPoint = inter.hitPoint();
return true;
}
else
{
return false;
}
//- Using exact intersections
//pointHit info = f.tri(points).intersectionExact(start, end);
//
//if (info.hit())
//{
// intersectionPoint = info.hitPoint();
//}
//return info.hit();
}
// ************************************************************************* //

141
src/meshTools/indexedOctree/treeDataTriSurface.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -25,7 +25,7 @@ Class
Foam::treeDataTriSurface
Description
Encapsulates data for (indexedOc)tree searches on triSurface.
Encapsulates data for (indexedOc)tree searches on a triSurface.
SourceFiles
treeDataTriSurface.C
@ -35,139 +35,26 @@ SourceFiles
#ifndef treeDataTriSurface_H
#define treeDataTriSurface_H
#include "treeDataPrimitivePatch.H"
#include "triSurface.H"
#include "point.H"
#include "indexedOctree.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
typedef treeDataPrimitivePatch<triSurface> treeDataTriSurface;
// Forward declaration of classes
class treeBoundBox;
class treeDataTriSurface;
template<class Type> class indexedOctree;
//- Template specialisation of getVolumeType for treeDataTriSurface
template<>
label treeDataPrimitivePatch<triSurface>::getVolumeType
(
const indexedOctree<treeDataPrimitivePatch<triSurface> >& oc,
const point& sample
) const;
}
/*---------------------------------------------------------------------------*\
Class treeDataTriSurface Declaration
\*---------------------------------------------------------------------------*/
class treeDataTriSurface
{
// Private data
//- Reference to triSurface
const triSurface& surface_;
//- Tolerance to use for intersection tests
const scalar planarTol_;
// Private Member Functions
// //- fast triangle nearest point calculation. Returns point in E0, E1
// // coordinate system: base + s*E0 + t*E1
// static scalar nearestCoords
// (
// const point& base,
// const point& E0,
// const point& E1,
// const scalar a,
// const scalar b,
// const scalar c,
// const point& P,
// scalar& s,
// scalar& t
// );
public:
// Declare name of the class and its debug switch
ClassName("treeDataTriSurface");
// Constructors
//- Construct from triSurface and tolerance for intersection
// tests. Holds reference.
treeDataTriSurface(const triSurface&, const scalar planarTol);
// Member Functions
// Access
inline const triSurface& surface() const
{
return surface_;
}
inline label size() const
{
return surface_.size();
}
//- Get representative point cloud for all shapes inside
// (one point per shape)
pointField shapePoints() const;
// Search
//- Get type (inside,outside,mixed,unknown) of point w.r.t. surface.
// Only makes sense for closed surfaces.
label getVolumeType
(
const indexedOctree<treeDataTriSurface>&,
const point&
) const;
//- Does (bb of) shape at index overlap bb
bool overlaps
(
const label index,
const treeBoundBox& sampleBb
) const;
//- Calculates nearest (to sample) point in shape.
// Returns actual point and distance (squared)
void findNearest
(
const labelUList& indices,
const point& sample,
scalar& nearestDistSqr,
label& nearestIndex,
point& nearestPoint
) const;
//- Calculates nearest (to line) point in shape.
// Returns point and distance (squared)
void findNearest
(
const labelUList& indices,
const linePointRef& ln,
treeBoundBox& tightest,
label& minIndex,
point& linePoint,
point& nearestPoint
) const;
//- Calculate intersection of triangle with ray. Sets result
// accordingly
bool intersects
(
const label index,
const point& start,
const point& end,
point& result
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

6
src/meshTools/searchableSurface/triSurfaceMesh.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -564,7 +564,7 @@ Foam::triSurfaceMesh::tree() const
(
new indexedOctree<treeDataTriSurface>
(
treeDataTriSurface(*this, tolerance_),
treeDataTriSurface(true, *this, tolerance_),
bb,
maxTreeDepth_, // maxLevel
10, // leafsize
@ -609,7 +609,7 @@ Foam::triSurfaceMesh::edgeTree() const
bb.min() -= point(ROOTVSMALL, ROOTVSMALL, ROOTVSMALL);
bb.max() += point(ROOTVSMALL, ROOTVSMALL, ROOTVSMALL);
scalar oldTol = indexedOctree<treeDataTriSurface>::perturbTol();
scalar oldTol = indexedOctree<treeDataEdge>::perturbTol();
indexedOctree<treeDataEdge>::perturbTol() = tolerance_;
edgeTree_.reset

3
src/meshTools/sets/pointSources/surfaceToPoint/surfaceToPoint.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -26,6 +26,7 @@ License
#include "surfaceToPoint.H"
#include "polyMesh.H"
#include "triSurfaceSearch.H"
#include "triSurface.H"
#include "cpuTime.H"
#include "addToRunTimeSelectionTable.H"

3
src/meshTools/triSurface/triSurfaceSearch/triSurfaceSearch.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -66,6 +66,7 @@ Foam::triSurfaceSearch::triSurfaceSearch(const triSurface& surface)
(
treeDataTriSurface
(
true,
surface_,
indexedOctree<treeDataTriSurface>::perturbTol()
),

3
src/meshTools/triSurface/triSurfaceSearch/triSurfaceSearch.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -48,7 +48,6 @@ namespace Foam
// Forward declaration of classes
class triSurface;
class treeDataTriSurface;
template<class Type> class indexedOctree;
/*---------------------------------------------------------------------------*\