LCOV - code coverage report
Current view: top level - geom/OCC - OCCCurve.cpp (source / functions) Hit Total Coverage
Test: coverage_sk.info Lines: 231 523 44.2 %
Date: 2020-06-30 00:58:45 Functions: 29 42 69.0 %
Branches: 286 1442 19.8 %

           Branch data     Line data    Source code
       1                 :            : //-------------------------------------------------------------------------
       2                 :            : // Filename      : OCCCurve.cpp
       3                 :            : //
       4                 :            : // Purpose       : 
       5                 :            : //
       6                 :            : // Special Notes :
       7                 :            : //
       8                 :            : // Creator       : Steven J. Owen
       9                 :            : //
      10                 :            : // Creation Date : 07/14/00
      11                 :            : //
      12                 :            : // Owner         : Steven J. Owen
      13                 :            : //-------------------------------------------------------------------------
      14                 :            : 
      15                 :            : // ********** BEGIN STANDARD INCLUDES      **********
      16                 :            : 
      17                 :            : // ********** END STANDARD INCLUDES        **********
      18                 :            : // ********** BEGIN CUBIT INCLUDES         **********
      19                 :            : 
      20                 :            : #include "CastTo.hpp"
      21                 :            : #include "CubitVector.hpp"
      22                 :            : #include "CubitBox.hpp"
      23                 :            : #include "GeometryDefines.h"
      24                 :            : #include "OCCCurve.hpp"
      25                 :            : #include "GeometryQueryEngine.hpp"
      26                 :            : #include "OCCQueryEngine.hpp"
      27                 :            : #include "CoEdgeSM.hpp"
      28                 :            : 
      29                 :            : #include "OCCBody.hpp"
      30                 :            : #include "OCCLump.hpp"
      31                 :            : #include "OCCShell.hpp"
      32                 :            : #include "OCCSurface.hpp"
      33                 :            : #include "OCCLoop.hpp"
      34                 :            : #include "OCCCoEdge.hpp"
      35                 :            : #include "OCCPoint.hpp"
      36                 :            : #include "OCCAttribSet.hpp"
      37                 :            : 
      38                 :            : #include <BRepAdaptor_Curve.hxx>
      39                 :            : #include <TopExp.hxx>
      40                 :            : #include "GProp_GProps.hxx"
      41                 :            : #include "BRepGProp.hxx"
      42                 :            : #include <TopTools_IndexedMapOfShape.hxx>
      43                 :            : #include "TopTools_ListIteratorOfListOfShape.hxx"
      44                 :            : #include <GCPnts_AbscissaPoint.hxx>
      45                 :            : #include <Bnd_Box.hxx>
      46                 :            : #include <BndLib_Add3dCurve.hxx>
      47                 :            : #include <Precision.hxx>
      48                 :            : #include <Extrema_ExtPC.hxx>
      49                 :            : #include <BRepLProp_CLProps.hxx>
      50                 :            : #include <BRep_Tool.hxx>
      51                 :            : #include <TopoDS.hxx>
      52                 :            : #include "BRepBuilderAPI_MakeEdge.hxx"
      53                 :            : #include "Geom_BezierCurve.hxx"
      54                 :            : #include "Geom_BSplineCurve.hxx"
      55                 :            : #include "GeomAPI_ProjectPointOnCurve.hxx"
      56                 :            : #include "TColgp_Array1OfPnt.hxx"
      57                 :            : #include "GeomAdaptor_Curve.hxx"
      58                 :            : #include "GCPnts_QuasiUniformAbscissa.hxx"
      59                 :            : #include "BRepAlgoAPI_BooleanOperation.hxx"
      60                 :            : #include "TopTools_ListOfShape.hxx"
      61                 :            : #include "BRepAlgo_NormalProjection.hxx"
      62                 :            : #include "TopExp_Explorer.hxx"
      63                 :            : #include "GeomLProp_CurveTool.hxx"
      64                 :            : #include "GeomAPI_ExtremaCurveCurve.hxx"
      65                 :            : #include "Geom_Line.hxx"
      66                 :            : #include "Geom_Circle.hxx"
      67                 :            : #include "Geom_Ellipse.hxx"
      68                 :            : #include "GC_MakeLine.hxx"
      69                 :            : #include "gp_Circ.hxx"
      70                 :            : #include "gp_Elips.hxx"
      71                 :            : #include "BRepBuilderAPI_Transform.hxx"
      72                 :            : #include "BRepBuilderAPI_GTransform.hxx"
      73                 :            : #include "BRepBuilderAPI_ModifyShape.hxx"
      74                 :            : #include "TopTools_DataMapOfShapeInteger.hxx"
      75                 :            : //#include "TopOpeBRep_ShapeIntersector.hxx"
      76                 :            : //#include "TopOpeBRep_Point2d.hxx"
      77                 :            : //#include "TopOpeBRep_EdgesIntersector.hxx"
      78                 :            : //#include "TopOpeBRepTool_ShapeTool.hxx"
      79                 :            : //#include "BRepPrimAPI_MakePrism.hxx"
      80                 :            : // ********** END CUBIT INCLUDES           **********
      81                 :            : 
      82                 :            : // ********** BEGIN FORWARD DECLARATIONS   **********
      83                 :            : // ********** END FORWARD DECLARATIONS     **********
      84                 :            : 
      85                 :            : // ********** BEGIN STATIC DECLARATIONS    **********
      86                 :            : // ********** END STATIC DECLARATIONS      **********
      87                 :            : 
      88                 :            : // ********** BEGIN PUBLIC FUNCTIONS       **********
      89                 :            : 
      90                 :            : //-------------------------------------------------------------------------
      91                 :            : // Purpose       : The default constructor
      92                 :            : //
      93                 :            : // Special Notes :
      94                 :            : //
      95                 :            : // Creator:      : Steve Owen
      96                 :            : //
      97                 :            : // Creation Date : 07/14/00
      98                 :            : //-------------------------------------------------------------------------
      99         [ +  - ]:      74544 : OCCCurve::OCCCurve( TopoDS_Edge *theEdge )
     100                 :            : {
     101                 :      37272 :   myTopoDSEdge = theEdge;
     102                 :      37272 :   myMarked = CUBIT_FALSE;
     103 [ +  - ][ -  + ]:      37272 :   assert (myTopoDSEdge->ShapeType() == TopAbs_EDGE);
     104                 :      37272 : }
     105                 :            : 
     106                 :            : //-------------------------------------------------------------------------
     107                 :            : // Purpose       : The destructor. 
     108                 :            : //
     109                 :            : // Special Notes :
     110                 :            : //
     111                 :            : // Creator       : Steve Owen
     112                 :            : //
     113                 :            : // Creation Date : 07/14/00
     114                 :            : //-------------------------------------------------------------------------
     115         [ +  - ]:      65919 : OCCCurve::~OCCCurve() 
     116                 :            : {
     117         [ +  - ]:      21973 :   if (myTopoDSEdge)
     118                 :            :   {
     119         [ +  - ]:      21973 :     myTopoDSEdge->Nullify();
     120 [ +  - ][ +  - ]:      21973 :     delete (TopoDS_Edge *)myTopoDSEdge;
                 [ +  - ]
     121                 :      21973 :     myTopoDSEdge = NULL;
     122                 :            :   }
     123         [ -  + ]:      43946 : }
     124                 :            : 
     125                 :            : //-------------------------------------------------------------------------
     126                 :            : // Purpose       : Add and update looplist for the curve, if input loop is 
     127                 :            : //                 NULL, just update the looplist.
     128                 :            : // Special Notes :
     129                 :            : //
     130                 :            : // Creator       : Jane Hu
     131                 :            : //
     132                 :            : // Creation Date : 10/04/12
     133                 :            : //-------------------------------------------------------------------------
     134                 :      76259 : void OCCCurve::add_loop(OCCLoop* loop) 
     135                 :            : { 
     136                 :            :   //before add the loop into the looplist, check to make sure the 
     137                 :            :   //looplist is up-to-date
     138                 :            :   //It should be done somewhere else, however, in large mcnp2cad test, there's
     139                 :            :   //no way to check where the code forget to remove the out-dated loop.
     140         [ +  + ]:     124248 :   for (int i = 0; i < myLoopList.size(); i++)
     141                 :            :   {
     142                 :      47989 :     OCCLoop* myLoop = CAST_TO(myLoopList.get(), OCCLoop);
     143                 :            : 
     144         [ -  + ]:      47989 :     if(!myLoop) 
     145                 :          0 :       this->remove_loop(myLoopList.get());
     146         [ -  + ]:      47989 :     else if(myLoop->get_TopoDS_Wire() < (void*) 0x1000)
     147                 :          0 :       this->remove_loop(myLoop);
     148 [ +  - ][ +  + ]:      47989 :     else if(myLoop->coedges().size() == 0)
     149                 :        973 :       this->remove_loop(myLoop);
     150                 :      47989 :     myLoopList.step();
     151                 :            :   }
     152         [ +  + ]:      76259 :   if(loop != NULL)
     153                 :      66895 :     myLoopList.append_unique(loop);
     154                 :      76259 : }
     155                 :            : 
     156                 :      45698 : void OCCCurve::set_TopoDS_Edge(TopoDS_Edge edge)
     157                 :            : {
     158 [ +  - ][ +  + ]:      45698 :   if(myTopoDSEdge && edge.IsEqual(*myTopoDSEdge))
                 [ +  + ]
     159                 :      45698 :     return;
     160                 :            : 
     161                 :            :   else
     162                 :            :   {
     163         [ +  - ]:      29342 :     DLIList<OCCPoint*> points ;
     164         [ +  - ]:      29342 :     this->get_points(points);
     165 [ +  - ][ +  + ]:      72688 :     for(int i = 0; i < points.size(); i++)
     166                 :            :     {
     167         [ +  - ]:      43346 :       OCCPoint* point = points.get_and_step();
     168         [ +  - ]:      43346 :       TopoDS_Vertex* vtx = point->get_TopoDS_Vertex();
     169         [ +  - ]:      43346 :       TopExp_Explorer Ex;
     170                 :      43346 :       CubitBoolean found = false;
     171 [ +  - ][ +  - ]:     107933 :       for (Ex.Init(edge, TopAbs_VERTEX); Ex.More(); Ex.Next())
         [ +  - ][ +  + ]
     172                 :            :       {
     173 [ +  - ][ +  - ]:      64587 :         TopoDS_Shape sh = Ex.Current();
     174 [ +  - ][ +  + ]:      64587 :         if(vtx->IsPartner(sh))
     175                 :            :         {
     176                 :      43027 :            found = true;
     177 [ +  - ][ +  + ]:      64587 :            break;
     178                 :            :          }
     179                 :      21560 :       }
     180         [ +  + ]:      43346 :       if (!found)
     181         [ +  - ]:        319 :         point->remove_curve(this);
     182 [ +  - ][ +  - ]:      72688 :     }
     183                 :            :   }
     184                 :            :  
     185         [ +  - ]:      29342 :   if(myTopoDSEdge)
     186                 :      29342 :     myTopoDSEdge->Nullify();
     187                 :      29342 :   *myTopoDSEdge = edge;
     188                 :            : }
     189                 :            : 
     190                 :            : //-------------------------------------------------------------------------
     191                 :            : // Purpose       : The purpose of this function is to append a
     192                 :            : //                 attribute to the GE. The name is attached to the 
     193                 :            : //                 underlying solid model entity this one points to.
     194                 :            : //
     195                 :            : //
     196                 :            : // Special Notes : 
     197                 :            : //
     198                 :            : // Creator       : Steve Owen
     199                 :            : //
     200                 :            : // Creation Date : 07/14/00
     201                 :            : //-------------------------------------------------------------------------
     202                 :       9538 : void OCCCurve::append_simple_attribute_virt(const CubitSimpleAttrib &csa)
     203                 :       9538 :   { OCCAttribSet::append_attribute(csa, *myTopoDSEdge); }
     204                 :            : 
     205                 :            : //-------------------------------------------------------------------------
     206                 :            : // Purpose       : The purpose of this function is to remove a simple 
     207                 :            : //                 attribute attached to this geometry entity. The name is 
     208                 :            : //                 removed from the underlying BODY this points to.
     209                 :            : //
     210                 :            : // Special Notes : 
     211                 :            : //
     212                 :            : // Creator       : Steve Owen
     213                 :            : //
     214                 :            : // Creation Date : 07/14/00
     215                 :            : //-------------------------------------------------------------------------
     216                 :      89419 : void OCCCurve::remove_simple_attribute_virt(const CubitSimpleAttrib& csa)
     217                 :      89419 :   { OCCAttribSet::remove_attribute(csa, *myTopoDSEdge); }
     218                 :            : 
     219                 :            : //-------------------------------------------------------------------------
     220                 :            : // Purpose       : The purpose of this function is to remove all simple 
     221                 :            : //                 attributes attached to this geometry entity.  Also
     222                 :            : //                 removes lingering GTC attributes.
     223                 :            : //
     224                 :            : //
     225                 :            : // Special Notes : 
     226                 :            : //
     227                 :            : // Creator       : Steve Owen
     228                 :            : //
     229                 :            : // Creation Date : 07/14/00
     230                 :            : //-------------------------------------------------------------------------
     231                 :      73865 : void OCCCurve::remove_all_simple_attribute_virt()
     232                 :            : {
     233         [ +  - ]:      73865 :   OCCAttribSet::remove_attribute(CubitSimpleAttrib(), *myTopoDSEdge);
     234                 :      73865 : }
     235                 :            : 
     236                 :            : //-------------------------------------------------------------------------
     237                 :            : // Purpose       : The purpose of this function is to get the  
     238                 :            : //                 attributes attached to this geometry entity. The name is 
     239                 :            : //                 attached to the underlying BODY this points to.
     240                 :            : //
     241                 :            : // Special Notes : 
     242                 :            : //
     243                 :            : // Creator       : Steve Owen
     244                 :            : //
     245                 :            : // Creation Date : 07/14/00
     246                 :            : //-------------------------------------------------------------------------
     247                 :      47988 : CubitStatus OCCCurve::get_simple_attribute(DLIList<CubitSimpleAttrib>&
     248                 :            :                                                csa_list)
     249                 :      47988 :   { return OCCAttribSet::get_attributes(*myTopoDSEdge, csa_list); }
     250                 :            :   
     251                 :     421057 : CubitStatus OCCCurve::get_simple_attribute( const CubitString& name,
     252                 :            :                                       DLIList<CubitSimpleAttrib>& csa_list)
     253                 :     421057 :   { return OCCAttribSet::get_attributes( name, *myTopoDSEdge, csa_list ); }
     254                 :            : 
     255                 :            : //-------------------------------------------------------------------------
     256                 :            : // Purpose       : Get geometry modeling engine: OCCQueryEngine
     257                 :            : //
     258                 :            : // Special Notes :
     259                 :            : //
     260                 :            : // Creator       : Steve Owen
     261                 :            : //
     262                 :            : // Creation Date : 07/14/00
     263                 :            : //-------------------------------------------------------------------------
     264                 :      15060 : GeometryQueryEngine* OCCCurve::get_geometry_query_engine() const
     265                 :            : {
     266                 :      15060 :   return OCCQueryEngine::instance();
     267                 :            : }                 
     268                 :            : 
     269                 :            : //-------------------------------------------------------------------------
     270                 :            : // Purpose       : Get the bounding box of the object.
     271                 :            : //
     272                 :            : // Special Notes :
     273                 :            : //
     274                 :            : // Creator       : Steve Owen
     275                 :            : //
     276                 :            : // Creation Date : 10/23/96
     277                 :            : //-------------------------------------------------------------------------
     278                 :       4215 : CubitBox OCCCurve::bounding_box() const 
     279                 :            : {
     280         [ +  - ]:       4215 :   BRepAdaptor_Curve acurve(*myTopoDSEdge);
     281         [ +  - ]:       4215 :   Bnd_Box aBox;
     282 [ +  - ][ +  - ]:       4215 :   BndLib_Add3dCurve::Add(acurve, Precision::Approximation(), aBox);
     283                 :            :   double min[3], max[3];
     284         [ +  - ]:       4215 :   aBox.Get( min[0], min[1], min[2], max[0], max[1], max[2]);
     285 [ +  - ][ +  - ]:       4215 :   return CubitBox(min, max);
     286                 :            : }
     287                 :            : 
     288                 :            : 
     289                 :            : //-------------------------------------------------------------------------
     290                 :            : // Purpose       : Return the length of the curve.
     291                 :            : //
     292                 :            : // Special Notes :
     293                 :            : //
     294                 :            : // Creator       : Steve Owen
     295                 :            : //
     296                 :            : // Creation Date : 07/14/00
     297                 :            : //-------------------------------------------------------------------------
     298                 :      41579 : double OCCCurve::measure()
     299                 :            : {
     300         [ +  - ]:      41579 :   GProp_GProps myProps;
     301         [ +  - ]:      41579 :   BRepGProp::LinearProperties(*myTopoDSEdge, myProps);
     302         [ +  - ]:      41579 :   return myProps.Mass();
     303                 :            : }
     304                 :            : 
     305                 :            : //-------------------------------------------------------------------------
     306                 :            : // Purpose       : Return the arc length along the Curve starting from
     307                 :            : //                 the point represented by the parameter1 going to the 
     308                 :            : //                 point represented by parameter2.
     309                 :            : //
     310                 :            : // Special Notes : The sign of the returned length value is always positive.
     311                 :            : //                 Parameter1 and parameter2 are with respect to the EDGE.
     312                 :            : //
     313                 :            : // Creator       : Steve Owen
     314                 :            : //
     315                 :            : // Creation Date : 07/14/00
     316                 :            : //-------------------------------------------------------------------------
     317                 :          0 : double OCCCurve::length_from_u( double parameter1, double parameter2 )
     318                 :            : {
     319         [ #  # ]:          0 :   BRepAdaptor_Curve acurve(*myTopoDSEdge);
     320 [ #  # ][ #  # ]:          0 :   return GCPnts_AbscissaPoint::Length(acurve, parameter1, parameter2);
     321                 :            : }
     322                 :            : 
     323                 :            : //-------------------------------------------------------------------------
     324                 :            : // Purpose       : Returns CUBIT_TRUE and the associated period value. Not
     325                 :            : //                 implemented yet
     326                 :            : //
     327                 :            : // Special Notes :  
     328                 :            : //
     329                 :            : // Creator       : Steve Owen
     330                 :            : //
     331                 :            : // Creation Date : 07/14/00
     332                 :            : //-------------------------------------------------------------------------
     333                 :      15270 : CubitBoolean OCCCurve::is_periodic(double& period)
     334                 :            : {
     335         [ +  - ]:      15270 :   BRepAdaptor_Curve acurve(*myTopoDSEdge);
     336 [ +  - ][ +  + ]:      15270 :   if (acurve.IsPeriodic())
     337                 :            :   {
     338         [ +  - ]:        280 :     period = acurve.Period();
     339                 :        280 :     return CUBIT_TRUE;
     340                 :            :   }
     341         [ +  - ]:      15270 :   return CUBIT_FALSE;
     342                 :            : }
     343                 :            : 
     344                 :            : //------------------------------------------------------------------
     345                 :            : // Purpose: Returns CUBIT_TRUE and the associated parametric values, 
     346                 :            : //          if the facet curve associated with the first EDGE is 
     347                 :            : //          parametric.
     348                 :            : //          Otherwise returns CUBIT_FALSE and the values of 
     349                 :            : //          the lower and upper parametric bounds are undetermined.
     350                 :            : //          NOT IMPLEMENTED YET
     351                 :            : //
     352                 :            : // Creator       : Steve Owen
     353                 :            : //
     354                 :            : // Creation Date : 07/14/00
     355                 :            : //-------------------------------------------------------------------
     356                 :     386913 : CubitBoolean OCCCurve::get_param_range( double& lower_bound,
     357                 :            :                                         double& upper_bound )
     358                 :            : {
     359         [ +  - ]:     386913 :   BRepAdaptor_Curve acurve(*myTopoDSEdge);
     360         [ +  - ]:     386913 :   lower_bound = acurve.FirstParameter();
     361         [ +  - ]:     386913 :   upper_bound = acurve.LastParameter();
     362         [ +  - ]:     386913 :   return CUBIT_TRUE;
     363                 :            : }
     364                 :            : 
     365                 :            : 
     366                 :            : //------------------------------------------------------------------
     367                 :            : // Purpose:        Finds the extrema along this Curve. 
     368                 :            : //
     369                 :            : // Special Notes : It is the responsibility of the
     370                 :            : //                 calling code to delete the CubitVectors added to 
     371                 :            : //                 interior_points!
     372                 :            : //
     373                 :            : // Creator       : Jason Kraftcheck
     374                 :            : //
     375                 :            : // Creation Date : 05/29/01
     376                 :            : //-------------------------------------------------------------------
     377                 :          0 : CubitStatus OCCCurve::get_interior_extrema(
     378                 :            :   DLIList<CubitVector*>& interior_points,
     379                 :            :   CubitSense& return_sense )
     380                 :            : {
     381         [ #  # ]:          0 :   DLIList<CubitVector*> point_list;
     382         [ #  # ]:          0 :   CubitVector x(1.0, 0.0, 0.0);
     383 [ #  # ][ #  # ]:          0 :   get_interior_extrema_in_direction(point_list, x);
     384         [ #  # ]:          0 :   CubitVector y(0.0, 1.0, 0.0);
     385 [ #  # ][ #  # ]:          0 :   get_interior_extrema_in_direction(point_list, y);
     386         [ #  # ]:          0 :   CubitVector z(0.0, 0.0, 1.0);
     387 [ #  # ][ #  # ]:          0 :   get_interior_extrema_in_direction(point_list, z );
     388                 :            : 
     389                 :            :   //like , return only points that aren't at an endpoint and are not
     390                 :            :   //close to previous point
     391                 :          0 :   const double epsilon = 30.* GEOMETRY_RESABS;
     392                 :          0 :   const double epsilon_squared = epsilon*epsilon;
     393                 :            : 
     394                 :            :   //get both vertices' coordinates.
     395 [ #  # ][ #  # ]:          0 :   CubitVector endpoints[2];
     396                 :          0 :   int i = 0;
     397 [ #  # ][ #  # ]:          0 :   TopExp_Explorer aVertexExp(*myTopoDSEdge, TopAbs_VERTEX);
     398 [ #  # ][ #  # ]:          0 :   while(aVertexExp.More())
     399                 :            :   {
     400 [ #  # ][ #  # ]:          0 :      TopoDS_Vertex v = TopoDS::Vertex(aVertexExp.Current());
                 [ #  # ]
     401         [ #  # ]:          0 :      gp_Pnt p = BRep_Tool::Pnt(v);
     402 [ #  # ][ #  # ]:          0 :      endpoints[i].x(p.X());
     403 [ #  # ][ #  # ]:          0 :      endpoints[i].y(p.Y());
     404 [ #  # ][ #  # ]:          0 :      endpoints[i].z(p.Z());  
     405                 :          0 :      i++;
     406         [ #  # ]:          0 :      aVertexExp.Next();
     407         [ #  # ]:          0 :   } 
     408                 :            : 
     409                 :            :   //compare to see if the Points in point_list are interior and far apart
     410                 :            :   int j;
     411                 :          0 :   CubitVector* cubit_position = NULL;
     412                 :          0 :   CubitVector * temp_position = NULL;
     413         [ #  # ]:          0 :   point_list.sort();
     414         [ #  # ]:          0 :   point_list.reset();
     415 [ #  # ][ #  # ]:          0 :   for (j = point_list.size(); j--; )
     416                 :            :   {
     417         [ #  # ]:          0 :      temp_position = point_list.get_and_step();
     418                 :            :      // save if not equal to an endpoint, or prior point
     419 [ #  # ][ #  # ]:          0 :      if (temp_position->distance_between_squared(endpoints[0]) > epsilon_squared
     420 [ #  # ][ #  # ]:          0 :         &&
     421         [ #  # ]:          0 :         temp_position->distance_between_squared(endpoints[1]) > epsilon_squared)
     422                 :            :      {
     423 [ #  # ][ #  # ]:          0 :         if (!cubit_position ||
                 [ #  # ]
     424         [ #  # ]:          0 :             temp_position->distance_between_squared(*cubit_position) > epsilon_squared)
     425                 :            :         {
     426                 :          0 :           cubit_position = temp_position ;
     427         [ #  # ]:          0 :           interior_points.append( cubit_position );
     428                 :            :         } // If point isn't close to previous point
     429                 :            :      } // If point isn't at an endpoint
     430                 :            :   } // for each point
     431                 :            : 
     432                 :            :   // Return sense is whatever the sense of this curve is.
     433         [ #  # ]:          0 :   TopAbs_Orientation sense = myTopoDSEdge->Orientation();
     434                 :          0 :   return_sense = (sense == TopAbs_FORWARD ? CUBIT_FORWARD : CUBIT_REVERSED);
     435                 :            :  
     436         [ #  # ]:          0 :   return CUBIT_SUCCESS;
     437                 :            : }
     438                 :            : 
     439                 :          0 : CubitStatus OCCCurve::get_interior_extrema_in_direction(
     440                 :            :                         DLIList<CubitVector*>& interior_points,
     441                 :            :                         CubitVector dir)
     442                 :            : {
     443                 :            :   //Create a straight line.
     444         [ #  # ]:          0 :   gp_Pnt origin(0.0, 0.0, 0.0);
     445 [ #  # ][ #  # ]:          0 :   gp_Dir adir(dir.x(), dir.y(), dir.z());
         [ #  # ][ #  # ]
     446 [ #  # ][ #  # ]:          0 :   Handle(Geom_Line) line = GC_MakeLine(origin, adir);
                 [ #  # ]
     447                 :            : 
     448                 :            :   //get the Geom_Curve of the OCCCurve
     449                 :            :   Standard_Real first;
     450                 :            :   Standard_Real last;
     451 [ #  # ][ #  # ]:          0 :   Handle(Geom_Curve) myCurve = BRep_Tool::Curve(*myTopoDSEdge, first, last);
     452                 :            :   
     453 [ #  # ][ #  # ]:          0 :   GeomAPI_ExtremaCurveCurve extrema(myCurve, line);
     454         [ #  # ]:          0 :   int nPnt = extrema.NbExtrema();
     455         [ #  # ]:          0 :   for (int i = 1; i <= nPnt ; i++)
     456                 :            :   {
     457 [ #  # ][ #  # ]:          0 :     gp_Pnt P1, P2;
     458         [ #  # ]:          0 :     extrema.Points(i, P1, P2);
     459 [ #  # ][ #  # ]:          0 :     CubitVector* v = new CubitVector(P1.X(), P1.Y(), P1.Z());
         [ #  # ][ #  # ]
                 [ #  # ]
     460         [ #  # ]:          0 :     interior_points.append(v);
     461                 :            :   }
     462         [ #  # ]:          0 :   return CUBIT_SUCCESS;
     463                 :            : }  
     464                 :            : //-------------------------------------------------------------------------
     465                 :            : // Purpose       : This function computes the point on the curve closest 
     466                 :            : //                 to the input location.  Optionally, it can also compute
     467                 :            : //                 the tangent and curvature on the Curve at the point on
     468                 :            : //                 on the Curve closest to the input location.
     469                 :            : //
     470                 :            : // Special Notes : The tangent direction is always in the positive direction of the 
     471                 :            : //                 owning RefEdge, regardless of the positive direction of the
     472                 :            : //                 underlying solid model entities.
     473                 :            : //
     474                 :            : //                 If the calling code needs the tangent and/or the curvature,
     475                 :            : //                 it is responsible for allocating the memory for these
     476                 :            : //                 CubitVector(s) and sending in the relevant non-NULL
     477                 :            : //                 pointers to this routine.
     478                 :            : //
     479                 :            : // Creator       : Steve Owen
     480                 :            : //
     481                 :            : // Creation Date : 07/14/00
     482                 :            : //-------------------------------------------------------------------------
     483                 :      42170 : CubitStatus OCCCurve::closest_point( 
     484                 :            :   CubitVector const& location, 
     485                 :            :   CubitVector& closest_location,
     486                 :            :   CubitVector* tangent_ptr,
     487                 :            :   CubitVector* curvature_ptr,
     488                 :            :   double* param)
     489                 :            : {  
     490         [ +  - ]:      42170 :   BRepAdaptor_Curve acurve(*myTopoDSEdge);
     491 [ +  - ][ +  - ]:      42170 :   gp_Pnt p(location.x(), location.y(), location.z()), newP(0.0, 0.0, 0.0);
         [ +  - ][ +  - ]
                 [ +  - ]
     492 [ +  - ][ +  - ]:      84340 :   Extrema_ExtPC ext(p, acurve, Precision::Approximation());
                 [ +  - ]
     493 [ +  - ][ +  + ]:      42170 :   if (!ext.IsDone())
     494                 :       1921 :     return CUBIT_FAILURE;
     495                 :            : 
     496                 :      40249 :   double sqr_dist = CUBIT_DBL_MAX;
     497                 :      40249 :   double pparam = 0.0;
     498 [ +  - ][ +  + ]:      81089 :   for (int i = 1; i <= ext.NbExt(); ++i) {
     499 [ +  - ][ +  - ]:      40840 :       double new_sqr_dist = p.SquareDistance( ext.Point(i).Value() );
                 [ +  - ]
     500         [ +  + ]:      40840 :       if (new_sqr_dist < sqr_dist) {
     501                 :      40249 :         sqr_dist = new_sqr_dist;
     502 [ +  - ][ +  - ]:      40249 :         newP = ext.Point(i).Value();
     503 [ +  - ][ +  - ]:      40249 :         pparam = ext.Point(i).Parameter();
     504                 :            :       }
     505                 :            :   }
     506                 :            : 
     507                 :            :     // if we didn't find any minimum...
     508         [ -  + ]:      40249 :   if (sqr_dist == CUBIT_DBL_MAX)
     509                 :          0 :     return CUBIT_FAILURE;
     510                 :            : 
     511                 :            :     // pass back closest point
     512 [ +  - ][ +  - ]:      40249 :   closest_location.set( newP.X(), newP.Y(), newP.Z() );
         [ +  - ][ +  - ]
     513         [ +  + ]:      40249 :   if (param != NULL)
     514                 :      15281 :     *param = pparam;
     515                 :            : 
     516                 :            :     // pass back tangent
     517         [ +  + ]:      40249 :   if (tangent_ptr != NULL) {
     518 [ +  - ][ +  - ]:       3768 :     BRepLProp_CLProps CLP(acurve, 2, Precision::PConfusion());
     519         [ +  - ]:       3768 :     CLP.SetParameter( pparam );
     520 [ +  - ][ -  + ]:       3768 :     if (!CLP.IsTangentDefined())
     521                 :          0 :       return CUBIT_FAILURE;
     522                 :            : 
     523         [ +  - ]:       3768 :     gp_Dir tangent;
     524         [ +  - ]:       3768 :     CLP.Tangent(tangent);
     525 [ +  - ][ +  - ]:       3768 :     tangent_ptr->set( tangent.X(), tangent.Y(), tangent.Z() );
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
     526                 :            :   }
     527                 :            : 
     528                 :            :     // if requested, pass back curvature
     529         [ -  + ]:      40249 :   if (curvature_ptr != NULL)
     530         [ #  # ]:          0 :     get_curvature( closest_location, *curvature_ptr );
     531                 :            : 
     532         [ +  - ]:      82419 :   return CUBIT_SUCCESS;
     533                 :            : }
     534                 :            : 
     535                 :            : 
     536                 :            : //------------------------------------------------------------------
     537                 :            : // Purpose: This function returns the coordinate of a point in the local
     538                 :            : //          parametric (u) space that corresponds to the input position 
     539                 :            : //          in global (world) space.  The input point is first moved to 
     540                 :            : //          the closest point on the Curve and the parameter value of 
     541                 :            : //          that point is determined. 
     542                 :            : //
     543                 :            : // Creator       : Steve Owen
     544                 :            : //
     545                 :            : // Creation Date : 07/14/00
     546                 :            : //-------------------------------------------------------------------
     547                 :     370287 : CubitStatus OCCCurve::position_from_u (double u_value,
     548                 :            :                                         CubitVector& output_position)
     549                 :            : {
     550         [ +  - ]:     370287 :   BRepAdaptor_Curve acurve(*myTopoDSEdge);
     551         [ +  - ]:     370287 :   gp_Pnt p = acurve.Value(u_value);
     552 [ +  - ][ +  - ]:     370287 :   output_position.x(p.X());
     553 [ +  - ][ +  - ]:     370287 :   output_position.y(p.Y());
     554 [ +  - ][ +  - ]:     370287 :   output_position.z(p.Z());
     555         [ +  - ]:     370287 :   return CUBIT_SUCCESS;
     556                 :            : }
     557                 :            : 
     558                 :            : //-------------------------------------------------------------------------
     559                 :            : // Purpose       : This function returns the coordinate of a point in the local
     560                 :            : //                 parametric (u) space that corresponds to the input position 
     561                 :            : //                 in global (world) space.  The input point is first moved to 
     562                 :            : //                 the closest point on the Curve and the parameter value of 
     563                 :            : //                 that point is determined. 
     564                 :            : //
     565                 :            : // Special Notes : 
     566                 :            : //
     567                 :            : // Creator       : Malcolm J. Panthaki
     568                 :            : //
     569                 :            : // Creation Date : 2/25/97
     570                 :            : //-------------------------------------------------------------------------
     571                 :         11 : double OCCCurve::u_from_position (const CubitVector& input_position)
     572                 :            : {
     573                 :            :     // Get the closest point on the Curve to the input position
     574         [ +  - ]:         11 :   CubitVector closest_point;
     575                 :            :   double u_val;
     576                 :            :   this->closest_point(input_position, closest_point,
     577         [ +  - ]:         11 :                       NULL, NULL, &u_val);
     578                 :            :     // closest_point already makes adjustments for sense and periodicity
     579                 :            :   
     580                 :         11 :   return u_val;
     581                 :            : }
     582                 :            : 
     583                 :            : //------------------------------------------------------------------
     584                 :            : // Purpose: This function returns the parameter value of the point 
     585                 :            : //          that is "arc_length" away from the root point, in the
     586                 :            : //          positive sense direction of the owning RefEdge.
     587                 :            : //
     588                 :            : // Special Notes : 
     589                 :            : //   If arc_length is negative, the new point (whose parameter value
     590                 :            : //   is being computed) is in the negative sense direction (along
     591                 :            : //   the RefEdge) from the root point (whose parameter value is
     592                 :            : //   root_param).
     593                 :            : //
     594                 :            : //   If the curve is not periodic and the new point, "arc_length"
     595                 :            : //   away from the root point in the appropriate direction, goes
     596                 :            : //   beyond the end point of the first EDGE, that end point is used
     597                 :            : //   to generate the returned parameter value.
     598                 :            : //
     599                 :            : // If the curve is periodic and the new point, "arc_length" away
     600                 :            : // from the root point in the appropriate direction, goes beyond
     601                 :            : // the end point of the first EDGE, wrap around is done.  After
     602                 :            : // wrap around, the point is treated as with other curves
     603                 :            : //
     604                 :            : // NOTE:
     605                 :            : // The important assumption that is made in this routine is that
     606                 :            : // the end points of the RefEdge that owns this Curve are the
     607                 :            : // same as the end points of the first  EDGE in the list of EDGEs
     608                 :            : // associated with this Curve.
     609                 :            : //
     610                 :            : // Assume that the parameter root_param is with respect to the
     611                 :            : // RefEdge as well as arc_length.  Before calling the  "curve",
     612                 :            : // we need to get them with respect to the curve.   
     613                 :            : //
     614                 :            : // Creator       : Malcolm J. Panthaki
     615                 :            : //
     616                 :            : // Creation Date : 2/28/97
     617                 :            : //------------------------------------------------------------------
     618                 :       1726 : double OCCCurve::u_from_arc_length ( double root_param,
     619                 :            :                                        double arc_length )
     620                 :            : {
     621         [ +  - ]:       1726 :   BRepAdaptor_Curve acurve(*myTopoDSEdge);
     622 [ +  - ][ +  - ]:       3452 :   GCPnts_AbscissaPoint abs(acurve, arc_length, root_param);
     623 [ +  - ][ +  - ]:       1726 :   if (abs.IsDone()) return abs.Parameter();
                 [ +  - ]
     624         [ +  - ]:       1726 :   else return 0.0;
     625                 :            : }
     626                 :            : 
     627                 :            : //-------------------------------------------------------------------------
     628                 :            : // Purpose       : This function tests the passed in position to see if
     629                 :            : //                 is on the underlying curve. 
     630                 :            : //
     631                 :            : // Special Notes :
     632                 :            : //
     633                 :            : // Creator       : Steve Owen
     634                 :            : //
     635                 :            : // Creation Date : 07/14/00
     636                 :            : //-------------------------------------------------------------------------
     637                 :       3216 : CubitBoolean OCCCurve::is_position_on( const CubitVector &test_position )
     638                 :            : {
     639         [ +  - ]:       3216 :   CubitVector new_point;
     640         [ +  - ]:       3216 :   CubitStatus stat = closest_point(test_position, new_point, NULL,NULL,NULL);
     641                 :            : 
     642         [ +  + ]:       3216 :   if ( !stat )
     643                 :        198 :     return CUBIT_FALSE;
     644         [ +  - ]:       3018 :   CubitVector result_vec = test_position - new_point;
     645 [ +  - ][ +  + ]:       3018 :   if ( result_vec.length_squared() < GEOMETRY_RESABS )
     646                 :        352 :     return CUBIT_TRUE;
     647                 :       3216 :   return CUBIT_FALSE;
     648                 :            : }
     649                 :            : 
     650                 :            : //-------------------------------------------------------------------------
     651                 :            : // Purpose       : This function returns the type of underlying curve. 
     652                 :            : //
     653                 :            : // Special Notes : It checks to see if *any* of the  curves associated
     654                 :            : //                 with the EDGEs in the list of EDGEs of this Curve is of
     655                 :            : //                 a particular type and returns the appropriate value
     656                 :            : //                 of the enum, CurveType.
     657                 :            : //
     658                 :            : // Creator       : Steve Owen
     659                 :            : //
     660                 :            : // Creation Date : 07/14/00
     661                 :            : //-------------------------------------------------------------------------
     662                 :       1625 : GeometryType OCCCurve::geometry_type()
     663                 :            : {
     664         [ +  - ]:       1625 :   BRepAdaptor_Curve acurve(*myTopoDSEdge);
     665 [ +  - ][ -  + ]:       1625 :   if (acurve.GetType() == GeomAbs_BezierCurve)
     666                 :          0 :      return SPLINE_CURVE_TYPE;
     667 [ +  - ][ +  + ]:       1625 :   if (acurve.GetType() == GeomAbs_BSplineCurve)
     668                 :         11 :      return SPLINE_CURVE_TYPE;
     669 [ +  - ][ +  + ]:       1614 :   if (acurve.GetType() == GeomAbs_Line)
     670                 :       1479 :      return STRAIGHT_CURVE_TYPE;
     671 [ +  - ][ +  + ]:        135 :   if (acurve.GetType() == GeomAbs_Parabola)
     672                 :         11 :      return PARABOLA_CURVE_TYPE;
     673 [ +  - ][ +  + ]:        124 :   if (acurve.GetType() == GeomAbs_Hyperbola)
     674                 :         11 :      return HYPERBOLA_CURVE_TYPE;
     675 [ +  - ][ +  + ]:        113 :   if (acurve.GetType() == GeomAbs_Circle)
     676                 :        102 :       return ARC_CURVE_TYPE;
     677 [ +  - ][ +  - ]:         11 :   if (acurve.GetType() == GeomAbs_Ellipse)
     678                 :         11 :      return ELLIPSE_CURVE_TYPE;
     679         [ +  - ]:       1625 :   return UNDEFINED_CURVE_TYPE;
     680                 :            : }
     681                 :            : 
     682                 :            : //-------------------------------------------------------------------------
     683                 :            : // Purpose       : Return direction of point on curve
     684                 :            : //
     685                 :            : // Special Notes : Finds the underlying line's origin and direction unit vector
     686                 :            : //
     687                 :            : // Creator       : Jane Hu
     688                 :            : //
     689                 :            : // Creation Date : 11/14/07
     690                 :            : //-------------------------------------------------------------------------
     691                 :          0 : CubitStatus OCCCurve::get_point_direction( CubitVector& point, 
     692                 :            :                                            CubitVector& direction )
     693                 :            : {
     694 [ #  # ][ #  # ]:          0 :   if (geometry_type() != STRAIGHT_CURVE_TYPE)
     695                 :          0 :     return CUBIT_FAILURE;
     696                 :            : 
     697                 :            :   //get the underlying geometry curve
     698                 :            :   double first,last;
     699         [ #  # ]:          0 :   Handle(Geom_Curve) gCurve = BRep_Tool::Curve(*myTopoDSEdge, first, last);
     700                 :            : 
     701                 :            :   //get the origin and direction of the underlying curve
     702 [ #  # ][ #  # ]:          0 :   Handle(Geom_Line) gLine = Handle(Geom_Line)::DownCast(gCurve);
     703 [ #  # ][ #  # ]:          0 :   gp_Ax1 axis = gLine->Position();
     704         [ #  # ]:          0 :   gp_Pnt loc = axis.Location();
     705         [ #  # ]:          0 :   gp_Dir dir = axis.Direction();
     706 [ #  # ][ #  # ]:          0 :   point.set(loc.X(), loc.Y(), loc.Z());
         [ #  # ][ #  # ]
     707                 :            : 
     708                 :            :   //Based on the TopoDS_Edge's orientation, give the unit vector.
     709 [ #  # ][ #  # ]:          0 :   if (myTopoDSEdge->Orientation() == TopAbs_FORWARD)
     710 [ #  # ][ #  # ]:          0 :     direction.set(dir.X(), dir.Y(), dir.Z());
         [ #  # ][ #  # ]
     711 [ #  # ][ #  # ]:          0 :   else if(myTopoDSEdge->Orientation() == TopAbs_REVERSED)
     712 [ #  # ][ #  # ]:          0 :     direction.set(-dir.X(), -dir.Y(), -dir.Z());
         [ #  # ][ #  # ]
     713         [ #  # ]:          0 :   return CUBIT_SUCCESS;  
     714                 :            : }
     715                 :            : 
     716                 :            : //-------------------------------------------------------------------------
     717                 :            : // Purpose       : Return the center and radius of an arc
     718                 :            : //
     719                 :            : // Special Notes : not currently implemented
     720                 :            : //
     721                 :            : // Creator       : Steve Owen
     722                 :            : //
     723                 :            : // Creation Date : 07/14/00
     724                 :            : //-------------------------------------------------------------------------
     725                 :          0 : CubitStatus OCCCurve::get_center_radius( CubitVector& center, 
     726                 :            :                                            double& radius )
     727                 :            : {
     728 [ #  # ][ #  # ]:          0 :   if( geometry_type() != ELLIPSE_CURVE_TYPE &&
         [ #  # ][ #  # ]
     729         [ #  # ]:          0 :       geometry_type() != ARC_CURVE_TYPE )
     730                 :          0 :     return CUBIT_FAILURE;
     731                 :            :  
     732                 :            :   //get the Geom_Curve of the OCCCurve
     733                 :            :   Standard_Real first;
     734                 :            :   Standard_Real last;
     735         [ #  # ]:          0 :   Handle(Geom_Curve) myCurve = BRep_Tool::Curve(*myTopoDSEdge, first, last); 
     736                 :            : 
     737 [ #  # ][ #  # ]:          0 :   if (Handle(Geom_Circle) gCircle = Handle(Geom_Circle)::DownCast(myCurve))
                 [ #  # ]
     738                 :            :   {
     739 [ #  # ][ #  # ]:          0 :      radius = gCircle->Radius();
     740 [ #  # ][ #  # ]:          0 :      gp_Circ gp_circ = gCircle->Circ();
     741         [ #  # ]:          0 :      gp_Pnt  gp_p = gp_circ.Location();
     742 [ #  # ][ #  # ]:          0 :      center.set(gp_p.X(), gp_p.Y(), gp_p.Z());
         [ #  # ][ #  # ]
     743                 :            :   }
     744                 :            : 
     745                 :            :   else //ellipse
     746                 :            :   {
     747         [ #  # ]:          0 :      Handle(Geom_Ellipse) gEllipse = Handle(Geom_Ellipse)::DownCast(myCurve);
     748 [ #  # ][ #  # ]:          0 :      radius = gEllipse->MajorRadius();
     749 [ #  # ][ #  # ]:          0 :      gp_Elips gp_ellip = gEllipse->Elips();
     750         [ #  # ]:          0 :      gp_Pnt  gp_p = gp_ellip.Location();
     751 [ #  # ][ #  # ]:          0 :      center.set(gp_p.X(), gp_p.Y(), gp_p.Z());
         [ #  # ][ #  # ]
                 [ #  # ]
     752         [ #  # ]:          0 :   }
     753         [ #  # ]:          0 :   return CUBIT_SUCCESS;
     754                 :            : }
     755                 :            : 
     756                 :            : //-------------------------------------------------------------------------
     757                 :            : // Purpose       : This function returns the start parameter.
     758                 :            : //
     759                 :            : // Special Notes : The start param is with respect to the ref_edge.
     760                 :            : //
     761                 :            : // Creator       : Steve Owen
     762                 :            : //
     763                 :            : // Creation Date : 07/14/00
     764                 :            : //-------------------------------------------------------------------------
     765                 :      85590 : double OCCCurve::start_param()
     766                 :            : {
     767                 :      85590 :    double start = 0.0, end = 0.0;
     768         [ +  - ]:      85590 :    get_param_range( start, end );
     769                 :      85590 :    return start;
     770                 :            : }
     771                 :            : 
     772                 :            : //-------------------------------------------------------------------------
     773                 :            : // Purpose       : This function returns the end parameter.
     774                 :            : //
     775                 :            : // Special Notes : The end param is with respect to the ref_edge.
     776                 :            : //
     777                 :            : // Creator       : Steve Owen
     778                 :            : //
     779                 :            : // Creation Date : 07/14/00
     780                 :            : //-------------------------------------------------------------------------
     781                 :      51090 : double OCCCurve::end_param()
     782                 :            : {
     783                 :      51090 :    double start = 0.0, end = 0.0;
     784                 :            :    
     785         [ +  - ]:      51090 :    get_param_range( start, end );
     786                 :      51090 :    return end;
     787                 :            : }
     788                 :            : 
     789                 :            : 
     790                 :       9364 : void OCCCurve::get_parents_virt( DLIList<TopologyBridge*>& parents ) 
     791                 :            : { 
     792                 :            :    //check to see all myLoops are up-to-date.
     793                 :       9364 :    add_loop(NULL);
     794                 :            : 
     795         [ +  + ]:      24954 :    for(int i = 0; i < myLoopList.size(); i++) 
     796                 :            :    {
     797 [ +  - ][ +  - ]:      15590 :       DLIList<OCCCoEdge*> coedges = myLoopList.get_and_step()->coedges();
     798                 :            :     
     799 [ +  - ][ +  - ]:      52744 :       for(int j = 0; j < coedges.size(); j++)
     800                 :            :       {
     801         [ +  - ]:      52744 :         OCCCoEdge * coedge = coedges.get_and_step();
     802 [ +  - ][ +  + ]:      52744 :         if(coedge->curve() == this)
     803                 :            :         {
     804         [ +  - ]:      15590 :           parents.append(coedge);
     805                 :      15590 :           break;
     806                 :            :         }
     807                 :            :       }
     808         [ +  - ]:      15590 :    }
     809                 :       9364 : }
     810                 :     211931 : void OCCCurve::get_children_virt( DLIList<TopologyBridge*>& children ) 
     811                 :            : {
     812         [ +  - ]:     211931 :         TopTools_IndexedMapOfShape M;
     813         [ +  - ]:     211931 :         TopExp::MapShapes(*myTopoDSEdge, TopAbs_VERTEX, M);
     814                 :            :         int ii ;
     815 [ +  - ][ +  + ]:     626606 :         for (ii = M.Extent();  ii > 0; ii--) {
     816 [ +  - ][ +  - ]:     414675 :              TopologyBridge *point = OCCQueryEngine::instance()->occ_to_cgm(M(ii));
                 [ +  - ]
     817         [ +  + ]:     414675 :               if (point)
     818         [ +  - ]:     390362 :                 children.append_unique(point);
     819                 :            :        }
     820 [ +  - ][ +  + ]:     211931 :        if(children.size() ==0)
     821                 :     219410 :          return;
     822                 :            :        //make sure the points are in the start-end order
     823                 :            :        double start , end;     
     824         [ +  - ]:     204452 :        get_param_range( start, end );
     825         [ +  - ]:     204452 :        CubitVector v;
     826         [ +  - ]:     204452 :        position_from_u(start, v);
     827         [ +  - ]:     204452 :        children.reset();
     828 [ +  - ][ +  - ]:     204452 :        if(!v.about_equal(CAST_TO(children.get(), TBPoint)->coordinates())) 
         [ +  - ][ +  - ]
                 [ +  + ]
     829 [ +  - ][ +  - ]:     211931 :          children.reverse();
                 [ +  + ]
     830                 :            : }
     831                 :            :  
     832                 :            : 
     833                 :            : 
     834                 :            : 
     835                 :            : //-------------------------------------------------------------------------
     836                 :            : // Purpose       : Check for G1 discontinuity
     837                 :            : //
     838                 :            : // Special Notes : returns tangency discontinuity all along the Curve
     839                 :            : //                 at the param, only returns minus tangent = plus tangent
     840                 :            : //                 when it's C1 continuity.
     841                 :            : //
     842                 :            : // Creator       : Jane Hu
     843                 :            : //
     844                 :            : // Creation Date : 11/14/07
     845                 :            : //-------------------------------------------------------------------------
     846                 :          0 : CubitBoolean OCCCurve::G1_discontinuous( 
     847                 :            :       double param, CubitVector* mtan, CubitVector* ptan )
     848                 :            : { 
     849                 :          0 :   CubitBoolean is_discon = CUBIT_TRUE;
     850                 :            :   double first, last;
     851         [ #  # ]:          0 :   Handle(Geom_Curve) gCurve = BRep_Tool::Curve(*myTopoDSEdge, first, last);
     852                 :            : 
     853 [ #  # ][ #  # ]:          0 :   if (gCurve->Continuity() < GeomAbs_G1)
                 [ #  # ]
     854                 :          0 :      return is_discon;
     855                 :            : 
     856 [ #  # ][ #  # ]:          0 :   assert(first <= param && param <= last );
     857                 :            :   
     858         [ #  # ]:          0 :   gp_Pnt P;
     859         [ #  # ]:          0 :   gp_Vec V1;
     860 [ #  # ][ #  # ]:          0 :   gCurve->D1(param, P, V1);
     861                 :            :   
     862 [ #  # ][ #  # ]:          0 :   mtan = new CubitVector(V1.X(), V1.Y(),V1.Z());
         [ #  # ][ #  # ]
                 [ #  # ]
     863 [ #  # ][ #  # ]:          0 :   ptan = new CubitVector(*mtan);
     864                 :            :      
     865         [ #  # ]:          0 :   return CUBIT_FALSE;
     866                 :            : }
     867                 :            : 
     868                 :      34333 : void OCCCurve::get_points( DLIList<OCCPoint*>& result_list )
     869                 :            : {
     870         [ +  - ]:      34333 :   TopTools_IndexedMapOfShape M;
     871         [ +  - ]:      34333 :   TopExp::MapShapes(*myTopoDSEdge, TopAbs_VERTEX, M);
     872                 :            :   int ii;
     873 [ +  - ][ +  + ]:     101134 :   for (ii=M.Extent(); ii>0; ii--) {
     874 [ +  - ][ +  - ]:      66801 :           TopologyBridge *point = OCCQueryEngine::instance()->occ_to_cgm(M(ii));
                 [ +  - ]
     875         [ +  + ]:      66801 :           if (point)
     876 [ -  + ][ +  - ]:      52988 :             result_list.append_unique(dynamic_cast<OCCPoint*>(point));
     877                 :            :   }
     878 [ +  - ][ +  + ]:      34333 :   if(result_list.size() ==0)
     879                 :      41284 :     return;
     880                 :            :   //make sure the points are in the start-end order
     881                 :            :   double start , end;     
     882         [ +  - ]:      27382 :   get_param_range( start, end );
     883         [ +  - ]:      27382 :   CubitVector v;
     884         [ +  - ]:      27382 :   position_from_u(start, v);
     885         [ +  - ]:      27382 :   result_list.reset();
     886 [ +  - ][ +  - ]:      27382 :   if(!v.about_equal(result_list.get()->coordinates()))
         [ +  - ][ +  + ]
     887 [ +  - ][ +  - ]:      34333 :     result_list.reverse();
                 [ +  + ]
     888                 :            : 
     889                 :            : }
     890                 :            : 
     891                 :          0 : void OCCCurve::get_tangent( CubitVector const& location,
     892                 :            :                             CubitVector& tangent)
     893                 :            : {
     894         [ #  # ]:          0 :     double u = u_from_position(location);
     895                 :            :     Standard_Real first;
     896                 :            :     Standard_Real last;
     897         [ #  # ]:          0 :     Handle(Geom_Curve) myCurve = BRep_Tool::Curve(*myTopoDSEdge, first, last);
     898                 :            :  
     899         [ #  # ]:          0 :     gp_Pnt p;
     900         [ #  # ]:          0 :     gp_Vec tan;
     901         [ #  # ]:          0 :     GeomLProp_CurveTool::D1(myCurve, u , p, tan) ;
     902 [ #  # ][ #  # ]:          0 :     tangent.set(tan.X(), tan.Y(), tan.Z());
         [ #  # ][ #  # ]
                 [ #  # ]
     903                 :          0 : } 
     904                 :            : 
     905                 :          0 : void OCCCurve::get_curvature( CubitVector const& location,
     906                 :            :                               CubitVector& curvature)
     907                 :            : {  
     908         [ #  # ]:          0 :     double u = u_from_position(location);
     909                 :            :     Standard_Real first;
     910                 :            :     Standard_Real last;
     911         [ #  # ]:          0 :     Handle(Geom_Curve) myCurve = BRep_Tool::Curve(*myTopoDSEdge, first, last);
     912                 :            : 
     913         [ #  # ]:          0 :     gp_Pnt p;
     914 [ #  # ][ #  # ]:          0 :     gp_Vec tan, cur;
     915         [ #  # ]:          0 :     GeomLProp_CurveTool::D2(myCurve, u , p, tan, cur) ;
     916 [ #  # ][ #  # ]:          0 :     curvature.set(cur.X(), cur.Y(), cur.Z()); 
         [ #  # ][ #  # ]
                 [ #  # ]
     917                 :          0 : }
     918                 :            : 
     919                 :            : // ********** END PUBLIC FUNCTIONS         **********
     920                 :            : 
     921                 :            : // ********** BEGIN PROTECTED FUNCTIONS    **********
     922                 :            : // ********** END PROTECTED FUNCTIONS      **********
     923                 :            : 
     924                 :            : // ********** BEGIN PRIVATE FUNCTIONS      **********
     925                 :            : 
     926                 :            : 
     927                 :            : //----------------------------------------------------------------
     928                 :            : // Adjusts the input parameter so that it falls within the
     929                 :            : // parameter range of this Curve, if possible.  Necessary for
     930                 :            : // periodic curves.
     931                 :            : //----------------------------------------------------------------
     932                 :          0 : void OCCCurve::adjust_periodic_parameter(double& param)
     933                 :            : {
     934                 :            :     // Adjustment only legal if this is a periodic curve.
     935                 :            :   double period;
     936 [ #  # ][ #  # ]:          0 :   if ( this->is_periodic(period) && (fabs(period) > CUBIT_RESABS))
         [ #  # ][ #  # ]
     937                 :            :   {
     938                 :            :     double upper_bound, lower_bound;
     939         [ #  # ]:          0 :     this->get_param_range( lower_bound, upper_bound );
     940         [ #  # ]:          0 :     assert((upper_bound - lower_bound) > CUBIT_RESABS * 100);
     941                 :            : 
     942                 :          0 :     lower_bound -= CUBIT_RESABS;
     943                 :          0 :     upper_bound += CUBIT_RESABS;
     944                 :            :     
     945                 :            :       // Make sure period is positive
     946         [ #  # ]:          0 :     if (period < 0.)
     947                 :          0 :       period = -period;
     948                 :            : 
     949                 :            :       // Move the parameter above the low param
     950         [ #  # ]:          0 :     while (param < lower_bound)
     951                 :          0 :       param += period;
     952                 :            :       // Move the parameter below the high param
     953         [ #  # ]:          0 :     while (param > upper_bound)
     954                 :          0 :       param -= period;
     955                 :            :   }
     956                 :          0 : }
     957                 :            : 
     958                 :            : //-------------------------------------------------------------------------
     959                 :            : // Purpose       : Return the spline parameters given a curve that is a spline
     960                 :            : //
     961                 :            : // Special Notes :
     962                 :            : //
     963                 :            : // Creator       : Jane Hu
     964                 :            : //
     965                 :            : // Creation Date : 2/20/2012
     966                 :            : //-------------------------------------------------------------------------
     967                 :          0 : CubitStatus OCCCurve::get_spline_params
     968                 :            : (
     969                 :            :   bool &rational,    // return true/false
     970                 :            :   int &degree,       // the degree of this spline
     971                 :            :   DLIList<CubitVector> &cntrl_pts,  // xyz position of controlpoints
     972                 :            :   DLIList<double> &cntrl_pt_weights, // if rational, a weight for each cntrl point.
     973                 :            :   DLIList<double> &knots   // There should be order+cntrl_pts.size()-2 knots
     974                 :            : ) const
     975                 :            : {
     976         [ #  # ]:          0 :   BRepAdaptor_Curve acurve(*myTopoDSEdge);
     977 [ #  # ][ #  # ]:          0 :   Handle_Geom_BSplineCurve h_S = NULL;
     978 [ #  # ][ #  # ]:          0 :   if (acurve.GetType() == GeomAbs_BSplineCurve)
     979 [ #  # ][ #  # ]:          0 :     h_S = acurve.BSpline();
                 [ #  # ]
     980                 :            :   else
     981                 :          0 :     return CUBIT_FAILURE;
     982 [ #  # ][ #  # ]:          0 :   assert ( h_S != NULL);
     983                 :            : 
     984 [ #  # ][ #  # ]:          0 :   rational = h_S->IsRational();
     985 [ #  # ][ #  # ]:          0 :   degree =   h_S->Degree();
     986                 :            :   
     987 [ #  # ][ #  # ]:          0 :   TColStd_Array1OfReal K(1, h_S->NbKnots());
         [ #  # ][ #  # ]
     988 [ #  # ][ #  # ]:          0 :   h_S->Knots(K);
     989 [ #  # ][ #  # ]:          0 :   for (int i = K.Lower(); i <= K.Upper(); i++)
                 [ #  # ]
     990 [ #  # ][ #  # ]:          0 :     knots.append(K.Value(i));
     991                 :            : 
     992 [ #  # ][ #  # ]:          0 :   TColgp_Array1OfPnt P(1, h_S->NbPoles());
         [ #  # ][ #  # ]
     993 [ #  # ][ #  # ]:          0 :   h_S->Poles(P);
     994 [ #  # ][ #  # ]:          0 :   for (int i = P.Lower(); i <= P.Upper(); i++) 
                 [ #  # ]
     995                 :            :   {
     996         [ #  # ]:          0 :     gp_Pnt point = P.Value(i);
     997 [ #  # ][ #  # ]:          0 :     CubitVector v = CubitVector(point.X(), point.Y(), point.Z());
         [ #  # ][ #  # ]
     998         [ #  # ]:          0 :     cntrl_pts.append(v); 
     999                 :            :   }
    1000                 :            : 
    1001         [ #  # ]:          0 :   if(rational)
    1002                 :            :   {
    1003 [ #  # ][ #  # ]:          0 :     TColStd_Array1OfReal W(1, h_S->NbPoles());
                 [ #  # ]
    1004 [ #  # ][ #  # ]:          0 :     h_S->Weights(W);
    1005 [ #  # ][ #  # ]:          0 :     for (int i = W.Lower(); i <= W.Upper(); i++)
                 [ #  # ]
    1006 [ #  # ][ #  # ]:          0 :       cntrl_pt_weights.append(W.Value(i));
                 [ #  # ]
    1007                 :            :   }
    1008         [ #  # ]:          0 :   return CUBIT_SUCCESS;
    1009                 :            : }
    1010                 :            : 
    1011                 :            : //-------------------------------------------------------------------------
    1012                 :            : // Purpose       : Return the ellipse parameters given a curve that is an ellipse
    1013                 :            : //
    1014                 :            : // Special Notes :
    1015                 :            : //
    1016                 :            : // Creator       : Jane  Hu
    1017                 :            : //
    1018                 :            : // Creation Date : 2/21/2012
    1019                 :            : //-------------------------------------------------------------------------
    1020                 :          0 : CubitStatus OCCCurve::get_ellipse_params
    1021                 :            : (
    1022                 :            :   CubitVector &center_pt,
    1023                 :            :   CubitVector &normal,
    1024                 :            :   CubitVector &major_axis,
    1025                 :            :   double &radius_ratio
    1026                 :            : ) const
    1027                 :            : {
    1028         [ #  # ]:          0 :   BRepAdaptor_Curve acurve(*myTopoDSEdge);
    1029         [ #  # ]:          0 :   gp_Elips ellipse;
    1030 [ #  # ][ #  # ]:          0 :   if (acurve.GetType() == GeomAbs_Ellipse)
    1031         [ #  # ]:          0 :     ellipse = acurve.Ellipse();
    1032                 :            :   else
    1033                 :          0 :     return CUBIT_FAILURE;
    1034                 :            : 
    1035         [ #  # ]:          0 :   gp_Pnt center = ellipse.Location();
    1036 [ #  # ][ #  # ]:          0 :   center_pt = CubitVector(center.X(), center.Y(), center.Z());
         [ #  # ][ #  # ]
                 [ #  # ]
    1037                 :            :   
    1038         [ #  # ]:          0 :   gp_Ax1 normal_Axis = ellipse.Axis();
    1039         [ #  # ]:          0 :   gp_Dir normal_dir = normal_Axis.Direction();
    1040 [ #  # ][ #  # ]:          0 :   normal = CubitVector(normal_dir.X(), normal_dir.Y(), normal_dir.Z());
         [ #  # ][ #  # ]
                 [ #  # ]
    1041                 :            : 
    1042         [ #  # ]:          0 :   gp_Ax1 major_Axis = ellipse.Directrix1();
    1043         [ #  # ]:          0 :   gp_Dir major_dir = major_Axis.Direction();
    1044 [ #  # ][ #  # ]:          0 :   major_axis = CubitVector(major_dir.X(), major_dir.Y(), major_dir.Z());
         [ #  # ][ #  # ]
                 [ #  # ]
    1045                 :            : 
    1046         [ #  # ]:          0 :   double major = ellipse.MajorRadius();
    1047         [ #  # ]:          0 :   double minor = ellipse.MinorRadius();
    1048                 :          0 :   radius_ratio = major/minor;
    1049                 :            : 
    1050         [ #  # ]:          0 :   return CUBIT_SUCCESS;
    1051                 :            : }
    1052                 :            : 
    1053                 :       3216 : CubitPointContainment OCCCurve::point_containment( const CubitVector &point )
    1054                 :            : {
    1055         [ +  + ]:       3216 :    if (is_position_on(point) == CUBIT_TRUE)
    1056                 :            :    {
    1057         [ +  - ]:        352 :      DLIList<OCCPoint*> points;
    1058         [ +  - ]:        352 :      get_points(points);
    1059 [ +  - ][ +  + ]:        660 :      for (int i = 0; i < points.size(); i++)
    1060                 :            :      {
    1061         [ +  - ]:        572 :         OCCPoint* pnt = points.get_and_step();
    1062         [ +  - ]:        572 :         CubitVector v = pnt->coordinates();
    1063         [ +  - ]:        572 :         double d = v.distance_between(point); 
    1064         [ +  + ]:        572 :         if (d < GEOMETRY_RESABS)
    1065                 :        264 :           return CUBIT_PNT_BOUNDARY; 
    1066                 :            :      }
    1067         [ +  - ]:        352 :      return CUBIT_PNT_ON;
    1068                 :            :    } 
    1069                 :       3216 :    return CUBIT_PNT_OFF;
    1070                 :            : }
    1071                 :            : 
    1072                 :            : //----------------------------------------------------------------
    1073                 :            : // Function: to update the core Curve
    1074                 :            : //           for any movement of the body/surface/curve.
    1075                 :            : // Author: Jane Hu
    1076                 :            : //----------------------------------------------------------------
    1077                 :      13396 : void OCCCurve::update_OCC_entity( BRepBuilderAPI_ModifyShape *aBRepTrsf,
    1078                 :            :                                  BRepAlgoAPI_BooleanOperation *op)
    1079                 :            : {
    1080         [ +  + ]:      13396 :   if (myMarked == 1) 
    1081                 :      13396 :      return;
    1082                 :            : 
    1083 [ -  + ][ #  # ]:       6698 :   assert(aBRepTrsf != NULL || op != NULL);
    1084                 :            :   
    1085         [ +  - ]:       6698 :   TopoDS_Shape shape;
    1086         [ +  - ]:       6698 :   if(aBRepTrsf)
    1087 [ +  - ][ +  - ]:       6698 :     shape = aBRepTrsf->ModifiedShape(*get_TopoDS_Edge()); 
                 [ +  - ]
    1088                 :            :   else
    1089                 :            :   {
    1090         [ #  # ]:          0 :     TopTools_ListOfShape shapes;
    1091 [ #  # ][ #  # ]:          0 :     shapes.Assign(op->Modified(*get_TopoDS_Edge()));
                 [ #  # ]
    1092 [ #  # ][ #  # ]:          0 :     if(shapes.Extent() == 0)
    1093 [ #  # ][ #  # ]:          0 :       shapes.Assign(op->Generated(*get_TopoDS_Edge()));
                 [ #  # ]
    1094 [ #  # ][ #  # ]:          0 :     if(shapes.Extent() == 1)
    1095 [ #  # ][ #  # ]:          0 :       shape = shapes.First();
    1096 [ #  # ][ #  # ]:          0 :     else if(shapes.Extent() > 1)
    1097                 :            :     {
    1098 [ #  # ][ #  # ]:          0 :       shape = shapes.First();
    1099                 :            :     }
    1100 [ #  # ][ #  # ]:          0 :     else if (op->IsDeleted(*get_TopoDS_Edge()))
                 [ #  # ]
    1101                 :            :       ;
    1102                 :            :     else
    1103 [ #  # ][ #  # ]:          0 :       return ;
    1104                 :            :   }
    1105 [ +  - ][ +  - ]:      13396 :   TopoDS_Edge curve;
         [ +  - ][ +  - ]
    1106 [ +  - ][ +  - ]:       6698 :   if(!shape.IsNull())
    1107 [ +  - ][ +  - ]:       6698 :     curve = TopoDS::Edge(shape);
    1108                 :            : 
    1109                 :            :   //make sure the shape (edge) length is greater than 0.
    1110         [ +  - ]:       6698 :   GProp_GProps myProps;
    1111         [ +  - ]:       6698 :   BRepGProp::LinearProperties(curve, myProps);
    1112         [ +  - ]:       6698 :   double d = myProps.Mass();
    1113 [ +  - ][ +  - ]:       6698 :   if(d > OCCQueryEngine::instance()->get_sme_resabs_tolerance())
                 [ +  - ]
    1114                 :            :   {
    1115                 :            :     //set the vertices
    1116         [ +  - ]:       6698 :     DLIList<TopologyBridge*> vertices;
    1117         [ +  - ]:       6698 :     get_children_virt(vertices);
    1118 [ +  - ][ +  + ]:      11294 :     for (int i = 1; i <= vertices.size(); i++)
    1119                 :            :     {
    1120         [ +  - ]:       4596 :        TopologyBridge* tb = vertices.get_and_step();
    1121         [ -  + ]:       4596 :        OCCPoint *point = CAST_TO(tb, OCCPoint);
    1122         [ +  - ]:       4596 :        if (point)
    1123         [ +  - ]:       4596 :          point->update_OCC_entity(aBRepTrsf, op);
    1124                 :            :     }
    1125         [ +  - ]:       6698 :     myMarked = 1;
    1126                 :            :   }
    1127                 :            :   else
    1128         [ #  # ]:          0 :     curve.Nullify();
    1129 [ +  - ][ +  - ]:      13396 :   OCCQueryEngine::instance()->update_OCC_map(*myTopoDSEdge, curve);
    1130                 :            : }
    1131                 :            : 
    1132                 :            : //===============================================================================
    1133                 :            : // Function   : project_curve
    1134                 :            : // Member Type: PUBLIC
    1135                 :            : // Description: project a curve onto a surface, if closed is true,
    1136                 :            : //              make sure it projected as two segment, then combine them
    1137                 :            : //              into a closed shape, third_point is used to determine
    1138                 :            : //              which segment to use if having two projections.
    1139                 :            : // Author     : Jane Hu
    1140                 :            : // Date       : 01/08
    1141                 :            : //===============================================================================
    1142                 :          0 : Curve* OCCCurve::project_curve(Surface* face_ptr, 
    1143                 :            :                                DLIList<TBPoint*>&  normal_proj_points,
    1144                 :            :                                CubitBoolean closed,
    1145                 :            :                                const CubitVector* third_point)
    1146                 :            : {
    1147         [ #  # ]:          0 :    TopoDS_Edge* edge = get_TopoDS_Edge();
    1148         [ #  # ]:          0 :    if (edge == NULL)
    1149                 :            :    {
    1150 [ #  # ][ #  # ]:          0 :         PRINT_ERROR("Cannot project the curve .\n"
                 [ #  # ]
    1151         [ #  # ]:          0 :                  "Possible incompatible geometry engines.\n");
    1152                 :          0 :         return (Curve*) NULL;
    1153                 :            :    }
    1154                 :            : 
    1155 [ #  # ][ #  # ]:          0 :    TopoDS_Face* face = CAST_TO(face_ptr, OCCSurface)->get_TopoDS_Face();
    1156         [ #  # ]:          0 :    if(face == NULL)
    1157                 :            :    {
    1158 [ #  # ][ #  # ]:          0 :         PRINT_ERROR("Cannot project the curve to the surface.\n"
                 [ #  # ]
    1159         [ #  # ]:          0 :                  "Possible incompatible geometry engines.\n");
    1160                 :          0 :         return (Curve*) NULL;
    1161                 :            :    }
    1162                 :            : 
    1163         [ #  # ]:          0 :    BRepAlgo_NormalProjection aProjection;
    1164         [ #  # ]:          0 :    aProjection.Init(*face);
    1165         [ #  # ]:          0 :    aProjection.Add(*edge);
    1166         [ #  # ]:          0 :    aProjection.Build();
    1167 [ #  # ][ #  # ]:          0 :    if (!aProjection.IsDone())
    1168                 :            :    {
    1169 [ #  # ][ #  # ]:          0 :         PRINT_ERROR("Cannot project the curve to the surface.\n"
                 [ #  # ]
    1170         [ #  # ]:          0 :                  "OCC engine failure.\n");
    1171                 :          0 :         return (Curve*) NULL;
    1172                 :            :    }
    1173                 :            : 
    1174 [ #  # ][ #  # ]:          0 :    TopoDS_Shape new_shape = aProjection.Projection();//compound shape
                 [ #  # ]
    1175                 :          0 :    int num_projection = 0;
    1176 [ #  # ][ #  # ]:          0 :    if (new_shape.IsNull())
    1177                 :            :    {
    1178 [ #  # ][ #  # ]:          0 :        PRINT_ERROR("Cannot project the curve to the surface.\n");
         [ #  # ][ #  # ]
    1179                 :          0 :        return (Curve*) NULL;
    1180                 :            :    }
    1181                 :            : 
    1182                 :            :    else
    1183                 :            :    {
    1184                 :            :      //count how many free edges and vertices the new_shape has.
    1185         [ #  # ]:          0 :      TopExp_Explorer Ex;
    1186 [ #  # ][ #  # ]:          0 :      for (Ex.Init(new_shape,TopAbs_EDGE); Ex.More(); Ex.Next())
         [ #  # ][ #  # ]
    1187                 :          0 :        num_projection++;
    1188 [ #  # ][ #  # ]:          0 :      for (Ex.Init(new_shape,TopAbs_VERTEX, TopAbs_EDGE); Ex.More(); Ex.Next())
         [ #  # ][ #  # ]
    1189         [ #  # ]:          0 :        num_projection++;
    1190                 :            :    }
    1191                 :            : 
    1192         [ #  # ]:          0 :    if(num_projection == 0)
    1193                 :            :    {
    1194 [ #  # ][ #  # ]:          0 :       PRINT_INFO("No projection on the surface.\n");
         [ #  # ][ #  # ]
    1195                 :          0 :       return (Curve*) NULL;
    1196                 :            :    }
    1197                 :            : 
    1198         [ #  # ]:          0 :    else if ( num_projection == 1 )
    1199                 :            :    {
    1200         [ #  # ]:          0 :       if(closed == true)
    1201 [ #  # ][ #  # ]:          0 :        PRINT_WARNING("Cannot project the curve to create a closed projection.\n"                 "There is only one projection segment.\n");
         [ #  # ][ #  # ]
    1202                 :            : 
    1203         [ #  # ]:          0 :       TopExp_Explorer Ex;
    1204 [ #  # ][ #  # ]:          0 :       TopoDS_Edge new_edge;
    1205 [ #  # ][ #  # ]:          0 :       TopoDS_Vertex new_point;
    1206 [ #  # ][ #  # ]:          0 :       for (Ex.Init(new_shape,TopAbs_EDGE); Ex.More(); Ex.Next())
                 [ #  # ]
    1207                 :            :       {
    1208 [ #  # ][ #  # ]:          0 :         new_edge = TopoDS::Edge(Ex.Current());
                 [ #  # ]
    1209                 :            :         return OCCQueryEngine::instance()->populate_topology_bridge(new_edge,
    1210 [ #  # ][ #  # ]:          0 :                                                                    CUBIT_TRUE );
    1211                 :            :       }
    1212 [ #  # ][ #  # ]:          0 :       for(Ex.Init(new_shape,TopAbs_VERTEX);Ex.More(); Ex.Next())
         [ #  # ][ #  # ]
    1213                 :            :       {
    1214 [ #  # ][ #  # ]:          0 :         new_point = TopoDS::Vertex(Ex.Current());
                 [ #  # ]
    1215 [ #  # ][ #  # ]:          0 :         normal_proj_points.append(OCCQueryEngine::instance()->populate_topology_bridge(new_point, CUBIT_TRUE));
                 [ #  # ]
    1216                 :            :       } 
    1217         [ #  # ]:          0 :       return (Curve*) NULL;
    1218                 :            :    }
    1219                 :            : 
    1220         [ #  # ]:          0 :    else if (num_projection == 2)
    1221                 :            :    {
    1222                 :            :       double d;
    1223                 :            :       double first, last;
    1224         [ #  # ]:          0 :       TopExp_Explorer Ex;
    1225 [ #  # ][ #  # ]:          0 :       TopoDS_Edge edge1, edge2;
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
    1226 [ #  # ][ #  # ]:          0 :       TopoDS_Vertex point;
                 [ #  # ]
    1227                 :            : 
    1228                 :          0 :       int count = 0;
    1229 [ #  # ][ #  # ]:          0 :       for (Ex.Init(new_shape,TopAbs_EDGE); Ex.More(); Ex.Next())
         [ #  # ][ #  # ]
    1230                 :            :       {
    1231                 :          0 :         count++;
    1232         [ #  # ]:          0 :         if(count == 1)
    1233 [ #  # ][ #  # ]:          0 :           edge1 = TopoDS::Edge(Ex.Current());
                 [ #  # ]
    1234         [ #  # ]:          0 :         if(count == 2)
    1235 [ #  # ][ #  # ]:          0 :           edge2 = TopoDS::Edge(Ex.Current());
                 [ #  # ]
    1236                 :            :       }
    1237                 :            : 
    1238 [ #  # ][ #  # ]:          0 :       for(Ex.Init(new_shape,TopAbs_VERTEX);Ex.More(); Ex.Next())
         [ #  # ][ #  # ]
    1239                 :            :       {
    1240 [ #  # ][ #  # ]:          0 :         point = TopoDS::Vertex(Ex.Current());
                 [ #  # ]
    1241 [ #  # ][ #  # ]:          0 :         normal_proj_points.append(OCCQueryEngine::instance()->populate_topology_bridge(point, CUBIT_TRUE));
                 [ #  # ]
    1242                 :            :       }
    1243                 :            : 
    1244 [ #  # ][ #  # ]:          0 :       if(edge1.IsNull())
    1245 [ #  # ][ #  # ]:          0 :         return OCCQueryEngine::instance()->populate_topology_bridge(edge2, CUBIT_TRUE);
    1246                 :            : 
    1247 [ #  # ][ #  # ]:          0 :       if(edge2.IsNull())
    1248 [ #  # ][ #  # ]:          0 :         return OCCQueryEngine::instance()->populate_topology_bridge(edge1, CUBIT_TRUE);
    1249                 :            : 
    1250 [ #  # ][ #  # ]:          0 :       if(edge1.IsNull() && edge2.IsNull())
         [ #  # ][ #  # ]
                 [ #  # ]
    1251                 :          0 :         return (Curve*) NULL;
    1252                 :            : 
    1253                 :            :       Handle(Geom_Curve) myCurve1 =
    1254 [ #  # ][ #  # ]:          0 :                         BRep_Tool::Curve(edge1,first,last);
                 [ #  # ]
    1255                 :            : 
    1256 [ #  # ][ #  # ]:          0 :       Handle(Geom_Curve) myCurve2= BRep_Tool::Curve(edge2, first, last);
                 [ #  # ]
    1257                 :            :       //If the surface is periodic, so it has 2 projections, we just need to
    1258                 :            :       //find the segment to which the third_point is closer.
    1259 [ #  # ][ #  # ]:          0 :       if(closed == CUBIT_FALSE && third_point != NULL)
    1260                 :            :       {
    1261 [ #  # ][ #  # ]:          0 :         gp_Pnt P (third_point->x(), third_point->y(), third_point->z());
         [ #  # ][ #  # ]
    1262         [ #  # ]:          0 :         GeomAPI_ProjectPointOnCurve projOncurve(P, myCurve1);
    1263 [ #  # ][ #  # ]:          0 :         if (projOncurve.NbPoints() == 0)
    1264                 :            :         {
    1265 [ #  # ][ #  # ]:          0 :           PRINT_ERROR("Cannot project the curve to the surface.\n"
                 [ #  # ]
    1266         [ #  # ]:          0 :                  "OCC engine failure.\n");
    1267                 :          0 :           return (Curve*) NULL;
    1268                 :            :         }
    1269         [ #  # ]:          0 :         d = projOncurve.LowerDistance();
    1270                 :            : 
    1271                 :            :         //Compare with the second solution
    1272 [ #  # ][ #  # ]:          0 :         GeomAPI_ProjectPointOnCurve projOncurve2(P, myCurve2);
    1273 [ #  # ][ #  # ]:          0 :         if (projOncurve2.NbPoints() == 0)
    1274                 :            :         {
    1275 [ #  # ][ #  # ]:          0 :            PRINT_ERROR("Cannot project the curve to the surface.\n"
                 [ #  # ]
    1276         [ #  # ]:          0 :                  "OCC engine failure.\n");
    1277                 :          0 :           return (Curve*) NULL;
    1278                 :            :         }
    1279                 :            : 
    1280         [ #  # ]:          0 :         double d2 = projOncurve2.LowerDistance();
    1281                 :            :         TopoDS_Edge new_edge =
    1282 [ #  # ][ #  # ]:          0 :                 d > d2 ? edge2 : edge1 ;
                 [ #  # ]
    1283 [ #  # ][ #  # ]:          0 :         return OCCQueryEngine::instance()->populate_topology_bridge(new_edge, CUBIT_TRUE);
                 [ #  # ]
    1284                 :            :       }
    1285                 :            : 
    1286                 :            : 
    1287         [ #  # ]:          0 :       else if (closed == CUBIT_TRUE)
    1288                 :            :       {
    1289                 :            :         //connect the two segment into a closed shape. Assume both segment
    1290                 :            :         // has the same curve type, create Bezier closed curve.
    1291         [ #  # ]:          0 :         GeomAdaptor_Curve acurve1(myCurve1);
    1292 [ #  # ][ #  # ]:          0 :         GeomAdaptor_Curve acurve2(myCurve2);
    1293                 :            :         //get 10 points of each curve, combine them to make one Bezier curve
    1294                 :          0 :         int NbPoints = 10;
    1295 [ #  # ][ #  # ]:          0 :         GCPnts_QuasiUniformAbscissa distribution1(acurve1, NbPoints);
    1296 [ #  # ][ #  # ]:          0 :         GCPnts_QuasiUniformAbscissa distribution2(acurve2, NbPoints);
    1297 [ #  # ][ #  # ]:          0 :         TColgp_Array1OfPnt points(1, 2*NbPoints-1);
    1298                 :            :         int i;
    1299         [ #  # ]:          0 :         for (i = 1; i <= NbPoints; i++)
    1300                 :            :         {
    1301         [ #  # ]:          0 :            double u = distribution1.Parameter(i);
    1302 [ #  # ][ #  # ]:          0 :            gp_Pnt P = myCurve1->Value(u);
    1303         [ #  # ]:          0 :            points.SetValue(i, P);
    1304                 :            :         }
    1305                 :            : 
    1306         [ #  # ]:          0 :         for (int j = NbPoints-1; j >= 1; j--)
    1307                 :            :         {
    1308         [ #  # ]:          0 :            double u = distribution2.Parameter(j); 
    1309 [ #  # ][ #  # ]:          0 :            gp_Pnt P = myCurve2->Value(u);
    1310         [ #  # ]:          0 :            points.SetValue(++i,P); 
    1311                 :            :         }    
    1312                 :            : 
    1313 [ #  # ][ #  # ]:          0 :         Geom_BezierCurve BezierCurve(points);
    1314 [ #  # ][ #  # ]:          0 :         Handle(Geom_Curve) curve_ptr(&BezierCurve);
    1315 [ #  # ][ #  # ]:          0 :         TopoDS_Edge new_edge = BRepBuilderAPI_MakeEdge(curve_ptr);
         [ #  # ][ #  # ]
    1316 [ #  # ][ #  # ]:          0 :         return OCCQueryEngine::instance()->populate_topology_bridge(new_edge);
         [ #  # ][ #  # ]
                 [ #  # ]
    1317                 :          0 :       }
    1318                 :            :    }
    1319         [ #  # ]:          0 :    return (Curve*) NULL;
    1320                 :            : }
    1321                 :          0 : CubitStatus OCCCurve::get_spline_params( bool &rational,
    1322                 :            :                                          int &degree,
    1323                 :            :                                          DLIList<CubitVector> &cntrl_pts,
    1324                 :            :                                          DLIList<double> &cntrl_pt_weights,
    1325                 :            :                                          DLIList<double> &knots, // There should be order+cntrl_pts.size()-2 knots
    1326                 :            :                                          bool &spline_is_reversed
    1327                 :            :                                        ) const
    1328                 :            :   {
    1329                 :          0 :           return CUBIT_FAILURE;
    1330 [ +  - ][ +  - ]:       6364 :   }
    1331                 :            : 
    1332                 :            : // ********** END PRIVATE FUNCTIONS        **********
    1333                 :            : 
    1334                 :            : // ********** BEGIN HELPER CLASSES         **********
    1335                 :            : // ********** END HELPER CLASSES           **********
    1336                 :            : 
    1337                 :            : // ********** BEGIN EXTERN FUNCTIONS       **********
    1338                 :            : // ********** END EXTERN FUNCTIONS         **********
    1339                 :            : 
    1340                 :            : // ********** BEGIN STATIC FUNCTIONS       **********
    1341                 :            : // ********** END STATIC FUNCTIONS         **********

Generated by: LCOV version 1.11