LCOV - code coverage report
Current view: top level - algs/AdvFront - AF2Neighborhood.cpp (source / functions) Hit Total Coverage
Test: coverage_sk.info Lines: 54 68 79.4 %
Date: 2020-07-01 15:24:36 Functions: 8 10 80.0 %
Branches: 104 242 43.0 %

           Branch data     Line data    Source code
       1                 :            : #include "meshkit/AF2Neighborhood.hpp"
       2                 :            : 
       3                 :            : // MeshKit
       4                 :            : #include "meshkit/Error.hpp"
       5                 :            : 
       6                 :            : // C++
       7                 :            : #include <set>
       8                 :            : 
       9                 :      10052 : AF2Neighborhood::AF2Neighborhood(const std::list<AF2Point3D*> & points,
      10                 :            :     AF2Edge3D* baselineEdge,
      11                 :            :     const std::list<const AF2Edge3D*> & otherEdges,
      12 [ +  - ][ +  - ]:      10052 :     const AF2LocalTransform* localTransformArg)
                 [ +  - ]
      13                 :            : {
      14                 :            :   typedef std::list<AF2Point3D*>::const_iterator ConstPoint3DItr;
      15                 :            :   typedef std::list<const AF2Edge3D*>::const_iterator ConstEdge3DItr;
      16                 :            :   typedef std::map<AF2Point3D*, const AF2Point2D*>::const_iterator MapItr;
      17                 :            : 
      18         [ +  - ]:      10052 :   std::set<AF2Point3D*> illegalPoints;
      19                 :            : 
      20                 :      10052 :   baseEdge3D = baselineEdge;
      21                 :      10052 :   localTransform = localTransformArg;
      22                 :            : 
      23 [ +  - ][ +  - ]:     299002 :   for (ConstPoint3DItr itr = points.begin(); itr != points.end(); ++itr)
                 [ +  + ]
      24                 :            :   {
      25                 :     288950 :     bool legal = true;
      26 [ +  - ][ +  - ]:     288950 :     AF2Point2D* point2D = localTransform->transformFromSurface(**itr, legal);
      27         [ +  + ]:     288950 :     if (legal)
      28                 :            :     {
      29         [ +  - ]:     281964 :       points2D.push_back(point2D);
      30 [ +  - ][ +  - ]:     281964 :       map2DTo3D[point2D] = *itr;
      31                 :            :     }
      32                 :            :     else
      33                 :            :     {
      34 [ +  - ][ +  - ]:       6986 :       illegalPoints.insert(*itr);
      35                 :            :     }
      36 [ +  - ][ +  - ]:     288950 :     map3DTo2D[*itr] = point2D;
      37                 :            :   }
      38                 :            : 
      39 [ +  - ][ +  - ]:      10052 :   MapItr baseStartItr = map3DTo2D.find(baselineEdge->getStart());
                 [ +  - ]
      40 [ +  - ][ +  - ]:      10052 :   MapItr baseEndItr = map3DTo2D.find(baselineEdge->getEnd());
                 [ +  - ]
      41 [ +  - ][ +  - ]:      10052 :   if (baseStartItr == map3DTo2D.end() || baseEndItr == map3DTo2D.end())
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
           [ -  +  #  #  
          #  #  #  #  #  
                      # ]
      42                 :            :   {
      43         [ #  # ]:          0 :     MeshKit::Error badArg(MeshKit::MK_BAD_INPUT);
      44                 :            :     badArg.set_string(
      45         [ #  # ]:          0 :         "A baseline edge endpoint is not listed in the neighborhood points.");
      46         [ #  # ]:          0 :     throw badArg;
      47                 :            :   }
      48 [ +  - ][ +  - ]:      10052 :   baseEdge2D = new AF2Edge2D(baseStartItr->second, baseEndItr->second);
         [ +  - ][ +  - ]
      49         [ +  - ]:      10052 :   edges2D.push_back(baseEdge2D);
      50                 :            : 
      51   [ +  -  +  - ]:     561436 :   for (ConstEdge3DItr itr = otherEdges.begin();
                 [ +  + ]
      52                 :     280718 :       itr != otherEdges.end(); ++itr)
      53                 :            :   {
      54 [ +  - ][ -  + ]:     270666 :     if (*itr == baselineEdge)
      55                 :            :     {
      56                 :            :       // the baseline edge should be listed only once (and listed first)
      57                 :            :       // in the list of edges
      58                 :       8174 :       continue;
      59                 :            :     }
      60 [ +  - ][ +  - ]:     270666 :     MapItr startItr = map3DTo2D.find((*itr)->getStart());
         [ +  - ][ +  - ]
      61 [ +  - ][ +  - ]:     270666 :     MapItr endItr = map3DTo2D.find((*itr)->getEnd());
         [ +  - ][ +  - ]
      62 [ +  - ][ +  - ]:     270666 :     if (startItr == map3DTo2D.end() || endItr == map3DTo2D.end())
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
           [ -  +  #  #  
          #  #  #  #  #  
                      # ]
      63                 :            :     {
      64         [ #  # ]:          0 :       MeshKit::Error badArg(MeshKit::MK_BAD_INPUT);
      65                 :            :       badArg.set_string(
      66         [ #  # ]:          0 :           "An edge endpoint is not listed in the neighborhood points.");
      67         [ #  # ]:          0 :       throw badArg;
      68                 :            :     }
      69 [ +  - ][ +  - ]:     805040 :     if ((illegalPoints.find((*itr)->getStart()) != illegalPoints.end()) ||
         [ +  - ][ +  - ]
         [ +  + ][ +  + ]
         [ +  - ][ +  - ]
         [ +  - ][ +  +  
          #  #  #  #  #  
                      # ]
      70 [ +  - ][ +  - ]:     534374 :         (illegalPoints.find((*itr)->getEnd()) != illegalPoints.end()))
         [ +  - ][ +  - ]
         [ +  + ][ +  + ]
         [ +  + ][ #  #  
             #  #  #  # ]
      71                 :            :     {
      72                 :            :       // Don't create an edge if its endpoints are illegal
      73                 :            :       // TODO: Decide whether there is something better to do if one endpoint
      74                 :            :       // is legal and the other is not legal
      75                 :       8174 :       continue;
      76                 :            :     }
      77                 :            :     const AF2Edge2D* edge2D =
      78 [ +  - ][ +  - ]:     262492 :         new AF2Edge2D(startItr->second, endItr->second);
         [ +  - ][ +  - ]
      79         [ +  - ]:     262492 :     edges2D.push_back(edge2D);
      80                 :      10052 :   }
      81                 :      10052 : }
      82                 :            : 
      83                 :        142 : AF2Neighborhood::~AF2Neighborhood()
      84                 :            : {
      85                 :            :   typedef std::list<const AF2Point2D*>::const_iterator ConstPoint2DItr;
      86                 :            :   typedef std::list<const AF2Edge2D*>::const_iterator ConstEdge2DItr;
      87                 :            : 
      88         [ +  + ]:        580 :   for (ConstEdge2DItr itr = edges2D.begin(); itr != edges2D.end(); ++itr)
      89                 :            :   {
      90                 :        509 :     delete *itr;
      91                 :            :   }
      92         [ +  + ]:        773 :   for (ConstPoint2DItr itr = points2D.begin(); itr != points2D.end(); ++itr)
      93                 :            :   {
      94                 :        702 :     delete *itr;
      95                 :            :   }
      96         [ +  - ]:         71 :   delete localTransform;
      97                 :         71 : }
      98                 :            : 
      99 [ #  # ][ #  # ]:          0 : AF2Neighborhood::AF2Neighborhood(const AF2Neighborhood & toCopy)
                 [ #  # ]
     100                 :            : {
     101         [ #  # ]:          0 :   MeshKit::Error notImpl(MeshKit::MK_NOT_IMPLEMENTED);
     102         [ #  # ]:          0 :   notImpl.set_string("AF2Neighborhood copy construction is not supported.");
     103         [ #  # ]:          0 :   throw notImpl;
     104                 :            : }
     105                 :            : 
     106                 :          0 : AF2Neighborhood& AF2Neighborhood::operator=(const AF2Neighborhood & rhs)
     107                 :            : {
     108         [ #  # ]:          0 :   MeshKit::Error notImpl(MeshKit::MK_NOT_IMPLEMENTED);
     109         [ #  # ]:          0 :   notImpl.set_string("AF2Neighborhood assignment operator is not supported.");
     110         [ #  # ]:          0 :   throw notImpl;
     111                 :            : }
     112                 :            : 
     113                 :     153928 : const AF2Edge2D* AF2Neighborhood::getBaselineEdge2D() const
     114                 :            : {
     115                 :     153928 :   return baseEdge2D;
     116                 :            : }
     117                 :            : 
     118                 :       9981 : AF2Edge3D* AF2Neighborhood::getBaselineEdge3D() const
     119                 :            : {
     120                 :       9981 :   return baseEdge3D;
     121                 :            : }
     122                 :            : 
     123                 :      27798 : AF2Point3D* AF2Neighborhood::getCorrespondingPoint(
     124                 :            :     const AF2Point2D* const & ngbhdPoint2D) const
     125                 :            : {
     126                 :            :   typedef std::map<const AF2Point2D*, AF2Point3D*>::const_iterator MapItr;
     127         [ +  - ]:      27798 :   MapItr ngbhdPntItr = map2DTo3D.find(ngbhdPoint2D);
     128 [ +  - ][ +  + ]:      27798 :   if (ngbhdPntItr == map2DTo3D.end())
     129                 :            :   {
     130                 :       6772 :     return NULL;
     131                 :            :   }
     132         [ +  - ]:      27798 :   return ngbhdPntItr->second;
     133                 :            : }
     134                 :            : 
     135                 :     100643 : const std::list<const AF2Edge2D*>* AF2Neighborhood::getEdges2D() const
     136                 :            : {
     137                 :     100643 :   return &edges2D;
     138                 :            : }
     139                 :            : 
     140                 :     100641 : const std::list<const AF2Point2D*>* AF2Neighborhood::getPoints2D() const
     141                 :            : {
     142                 :     100641 :   return &points2D;
     143                 :            : }
     144                 :            : 
     145                 :       4051 : AF2Point3D* AF2Neighborhood::transformPoint(
     146                 :            :     const AF2Point2D* const & point2D, unsigned long const & pntId) const
     147                 :            : {
     148                 :       4051 :   return localTransform->transformToSurface(*point2D, pntId);
     149                 :            : }

Generated by: LCOV version 1.11