| /*---------------------------------------------------------------------------*\ | |
| ========= | | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | |
| \\ / O peration | Website: https://openfoam.org | |
| \\ / A nd | Copyright (C) 2011-2026 OpenFOAM Foundation | |
| \\/ M anipulation | | |
| ------------------------------------------------------------------------------- | |
| License | |
| This file is part of OpenFOAM. | |
| OpenFOAM is free software: you can redistribute it and/or modify it | |
| under the terms of the GNU General Public License as published by | |
| the Free Software Foundation, either version 3 of the License, or | |
| (at your option) any later version. | |
| OpenFOAM is distributed in the hope that it will be useful, but WITHOUT | |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| for more details. | |
| You should have received a copy of the GNU General Public License | |
| along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. | |
| Class | |
| Foam::treeBoundBox | |
| Description | |
| Standard boundBox + extra functionality for use in octree. | |
| Numbering of corner points is according to octant numbering. | |
| On the back plane (z=0): | |
| \verbatim | |
| Y | |
| ^ | |
| | | |
| +--------+ | |
| |2 3| | |
| | | | |
| | | | |
| | | | |
| |0 1| | |
| +--------+->X | |
| \endverbatim | |
| For the front plane add 4 to the point labels. | |
| SourceFiles | |
| treeBoundBoxI.H | |
| treeBoundBox.C | |
| treeBoundBoxTemplates.C | |
| \*---------------------------------------------------------------------------*/ | |
| // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // | |
| namespace Foam | |
| { | |
| class randomGenerator; | |
| // Forward declaration of friend functions and operators | |
| class treeBoundBox; | |
| bool operator==(const treeBoundBox&, const treeBoundBox&); | |
| bool operator!=(const treeBoundBox&, const treeBoundBox&); | |
| Istream& operator>>(Istream& is, treeBoundBox&); | |
| Ostream& operator<<(Ostream& os, const treeBoundBox&); | |
| /*---------------------------------------------------------------------------*\ | |
| Class treeBoundBox Declaration | |
| \*---------------------------------------------------------------------------*/ | |
| class treeBoundBox | |
| : | |
| public boundBox | |
| { | |
| //- To initialise edges. | |
| static edgeList calcEdges(const label[12][2]); | |
| //- To initialise faceNormals. | |
| static FixedList<vector, 6> calcFaceNormals(); | |
| public: | |
| // Static Data Members | |
| //- As per boundBox::greatBox, but with great instead of vGreat | |
| static const treeBoundBox greatBox; | |
| //- As per boundBox::invertedBox, but with great instead of vGreat | |
| static const treeBoundBox invertedBox; | |
| //- Bits used for octant/point coding. | |
| // Every octant/corner point is the combination of three faces. | |
| struct octantBit | |
| { | |
| enum | |
| { | |
| rightHalf = 0x1 << 0, | |
| topHalf = 0x1 << 1, | |
| frontHalf = 0x1 << 2 | |
| }; | |
| }; | |
| //- Face codes | |
| struct faceId | |
| { | |
| enum | |
| { | |
| left = 0, | |
| right = 1, | |
| bottom = 2, | |
| top = 3, | |
| back = 4, | |
| front = 5 | |
| }; | |
| }; | |
| //- Bits used for face coding | |
| struct faceBit | |
| { | |
| enum | |
| { | |
| noFace = 0, | |
| left = 0x1 << faceId::left, //1 | |
| right = 0x1 << faceId::right, //2 | |
| bottom = 0x1 << faceId::bottom, //4 | |
| top = 0x1 << faceId::top, //8 | |
| back = 0x1 << faceId::back, //16 | |
| front = 0x1 << faceId::front, //32 | |
| }; | |
| }; | |
| //- Edges codes. | |
| // e01 = edge between 0 and 1. | |
| struct edgeId | |
| { | |
| enum | |
| { | |
| e01 = 0, | |
| e13 = 1, | |
| e23 = 2, | |
| e02 = 3, | |
| e45 = 4, | |
| e57 = 5, | |
| e67 = 6, | |
| e46 = 7, | |
| e04 = 8, | |
| e15 = 9, | |
| e37 = 10, | |
| e26 = 11 | |
| }; | |
| }; | |
| //- Face to point addressing | |
| static const faceList faces; | |
| //- Edge to point addressing | |
| static const edgeList edges; | |
| //- Per face the unit normal | |
| static const FixedList<vector, 6> faceNormals; | |
| // Constructors | |
| //- Construct null setting points to zero | |
| inline treeBoundBox(); | |
| //- Construct from a boundBox | |
| explicit inline treeBoundBox(const boundBox& bb); | |
| //- Construct from components | |
| inline treeBoundBox(const point& min, const point& max); | |
| //- Construct as the bounding box of the given pointField. | |
| // Local processor domain only (no reduce as in boundBox) | |
| explicit treeBoundBox(const UList<point>&); | |
| //- Construct as subset of points | |
| // Local processor domain only (no reduce as in boundBox) | |
| treeBoundBox(const UList<point>&, const labelUList& indices); | |
| //- Construct as subset of points | |
| // The indices could be from edge/triFace etc. | |
| // Local processor domain only (no reduce as in boundBox) | |
| template<unsigned Size> | |
| treeBoundBox | |
| ( | |
| const UList<point>&, | |
| const FixedList<label, Size>& indices | |
| ); | |
| //- Construct from Istream | |
| inline treeBoundBox(Istream&); | |
| //- Construct from dictionary | |
| inline treeBoundBox(const dictionary&); | |
| // Member Functions | |
| // Access | |
| //- Typical dimension length,height,width | |
| inline scalar typDim() const; | |
| //- Vertex coordinates. In octant coding. | |
| tmp<pointField> points() const; | |
| // Check | |
| //- Corner point given octant | |
| inline point corner(const direction) const; | |
| //- Sub box given by octant number. Midpoint calculated. | |
| treeBoundBox subBbox(const direction) const; | |
| //- Sub box given by octant number. Midpoint provided. | |
| treeBoundBox subBbox(const point& mid, const direction) const; | |
| //- Returns octant number given point and the calculated midpoint. | |
| inline direction subOctant | |
| ( | |
| const point& pt | |
| ) const; | |
| //- Returns octant number given point and midpoint. | |
| static inline direction subOctant | |
| ( | |
| const point& mid, | |
| const point& pt | |
| ); | |
| //- Returns octant number given point and the calculated midpoint. | |
| // onEdge set if the point is on edge of subOctant | |
| inline direction subOctant | |
| ( | |
| const point& pt, | |
| bool& onEdge | |
| ) const; | |
| //- Returns octant number given point and midpoint. | |
| // onEdge set if the point is on edge of subOctant | |
| static inline direction subOctant | |
| ( | |
| const point& mid, | |
| const point& pt, | |
| bool& onEdge | |
| ); | |
| //- Returns octant number given intersection and midpoint. | |
| // onEdge set if the point is on edge of subOctant | |
| // If onEdge, the direction vector determines which octant to use | |
| // (acc. to which octant the point would be if it were moved | |
| // along dir) | |
| static inline direction subOctant | |
| ( | |
| const point& mid, | |
| const vector& dir, | |
| const point& pt, | |
| bool& onEdge | |
| ); | |
| //- Calculates optimal order to look for nearest to point. | |
| // First will be the octant containing the point, | |
| // second the octant with boundary nearest to the point etc. | |
| inline void searchOrder | |
| ( | |
| const point& pt, | |
| FixedList<direction, 8>& octantOrder | |
| ) const; | |
| //- Overlaps other bounding box? | |
| using boundBox::overlaps; | |
| //- Intersects segment; set point to intersection position and face, | |
| // return true if intersection found. | |
| // (pt argument used during calculation even if not intersecting). | |
| // Calculates intersections from outside supplied vector | |
| // (overallStart, overallVec). This is so when | |
| // e.g. tracking through lots of consecutive boxes | |
| // (typical octree) we're not accumulating truncation errors. Set | |
| // to start, (end-start) if not used. | |
| bool intersects | |
| ( | |
| const point& overallStart, | |
| const vector& overallVec, | |
| const point& start, | |
| const point& end, | |
| point& pt, | |
| direction& ptBits | |
| ) const; | |
| //- Like above but does not return faces point is on | |
| bool intersects | |
| ( | |
| const point& start, | |
| const point& end, | |
| point& pt | |
| ) const; | |
| //- Contains point or other bounding box? | |
| using boundBox::contains; | |
| //- Contains point (inside or on edge) and moving in direction | |
| // dir would cause it to go inside. | |
| bool contains(const vector& dir, const point&) const; | |
| //- Code position of point on bounding box faces | |
| direction faceBits(const point&) const; | |
| //- Position of point relative to bounding box | |
| direction posBits(const point&) const; | |
| //- Calculate nearest and furthest (to point) vertex coords of | |
| // bounding box | |
| void calcExtremities | |
| ( | |
| const point& pt, | |
| point& nearest, | |
| point& furthest | |
| ) const; | |
| //- Returns distance point to furthest away corner. | |
| scalar maxDist(const point&) const; | |
| //- Compare distance to point with other bounding box | |
| // return: | |
| // -1 : all vertices of my bounding box are nearer than any of | |
| // other | |
| // +1 : all vertices of my bounding box are further away than | |
| // any of other | |
| // 0 : none of the above. | |
| label distanceCmp(const point&, const treeBoundBox& other) const; | |
| //- Return asymmetrically extended bounding box, with guaranteed | |
| // minimum width of s*mag(span) in any direction | |
| inline treeBoundBox extend(const scalar s) const; | |
| // Write | |
| void writeOBJ(const fileName& fName) const; | |
| // Friend Operators | |
| friend bool operator==(const treeBoundBox&, const treeBoundBox&); | |
| friend bool operator!=(const treeBoundBox&, const treeBoundBox&); | |
| // IOstream operator | |
| friend Istream& operator>>(Istream& is, treeBoundBox&); | |
| friend Ostream& operator<<(Ostream& os, const treeBoundBox&); | |
| }; | |
| //- Data associated with treeBoundBox type are contiguous | |
| template<> | |
| inline bool contiguous<treeBoundBox>() {return contiguous<boundBox>();} | |
| //- A treeBoundBox is scalable | |
| template<> | |
| struct scalable<treeBoundBox> : public scalable<boundBox> {}; | |
| // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // | |
| } // End namespace Foam | |
| // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // | |
| // ************************************************************************* // | |