LCOV - code coverage report
Current view: top level - util/cgm - IntersectionTool.hpp (source / functions) Hit Total Coverage
Test: coverage_sk.info Lines: 0 6 0.0 %
Date: 2020-06-30 00:58:45 Functions: 0 3 0.0 %
Branches: 0 2 0.0 %

           Branch data     Line data    Source code
       1                 :            : // file: GeomIntersectionTool.hpp
       2                 :            : // author: Michael Stephenson
       3                 :            : //
       4                 :            : 
       5                 :            : #ifndef INTERSECTION_TOOL_HPP
       6                 :            : #define INTERSECTION_TOOL_HPP
       7                 :            : 
       8                 :            : #include "CubitDefines.h"
       9                 :            : #include "CGMUtilConfigure.h"
      10                 :            : 
      11                 :            : class CubitVector;
      12                 :            : template <class X> class DLIList;
      13                 :            : 
      14                 :            : class CUBIT_UTIL_EXPORT IntersectionTool
      15                 :            : {
      16                 :            : public:
      17                 :            :   IntersectionTool(const double &tol = 0.0001);
      18         [ #  # ]:          0 :   virtual ~IntersectionTool() {}
      19                 :            : 
      20                 :            :   virtual CubitStatus closest_points_on_segments(CubitVector &p0,
      21                 :            :                                                  CubitVector &p1,
      22                 :            :                                                  CubitVector &p2,
      23                 :            :                                                  CubitVector &p3,
      24                 :            :                                                  CubitVector &point_1,
      25                 :            :                                                  CubitVector &point_2,
      26                 :            :                                                  double &sc, double &tc);
      27                 :            :     //- Finds the two closest points on the line segments {p0,p1} and {p2,p3},
      28                 :            :     //- and returns them in point_1 and point_2.  Will return failure
      29                 :            :     //- if a divide by zero is attempted.
      30                 :            : 
      31                 :            :   double distance_point_line(const double point[3], const double start[3], 
      32                 :            :                              const double end[3], double &t);
      33                 :            :   int point_on_polyline(CubitVector& pt, DLIList<CubitVector*> &pt_list,
      34                 :            :                          double *tol_in = NULL);
      35                 :            : 
      36                 :            :   double parametric_position(const double node[3],
      37                 :            :                            const double pt1[3],
      38                 :            :                            const double pt2[3]);
      39                 :            :   
      40                 :            :     ///
      41                 :            :     /// Returns the parametric position of the node on the
      42                 :            :     /// line segement between the points pt1 and pt2.  This
      43                 :            :     /// value is between 0 and 1.  If the node is closest
      44                 :            :     /// to pt1 it will return 0, if it is closest to pt2, it
      45                 :            :     /// will return 1.  If the node is off the line, it
      46                 :            :     /// returns the closest parametric value.
      47                 :            :     /// If there is an error, like pt1 and pt2 are equal,
      48                 :            :     /// then the function returns CUBIT_DBL_MAX.
      49                 :            :     ///
      50                 :            : 
      51                 :          0 :   virtual CubitStatus initialize(){return CUBIT_SUCCESS;}
      52                 :            : 
      53                 :            :   // The following copyright applies to the following two functions...
      54                 :            :   //
      55                 :            :   // Copyright 2001, softSurfer (www.softsurfer.com)
      56                 :            :   //
      57                 :            :   // This code may be freely used and modified for any purpose
      58                 :            :   // providing that this copyright notice is included with it.
      59                 :            :   // SoftSurfer makes no warranty for this code, and cannot be held
      60                 :            :   // liable for any real or imagined damage resulting from its use.
      61                 :            :   // Users of this code must verify correctness for their application.
      62                 :            : 
      63                 :            :   static int intersect_triangle_with_ray( CubitVector &ray_origin, CubitVector &ray_direction,
      64                 :            :           const CubitVector *p0, const CubitVector *p1, const CubitVector *p2,
      65                 :            :           CubitVector* point, double &distance, int &edge_hit );
      66                 :            :     //- Find intersection point of a ray and a triangle
      67                 :            :     //    Return: -1 = triangle is degenerate (a segment or point)
      68                 :            :     //             0 = disjoint (no intersect)
      69                 :            :     //             1 = intersect at unique point
      70                 :            :     //             2 = are in the same plane
      71                 :            : 
      72                 :            :   static int intersect_segment_with_ray( CubitVector &ray_origin, CubitVector &ray_direction,
      73                 :            :           const CubitVector *p0, const CubitVector *p1,
      74                 :            :           CubitVector* point, double &distance, int &point_hit, double tol=0.0 );
      75                 :            :     //- Find intersection point of a ray and a facet edge
      76                 :            :     //    Return: -1 = edge is degenerate (a point)
      77                 :            :     //             0 = disjoint (no intersect)
      78                 :            :     //             1 = intersect at unique point
      79                 :            :     //             2 = are the same line (infinite points)
      80                 :            : 
      81                 :            :   static int intersect_point_with_ray( CubitVector &ray_origin, CubitVector &ray_direction, 
      82                 :            :           const CubitVector* point, double &distance, double tol=0.0);
      83                 :            :     //- Find intersection of a ray and a point
      84                 :            :     //    Return: 0 = no intersection
      85                 :            :     //                    1 = intersection
      86                 :            : 
      87                 :            : 
      88                 :            : protected:
      89                 :            :   double mTolerance;
      90                 :            :   double mToleranceSquared;
      91                 :            : 
      92                 :            :   CubitBoolean ray_tri_test(const double start[3], const double dir[3],
      93                 :            :                             const double tri1[3], const double tri2[3], 
      94                 :            :                             const double tri3[3],
      95                 :            :                             double &t, double &alpha, double &beta);
      96                 :            : 
      97                 :            :   CubitBoolean skew_line_test(const double start1[3], const double end1[3],
      98                 :            :                               const double start2[3], const double end2[3],
      99                 :            :                               double &t, double &u);
     100                 :            : 
     101                 :            :   void tolerance(const double &tol);
     102                 :            :   double tolerance(void) const;
     103                 :            :   
     104                 :            : private:
     105                 :            : };
     106                 :            : 
     107                 :          0 : inline IntersectionTool::IntersectionTool(const double &tol) 
     108                 :          0 :     : mTolerance(tol)
     109                 :            : {
     110                 :          0 :   mToleranceSquared = tol * tol;
     111                 :          0 : }
     112                 :            : 
     113                 :            : #endif // INTERSECTION_TOOL_HPP
     114                 :            : 

Generated by: LCOV version 1.11