src/meshTools/triSurface/booleanOps/intersectedSurface/edgeSurface.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 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 Class
  26     Foam::edgeSurface
  27
  28 Description
  29     Description of surface in form of 'cloud of edges'.
  30
  31     The 'cloud of edges':
  32     - points
  33     - edges
  34     - faceEdges
  35     - parentEdge (edge on surface this edge originates from)
  36     and nothing more.
  37
  38     (pointEdges constructed from above data)
  39
  40     Constructed from triSurface and surfaceIntersection. (uses localPoints
  41     of surface of course)
  42
  43     Used to easily insert cuts and split faces.
  44
  45 Note
  46     - points with surface (local)points first, intersection points last
  47     - edges with (split) surface edges first, intersection edges last.
  48
  49 SourceFiles
  50     edgeSurface.C
  51
  52 \*---------------------------------------------------------------------------*/
  53
  54 #ifndef edgeSurface_H
  55 #define edgeSurface_H
  56
  57 #include "edgeList.H"
  58 #include "labelList.H"
  59 #include "pointField.H"
  60 #include "typeInfo.H"
  61
  62 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  63
  64 namespace Foam
  65 {
  66
  67 // Forward declaration of classes
  68 class triSurface;
  69 class surfaceIntersection;
  70
  71 /*---------------------------------------------------------------------------*\
  72                            Class edgeSurface Declaration
  73 \*---------------------------------------------------------------------------*/
  74
  75 class edgeSurface
  76 {
  77 private:
  78
  79     // Private data
  80
  81         //- All points (0 .. nSurfacePoints_-1 are points from surface)
  82         pointField points_;
  83
  84         label nSurfacePoints_;
  85
  86         //- All edges (0 .. nSurfaceEdges_-1 are (possibly split) surface edges)
  87         edgeList edges_;
  88
  89         label nSurfaceEdges_;
  90
  91         //- Original surface edge. Valid only surfaceEdges.
  92         labelList parentEdges_;
  93
  94         //- From face to our edges_
  95         labelListList faceEdges_;
  96
  97
  98         //- Constructed from above: pointEdges
  99         labelListList pointEdges_;
 100
 101
 102     // Private Member Functions
 103
 104         //- Dump edges in obj format
 105         static void writeOBJ(const pointField&, const edgeList&, Ostream&);
 106
 107         //- Dump selected edges in obj format
 108         static void writeOBJ
 109         (
 110             const pointField&,
 111             const edgeList&,
 112             const labelList&,
 113             Ostream&
 114         );
 115
 116         //- Calculate pointEdges
 117         void calcPointEdges();
 118
 119
 120
 121 public:
 122
 123     ClassName("edgeSurface");
 124
 125     // Constructors
 126
 127         //- Construct from surface and intersection description
 128         edgeSurface
 129         (
 130             const triSurface& surf,
 131             const bool isFirstSurface,
 132             const surfaceIntersection& inter
 133         );
 134
 135
 136     // Member Functions
 137
 138         // Access
 139
 140             const pointField& points() const
 141             {
 142                 return points_;
 143             }
 144
 145             label nSurfacePoints() const
 146             {
 147                 return nSurfacePoints_;
 148             }
 149
 150             const edgeList& edges() const
 151             {
 152                 return edges_;
 153             }
 154
 155             label nSurfaceEdges() const
 156             {
 157                 return nSurfaceEdges_;
 158             }
 159
 160             bool isSurfaceEdge(const label edgeI) const
 161             {
 162                 return edgeI < nSurfaceEdges_;
 163             }
 164
 165             //- Parent edge (original surface edge this edge came from).
 166             //  Valid only for edgeI < nSurfaceEdges_.
 167             label parentEdge(const label edgeI) const
 168             {
 169                 if (edgeI < nSurfaceEdges_)
 170                 {
 171                     return parentEdges_[edgeI];
 172                 }
 173                 else
 174                 {
 175                     FatalErrorIn
 176                     (
 177                         "edgeSurface::parentEdge(const label edgeI) const"
 178                     )   << "Trying to get parent (i.e. surface) edge for"
 179                         << " intersection edge " << edgeI
 180                         << abort(FatalError);
 181                     return -1;
 182                 }
 183             }
 184
 185             //- From face to our edges_
 186             const labelListList& faceEdges() const
 187             {
 188                 return faceEdges_;
 189             }
 190
 191             //- point to edge addressing
 192             const labelListList& pointEdges() const
 193             {
 194                 return pointEdges_;
 195             }
 196
 197
 198         // Edit
 199
 200             //- Add intersection edges to a face. Used for connecting
 201             //  floating intersection on face to rest of face.
 202             void addIntersectionEdges(const label faceI, const edgeList&);
 203 };
 204
 205
 206 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 207
 208 } // End namespace Foam
 209
 210 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 211
 212 #endif
 213
 214 // ************************************************************************* //