src/meshTools/triSurface/booleanOps/surfaceIntersection/surfaceIntersectionFuncs.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software; you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM; if not, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 Description
  26
  27 \*---------------------------------------------------------------------------*/
  28
  29 #include "surfaceIntersection.H"
  30 #include "triSurfaceSearch.H"
  31 #include "labelPairLookup.H"
  32 #include "OFstream.H"
  33 #include "HashSet.H"
  34 #include "labelHashSet.H"
  35 #include "triSurface.H"
  36 #include "pointIndexHit.H"
  37 #include "octreeDataTriSurface.H"
  38 #include "octree.H"
  39 #include "meshTools.H"
  40
  41 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  42
  43
  44 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  45
  46 void Foam::surfaceIntersection::writeOBJ(const point& pt, Ostream& os)
  47 {
  48     os << "v " << pt.x() << ' ' << pt.y() << ' ' << pt.z() << endl;
  49 }
  50
  51
  52 void Foam::surfaceIntersection::writeOBJ
  53 (
  54     const List<point>& pts,
  55     const List<edge>& edges,
  56     Ostream& os
  57 )
  58 {
  59     forAll(pts, i)
  60     {
  61         writeOBJ(pts[i], os);
  62     }
  63     forAll(edges, i)
  64     {
  65         const edge& e = edges[i];
  66
  67         os << "l " << e.start()+1 << ' ' << e.end()+1 << endl;
  68     }
  69 }
  70
  71
  72 // Get minimum length of all edges connected to point
  73 Foam::scalar Foam::surfaceIntersection::minEdgeLen
  74 (
  75     const triSurface& surf,
  76     const label pointI
  77 )
  78 {
  79     const labelList& pEdges = surf.pointEdges()[pointI];
  80
  81     scalar minLen = GREAT;
  82
  83     forAll(pEdges, pEdgeI)
  84     {
  85         const edge& e = surf.edges()[pEdges[pEdgeI]];
  86
  87         minLen = min(minLen, e.mag(surf.localPoints()));
  88     }
  89
  90     return minLen;
  91 }
  92
  93
  94 // Get edge between fp and fp+1 on faceI.
  95 Foam::label Foam::surfaceIntersection::getEdge
  96 (
  97     const triSurface& surf,
  98     const label faceI,
  99     const label fp
 100 )
 101 {
 102     const labelledTri& f = surf.localFaces()[faceI];
 103
 104     edge faceEdge(f[fp], f[(fp+1) % 3]);
 105
 106     const labelList& eLabels = surf.faceEdges()[faceI];
 107
 108     forAll(eLabels, eI)
 109     {
 110         const label edgeI = eLabels[eI];
 111
 112         if (surf.edges()[edgeI] == faceEdge)
 113         {
 114             return edgeI;
 115         }
 116     }
 117
 118     FatalErrorIn
 119     (
 120         "surfaceIntersection::getEdge(const triSurface&"
 121         ", const label, const label"
 122     )   << "Problem:: Cannot find edge with vertices " << faceEdge
 123         << " in face " << faceI
 124         << abort(FatalError);
 125
 126     return -1;
 127 }
 128
 129
 130 // Given a map remove all consecutive duplicate elements.
 131 void Foam::surfaceIntersection::removeDuplicates
 132 (
 133     const labelList& map,
 134     labelList& elems
 135 )
 136 {
 137     bool hasDuplicate = false;
 138
 139     label prevVertI = -1;
 140
 141     forAll(elems, elemI)
 142     {
 143         label newVertI = map[elems[elemI]];
 144
 145         if (newVertI == prevVertI)
 146         {
 147             hasDuplicate = true;
 148
 149             break;
 150         }
 151         prevVertI = newVertI;
 152     }
 153
 154     if (hasDuplicate)
 155     {
 156         // Create copy
 157         labelList oldElems(elems);
 158
 159         label elemI = 0;
 160
 161         // Insert first
 162         elems[elemI++] = map[oldElems[0]];
 163
 164         for(label vertI = 1; vertI < oldElems.size(); vertI++)
 165         {
 166             // Insert others only if they differ from one before
 167             label newVertI = map[oldElems[vertI]];
 168
 169             if (newVertI != elems[elems.size()-1])
 170             {
 171                 elems[elemI++] = newVertI;
 172             }
 173         }
 174         elems.setSize(elemI);
 175     }
 176 }
 177
 178
 179 // Remap.
 180 void Foam::surfaceIntersection::inlineRemap
 181 (
 182     const labelList& map,
 183     labelList& elems
 184 )
 185 {
 186     forAll(elems, elemI)
 187     {
 188         elems[elemI] = map[elems[elemI]];
 189     }
 190 }
 191
 192
 193 // Remove all duplicate and degenerate elements. Return unique elements and
 194 // map from old to new.
 195 Foam::edgeList Foam::surfaceIntersection::filterEdges
 196 (
 197     const edgeList& edges,
 198     labelList& map
 199 )
 200 {
 201     HashSet<edge, Hash<edge> > uniqueEdges(10*edges.size());
 202
 203     edgeList newEdges(edges.size());
 204
 205     map.setSize(edges.size());
 206     map = -1;
 207
 208     label newEdgeI = 0;
 209
 210     forAll(edges, edgeI)
 211     {
 212         const edge& e = edges[edgeI];
 213
 214         if
 215         (
 216             (e.start() != e.end())
 217          && (uniqueEdges.find(e) == uniqueEdges.end())
 218         )
 219         {
 220             // Edge is -non degenerate and -not yet seen.
 221             uniqueEdges.insert(e);
 222
 223             map[edgeI] = newEdgeI;
 224
 225             newEdges[newEdgeI++] = e;
 226         }
 227     }
 228
 229     newEdges.setSize(newEdgeI);
 230
 231     return newEdges;
 232 }
 233
 234
 235 // Remove all duplicate elements.
 236 Foam::labelList Foam::surfaceIntersection::filterLabels
 237 (
 238     const labelList& elems,
 239     labelList& map
 240 )
 241 {
 242     labelHashSet uniqueElems(10*elems.size());
 243
 244     labelList newElems(elems.size());
 245
 246     map.setSize(elems.size());
 247     map = -1;
 248
 249     label newElemI = 0;
 250
 251     forAll(elems, elemI)
 252     {
 253         label elem = elems[elemI];
 254
 255         if (uniqueElems.find(elem) == uniqueElems.end())
 256         {
 257             // First time elem is seen
 258             uniqueElems.insert(elem);
 259
 260             map[elemI] = newElemI;
 261
 262             newElems[newElemI++] = elem;
 263         }
 264     }
 265
 266     newElems.setSize(newElemI);
 267
 268     return newElems;
 269 }
 270
 271
 272 void Foam::surfaceIntersection::writeIntersectedEdges
 273 (
 274     const triSurface& surf,
 275     const labelListList& edgeCutVerts,
 276     Ostream& os
 277 ) const
 278 {
 279     // Dump all points (surface followed by cutPoints)
 280     const pointField& pts = surf.localPoints();
 281
 282     forAll(pts, pointI)
 283     {
 284         writeOBJ(pts[pointI], os);
 285     }
 286     forAll(cutPoints(), cutPointI)
 287     {
 288         writeOBJ(cutPoints()[cutPointI], os);
 289     }
 290
 291     forAll(edgeCutVerts, edgeI)
 292     {
 293         const labelList& extraVerts = edgeCutVerts[edgeI];
 294
 295         if (extraVerts.size() != 0)
 296         {
 297             const edge& e = surf.edges()[edgeI];
 298
 299             // Start of original edge to first extra point
 300             os  << "l " << e.start()+1 << ' '
 301                 << extraVerts[0] + surf.nPoints() + 1 << endl;
 302
 303             for(label i = 1; i < extraVerts.size(); i++)
 304             {
 305                 os  << "l " << extraVerts[i-1] + surf.nPoints() + 1  << ' '
 306                     << extraVerts[i] + surf.nPoints() + 1 << endl;
 307             }
 308
 309             os  << "l " << extraVerts[extraVerts.size()-1] + surf.nPoints() + 1
 310                 << ' ' << e.end()+1 << endl;
 311         }
 312     }
 313 }
 314
 315
 316 // Return 0 (p close to start), 1(close to end) or -1.
 317 Foam::label Foam::surfaceIntersection::classify
 318 (
 319     const scalar startTol,
 320     const scalar endTol,
 321     const point& p,
 322     const edge& e,
 323     const pointField& points
 324 )
 325 {
 326     if (mag(p - points[e.start()]) < startTol)
 327     {
 328         return 0;
 329     }
 330     else if (mag(p - points[e.end()]) < endTol)
 331     {
 332         return 1;
 333     }
 334     else
 335     {
 336         return -1;
 337     }
 338 }
 339
 340
 341 // ************************************************************************* //