src/OpenFOAM/meshes/primitiveShapes/triangle/triangle.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::triangle
  26
  27 Description
  28     A triangle primitive used to calculate face normals and swept volumes.
  29
  30 SourceFiles
  31     triangleI.H
  32
  33 \*---------------------------------------------------------------------------*/
  34
  35 #ifndef triangle_H
  36 #define triangle_H
  37
  38 #include "intersection.H"
  39 #include "vector.H"
  40 #include "tensor.H"
  41 #include "pointHit.H"
  42 #include "Random.H"
  43 #include "FixedList.H"
  44 #include "UList.H"
  45
  46 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  47
  48 namespace Foam
  49 {
  50
  51 class Istream;
  52 class Ostream;
  53
  54 // Forward declaration of friend functions and operators
  55
  56 template<class Point, class PointRef> class triangle;
  57
  58 template<class Point, class PointRef>
  59 inline Istream& operator>>
  60 (
  61     Istream&,
  62     triangle<Point, PointRef>&
  63 );
  64
  65 template<class Point, class PointRef>
  66 inline Ostream& operator<<
  67 (
  68     Ostream&,
  69     const triangle<Point, PointRef>&
  70 );
  71
  72
  73 /*---------------------------------------------------------------------------*\
  74                           Class triangle Declaration
  75 \*---------------------------------------------------------------------------*/
  76
  77 template<class Point, class PointRef>
  78 class triangle
  79 {
  80     // Private data
  81
  82         PointRef a_, b_, c_;
  83
  84
  85 public:
  86
  87     //- Return types for classify
  88     enum proxType
  89     {
  90         NONE,
  91         POINT,  // Close to point
  92         EDGE    // Close to edge
  93     };
  94
  95
  96     // Constructors
  97
  98         //- Construct from three points
  99         inline triangle(const Point& a, const Point& b, const Point& c);
 100
 101         //- Construct from three points in the list of points
 102         //  The indices could be from triFace etc.
 103         inline triangle
 104         (
 105             const UList<Point>&,
 106             const FixedList<label, 3>& indices
 107         );
 108
 109         //- Construct from Istream
 110         inline triangle(Istream&);
 111
 112
 113     // Member Functions
 114
 115         // Access
 116
 117             //- Return first vertex
 118             inline const Point& a() const;
 119
 120             //- Return second vertex
 121             inline const Point& b() const;
 122
 123             //- Return third vertex
 124             inline const Point& c() const;
 125
 126
 127         // Properties
 128
 129             //- Return centre (centroid)
 130             inline Point centre() const;
 131
 132             //- Return scalar magnitude
 133             inline scalar mag() const;
 134
 135             //- Return vector normal
 136             inline vector normal() const;
 137
 138             //- Return circum-centre
 139             inline Point circumCentre() const;
 140
 141             //- Return circum-radius
 142             inline scalar circumRadius() const;
 143
 144             //- Return quality: Ratio of triangle and circum-circle
 145             //  area, scaled so that an equilateral triangle has a
 146             //  quality of 1
 147             inline scalar quality() const;
 148
 149             //- Return swept-volume
 150             inline scalar sweptVol(const triangle& t) const;
 151
 152             //- Return the inertia tensor, with optional reference
 153             //  point and density specification
 154             inline tensor inertia
 155             (
 156                 PointRef refPt = vector::zero,
 157                 scalar density = 1.0
 158             ) const;
 159
 160             //- Return a random point on the triangle from a uniform
 161             //  distribution
 162             inline Point randomPoint(Random& rndGen) const;
 163
 164             //- Calculate the barycentric coordinates of the given
 165             //  point, in the same order as a, b, c.  Returns the
 166             //  determinant of the solution.
 167             inline scalar barycentric
 168             (
 169                 const point& pt,
 170                 List<scalar>& bary
 171             ) const;
 172
 173             //- Return point intersection with a ray.
 174             //  For a hit, the distance is signed. Positive number
 175             //  represents the point in front of triangle.
 176             //  In case of miss pointHit is set to nearest point
 177             //  on triangle and its distance to the distance between
 178             //  the original point and the plane intersection point
 179             inline pointHit ray
 180             (
 181                 const point& p,
 182                 const vector& q,
 183                 const intersection::algorithm = intersection::FULL_RAY,
 184                 const intersection::direction dir = intersection::VECTOR
 185             ) const;
 186
 187             //- Fast intersection with a ray.
 188             //  For a hit, the pointHit.distance() is the line parameter t :
 189             //  intersection=p+t*q. Only defined for VISIBLE, FULL_RAY or
 190             //  HALF_RAY. tol increases the virtual size of the triangle
 191             // by a relative factor.
 192             inline pointHit intersection
 193             (
 194                 const point& p,
 195                 const vector& q,
 196                 const intersection::algorithm alg,
 197                 const scalar tol = 0.0
 198             ) const;
 199
 200             //- Find the nearest point to p on the triangle and classify it:
 201             //  + near point (nearType=POINT, nearLabel=0, 1, 2)
 202             //  + near edge (nearType=EDGE, nearLabel=0, 1, 2)
 203             //    Note: edges are counted from starting
 204             //    vertex so e.g. edge 2 is from f[2] to f[0]
 205             pointHit nearestPointClassify
 206             (
 207                 const point& p,
 208                 label& nearType,
 209                 label& nearLabel
 210             ) const;
 211
 212             //- Return nearest point to p on triangle
 213             inline pointHit nearestPoint(const point& p) const;
 214
 215             //- Classify nearest point to p in triangle plane
 216             //  w.r.t. triangle edges and points.  Returns inside
 217             //  (true)/outside (false).
 218             bool classify
 219             (
 220                 const point& p,
 221                 label& nearType,
 222                 label& nearLabel
 223             ) const;
 224
 225
 226     // IOstream operators
 227
 228         friend Istream& operator>> <Point, PointRef>
 229         (
 230             Istream&,
 231             triangle&
 232         );
 233
 234         friend Ostream& operator<< <Point, PointRef>
 235         (
 236             Ostream&,
 237             const triangle&
 238         );
 239 };
 240
 241
 242 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 243
 244 } // End namespace Foam
 245
 246 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 247
 248 #include "triangleI.H"
 249
 250 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 251
 252 #endif
 253
 254 // ************************************************************************* //