src/OpenFOAM/meshes/treeBoundBox/treeBoundBox.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
   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
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your 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, see <http://www.gnu.org/licenses/>.
  23
  24 Class
  25     Foam::treeBoundBox
  26
  27 Description
  28     Standard boundBox + extra functionality for use in octree.
  29
  30     Numbering of corner points is according to octant numbering.
  31
  32     On the back plane (z=0):
  33
  34     \verbatim
  35         Y
  36         ^
  37         |
  38         +--------+
  39         |2      3|
  40         |        |
  41         |        |
  42         |        |
  43         |0      1|
  44         +--------+->X
  45     \endverbatim
  46
  47     For the front plane add 4 to the point labels.
  48
  49
  50 SourceFiles
  51     treeBoundBoxI.H
  52     treeBoundBox.C
  53     treeBoundBoxTemplates.C
  54
  55 \*---------------------------------------------------------------------------*/
  56
  57 #ifndef treeBoundBox_H
  58 #define treeBoundBox_H
  59
  60 #include "boundBox.H"
  61 #include "direction.H"
  62 #include "pointField.H"
  63 #include "faceList.H"
  64
  65 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  66
  67 namespace Foam
  68 {
  69
  70 class Random;
  71
  72 /*---------------------------------------------------------------------------*\
  73                         Class treeBoundBox Declaration
  74 \*---------------------------------------------------------------------------*/
  75
  76 class treeBoundBox
  77 :
  78     public boundBox
  79 {
  80
  81 private:
  82
  83         //- To initialise edges.
  84         static edgeList calcEdges(const label[12][2]);
  85
  86         //- To initialise faceNormals.
  87         static FixedList<vector, 6> calcFaceNormals();
  88
  89 public:
  90
  91     // Static data members
  92
  93         //- The great value used for greatBox and invertedBox
  94         static const scalar great;
  95
  96         //- As per boundBox::greatBox, but with GREAT instead of VGREAT
  97         static const treeBoundBox greatBox;
  98
  99         //- As per boundBox::invertedBox, but with GREAT instead of VGREAT
 100         static const treeBoundBox invertedBox;
 101
 102         //- Bits used for octant/point coding.
 103         //  Every octant/corner point is the combination of three faces.
 104         enum octantBit
 105         {
 106             RIGHTHALF = 0x1 << 0,
 107             TOPHALF   = 0x1 << 1,
 108             FRONTHALF = 0x1 << 2
 109         };
 110
 111         //- Face codes
 112         enum faceId
 113         {
 114             LEFT   = 0,
 115             RIGHT  = 1,
 116             BOTTOM = 2,
 117             TOP    = 3,
 118             BACK   = 4,
 119             FRONT  = 5
 120         };
 121
 122         //- Bits used for face coding
 123         enum faceBit
 124         {
 125             NOFACE    = 0,
 126             LEFTBIT   = 0x1 << LEFT,    //1
 127             RIGHTBIT  = 0x1 << RIGHT,   //2
 128             BOTTOMBIT = 0x1 << BOTTOM,  //4
 129             TOPBIT    = 0x1 << TOP,     //8
 130             BACKBIT   = 0x1 << BACK,    //16
 131             FRONTBIT  = 0x1 << FRONT,   //32
 132         };
 133
 134         //- Edges codes.
 135         //  E01 = edge between 0 and 1.
 136         enum edgeId
 137         {
 138             E01 = 0,
 139             E13 = 1,
 140             E23 = 2,
 141             E02 = 3,
 142
 143             E45 = 4,
 144             E57 = 5,
 145             E67 = 6,
 146             E46 = 7,
 147
 148             E04 = 8,
 149             E15 = 9,
 150             E37 = 10,
 151             E26 = 11
 152         };
 153
 154         //- Face to point addressing
 155         static const faceList faces;
 156
 157         //- Edge to point addressing
 158         static const edgeList edges;
 159
 160         //- Per face the unit normal
 161         static const FixedList<vector, 6> faceNormals;
 162
 163
 164     // Constructors
 165
 166         //- Construct null setting points to zero
 167         inline treeBoundBox();
 168
 169         //- Construct from a boundBox
 170         explicit inline treeBoundBox(const boundBox& bb);
 171
 172         //- Construct from components
 173         inline treeBoundBox(const point& min, const point& max);
 174
 175         //- Construct as the bounding box of the given pointField.
 176         //  Local processor domain only (no reduce as in boundBox)
 177         explicit treeBoundBox(const UList<point>&);
 178
 179         //- Construct as subset of points
 180         //  Local processor domain only (no reduce as in boundBox)
 181         treeBoundBox(const UList<point>&, const labelUList& indices);
 182
 183         //- Construct as subset of points
 184         //  The indices could be from edge/triFace etc.
 185         //  Local processor domain only (no reduce as in boundBox)
 186         template<unsigned Size>
 187         treeBoundBox
 188         (
 189             const UList<point>&,
 190             const FixedList<label, Size>& indices
 191         );
 192
 193
 194         //- Construct from Istream
 195         inline treeBoundBox(Istream&);
 196
 197
 198     // Member functions
 199
 200         // Access
 201
 202             //- Typical dimension length,height,width
 203             inline scalar typDim() const;
 204
 205             //- vertex coordinates. In octant coding.
 206             tmp<pointField> points() const;
 207
 208
 209         // Check
 210
 211             //- Corner point given octant
 212             inline point corner(const direction) const;
 213
 214             //- Sub box given by octant number. Midpoint calculated.
 215             treeBoundBox subBbox(const direction) const;
 216
 217             //- Sub box given by octant number. Midpoint provided.
 218             treeBoundBox subBbox(const point& mid, const direction) const;
 219
 220             //- Returns octant number given point and the calculated midpoint.
 221             inline direction subOctant
 222             (
 223                 const point& pt
 224             ) const;
 225
 226             //- Returns octant number given point and midpoint.
 227             static inline direction subOctant
 228             (
 229                 const point& mid,
 230                 const point& pt
 231             );
 232
 233             //- Returns octant number given point and the calculated midpoint.
 234             //  onEdge set if the point is on edge of subOctant
 235             inline direction subOctant
 236             (
 237                 const point& pt,
 238                 bool& onEdge
 239             ) const;
 240
 241             //- Returns octant number given point and midpoint.
 242             //  onEdge set if the point is on edge of subOctant
 243             static inline direction subOctant
 244             (
 245                 const point& mid,
 246                 const point& pt,
 247                 bool& onEdge
 248             );
 249
 250             //- Returns octant number given intersection and midpoint.
 251             //  onEdge set if the point is on edge of subOctant
 252             //  If onEdge, the direction vector determines which octant to use
 253             //  (acc. to which octant the point would be if it were moved
 254             //  along dir)
 255             static inline direction subOctant
 256             (
 257                 const point& mid,
 258                 const vector& dir,
 259                 const point& pt,
 260                 bool& onEdge
 261             );
 262
 263             //- Calculates optimal order to look for nearest to point.
 264             //  First will be the octant containing the point,
 265             //  second the octant with boundary nearest to the point etc.
 266             inline void searchOrder
 267             (
 268                  const point& pt,
 269                  FixedList<direction, 8>& octantOrder
 270             ) const;
 271
 272             //- Overlaps other bounding box?
 273             using boundBox::overlaps;
 274
 275             //- Overlaps boundingSphere (centre + sqr(radius))?
 276             bool overlaps(const point&, const scalar radiusSqr) const;
 277
 278             //- Intersects segment; set point to intersection position and face,
 279             //  return true if intersection found.
 280             //  (pt argument used during calculation even if not intersecting).
 281             //  Calculates intersections from outside supplied vector
 282             //  (overallStart, overallVec). This is so when
 283             //  e.g. tracking through lots of consecutive boxes
 284             // (typical octree) we're not accumulating truncation errors. Set
 285             // to start, (end-start) if not used.
 286             bool intersects
 287             (
 288                 const point& overallStart,
 289                 const vector& overallVec,
 290                 const point& start,
 291                 const point& end,
 292                 point& pt,
 293                 direction& ptBits
 294             ) const;
 295
 296             //- Like above but does not return faces point is on
 297             bool intersects
 298             (
 299                 const point& start,
 300                 const point& end,
 301                 point& pt
 302             ) const;
 303
 304             //- Contains point or other bounding box?
 305             using boundBox::contains;
 306
 307             //- Contains point (inside or on edge) and moving in direction
 308             //  dir would cause it to go inside.
 309             bool contains(const vector& dir, const point&) const;
 310
 311             //- Code position of point on bounding box faces
 312             direction faceBits(const point&) const;
 313
 314             //- Position of point relative to bounding box
 315             direction posBits(const point&) const;
 316
 317             //- Calculate nearest and furthest (to point) vertex coords of
 318             //  bounding box
 319             void calcExtremities
 320             (
 321                 const point& pt,
 322                 point& nearest,
 323                 point& furthest
 324             ) const;
 325
 326             //- Returns distance point to furthest away corner.
 327             scalar maxDist(const point&) const;
 328
 329             //- Compare distance to point with other bounding box
 330             //  return:
 331             //  -1 : all vertices of my bounding box are nearer than any of
 332             //       other
 333             //  +1 : all vertices of my bounding box are further away than
 334             //       any of other
 335             //   0 : none of the above.
 336             label distanceCmp(const point&, const treeBoundBox& other) const;
 337
 338             //- Return slightly wider bounding box
 339             //  Extends all dimensions with s*span*Random::scalar01()
 340             //  and guarantees in any direction s*mag(span) minimum width
 341             inline treeBoundBox extend(Random&, const scalar s) const;
 342
 343     // Friend Operators
 344
 345         friend bool operator==(const treeBoundBox&, const treeBoundBox&);
 346         friend bool operator!=(const treeBoundBox&, const treeBoundBox&);
 347
 348     // IOstream operator
 349
 350         friend Istream& operator>>(Istream& is, treeBoundBox&);
 351         friend Ostream& operator<<(Ostream& os, const treeBoundBox&);
 352
 353 };
 354
 355
 356 //- Data associated with treeBoundBox type are contiguous
 357 template<>
 358 inline bool contiguous<treeBoundBox>() {return contiguous<boundBox>();}
 359
 360
 361 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 362
 363 } // End namespace Foam
 364
 365 #include "treeBoundBoxI.H"
 366
 367 #ifdef NoRepository
 368 #   include "treeBoundBoxTemplates.C"
 369 #endif
 370
 371 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 372
 373 #endif
 374
 375 // ************************************************************************* //