src/Geom2dHatch/Geom2dHatch_Elements.cxx

   1 // Created on: 1994-12-16
   2 // Created by: Laurent BUCHARD
   3 // Copyright (c) 1994-1999 Matra Datavision
   4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   5 //
   6 // This file is part of Open CASCADE Technology software library.
   7 //
   8 // This library is free software; you can redistribute it and/or modify it under
   9 // the terms of the GNU Lesser General Public License version 2.1 as published
  10 // by the Free Software Foundation, with special exception defined in the file
  11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  12 // distribution for complete text of the license and disclaimer of any warranty.
  13 //
  14 // Alternatively, this file may be used under the terms of Open CASCADE
  15 // commercial license or contractual agreement.
  16
  17 //  Modified by skv - Fri Jul 14 17:03:47 2006 OCC12627
  18
  19 #include <Geom2dAdaptor_Curve.hxx>
  20 #include <Geom2dHatch_Element.hxx>
  21 #include <Geom2dHatch_Elements.hxx>
  22 #include <gp.hxx>
  23 #include <gp_Lin2d.hxx>
  24 #include <gp_Pnt2d.hxx>
  25 #include <gp_Vec2d.hxx>
  26 #include <Standard_DomainError.hxx>
  27 #include <Standard_Integer.hxx>
  28 #include <Standard_NoSuchObject.hxx>
  29 #include <TColStd_MapIntegerHasher.hxx>
  30 #include <TopAbs_Orientation.hxx>
  31 #include <Precision.hxx>
  32
  33 static const Standard_Real Probing_Start = 0.123;
  34 static const Standard_Real Probing_End = 0.8;
  35 static const Standard_Real Probing_Step = 0.2111;
  36
  37 Geom2dHatch_Elements::Geom2dHatch_Elements(const Geom2dHatch_Elements& )
  38 {
  39 #ifdef OCCT_DEBUG
  40   std::cout<<" Magic Constructor in Geom2dHatch_Elements:: "<<std::endl;
  41 #endif
  42 }
  43
  44 Geom2dHatch_Elements::Geom2dHatch_Elements()
  45 {
  46   NumWire = 0;
  47   NumEdge = 0;
  48   myCurEdge = 1;
  49   myCurEdgePar = Probing_Start;
  50 }
  51
  52 void Geom2dHatch_Elements::Clear()
  53 {
  54   myMap.Clear();
  55 }
  56
  57 Standard_Boolean Geom2dHatch_Elements::IsBound(const Standard_Integer K) const
  58 {
  59   return(myMap.IsBound(K));
  60 }
  61
  62 Standard_Boolean Geom2dHatch_Elements::UnBind(const Standard_Integer K)
  63 {
  64   return(myMap.UnBind(K));
  65 }
  66
  67 Standard_Boolean Geom2dHatch_Elements::Bind(const Standard_Integer K,const Geom2dHatch_Element& I)
  68 {
  69   return(myMap.Bind(K,I));
  70 }
  71
  72 const Geom2dHatch_Element& Geom2dHatch_Elements::Find(const Standard_Integer K) const
  73 {
  74   return(myMap.Find(K));
  75 }
  76
  77 Geom2dHatch_Element& Geom2dHatch_Elements::ChangeFind(const Standard_Integer K)
  78 {
  79   return(myMap.ChangeFind(K));
  80 }
  81
  82 //=======================================================================
  83 //function : CheckPoint
  84 //purpose  :
  85 //=======================================================================
  86
  87 Standard_Boolean  Geom2dHatch_Elements::CheckPoint(gp_Pnt2d&)
  88 {
  89   return Standard_True;
  90 }
  91
  92 //=======================================================================
  93 //function : Reject
  94 //purpose  :
  95 //=======================================================================
  96
  97 Standard_Boolean  Geom2dHatch_Elements::Reject(const gp_Pnt2d&) const  {
  98   return Standard_False;
  99 }
 100
 101 //=======================================================================
 102 //function : Segment
 103 //purpose  :
 104 //=======================================================================
 105
 106 Standard_Boolean Geom2dHatch_Elements::Segment(const gp_Pnt2d& P,
 107                                                      gp_Lin2d& L,
 108                                                      Standard_Real& Par)
 109 {
 110   myCurEdge = 1;
 111   myCurEdgePar = Probing_Start;
 112   return OtherSegment(P, L, Par);
 113 }
 114
 115 //=======================================================================
 116 //function : Segment
 117 //purpose  :
 118 //=======================================================================
 119
 120 Standard_Boolean Geom2dHatch_Elements::OtherSegment (const gp_Pnt2d& P,
 121                                                      gp_Lin2d& L,
 122                                                      Standard_Real& Par)
 123 {
 124   Geom2dHatch_DataMapIteratorOfMapOfElements Itertemp;
 125   Standard_Integer                        i;
 126
 127   for (Itertemp.Initialize (myMap), i = 1; Itertemp.More(); Itertemp.Next(), i++)
 128   {
 129     if (i < myCurEdge)
 130       continue;
 131
 132     void *ptrmyMap = (void *)(&myMap);
 133     Geom2dHatch_Element& Item = ((Geom2dHatch_MapOfElements*)ptrmyMap)->ChangeFind (Itertemp.Key());
 134     Geom2dAdaptor_Curve& E = Item.ChangeCurve();
 135     TopAbs_Orientation Or = Item.Orientation();
 136     if (Or == TopAbs_FORWARD || Or == TopAbs_REVERSED)
 137     {
 138       Standard_Real aFPar = E.FirstParameter(), aLPar = E.LastParameter();
 139       if (Precision::IsNegativeInfinite (aFPar))
 140       {
 141         if (Precision::IsPositiveInfinite (aLPar))
 142         {
 143           aFPar = -1.;
 144           aLPar = 1.;
 145         }
 146         else
 147           aFPar = aLPar - 1.;
 148       }
 149       else if (Precision::IsPositiveInfinite (aLPar))
 150         aLPar = aFPar + 1.;
 151
 152       for (; myCurEdgePar < Probing_End; myCurEdgePar += Probing_Step)
 153       {
 154         Standard_Real aParam = myCurEdgePar * aFPar + (1. - myCurEdgePar) * aLPar;
 155         gp_Vec2d aTanVec;
 156         gp_Pnt2d aPOnC;
 157         E.D1 (aParam, aPOnC, aTanVec);
 158         gp_Vec2d aLinVec (P, aPOnC);
 159         Par = aLinVec.SquareMagnitude();
 160         if (Par > Precision::SquarePConfusion())
 161         {
 162           gp_Dir2d aLinDir (aLinVec);
 163           Standard_Real aTanMod = aTanVec.SquareMagnitude();
 164           if (aTanMod < Precision::SquarePConfusion())
 165             continue;
 166
 167           aTanVec /= Sqrt (aTanMod);
 168           Standard_Real aSinA = aTanVec.Crossed (aLinDir);
 169           if (Abs (aSinA) < 0.001)
 170           {
 171             // too small angle - line and edge may be considered
 172             // as tangent which is bad for classifier
 173             if (myCurEdgePar + Probing_Step < Probing_End)
 174               continue;
 175           }
 176
 177           L = gp_Lin2d (P, aLinDir);
 178
 179           aPOnC = E.Value (aFPar);
 180           if (L.SquareDistance (aPOnC) > Precision::SquarePConfusion())
 181           {
 182             aPOnC = E.Value (aLPar);
 183             if (L.SquareDistance (aPOnC) > Precision::SquarePConfusion())
 184             {
 185               myCurEdgePar += Probing_Step;
 186               if (myCurEdgePar >= Probing_End)
 187               {
 188                 myCurEdge++;
 189                 myCurEdgePar = Probing_Start;
 190               }
 191               Par = Sqrt (Par);
 192               return Standard_True;
 193             }
 194           }
 195         }
 196       }
 197     }
 198     myCurEdge++;
 199     myCurEdgePar = Probing_Start;
 200   }
 201
 202   Par = RealLast();
 203   L = gp_Lin2d (P, gp_Dir2d (1, 0));
 204
 205   return Standard_False;
 206 }
 207
 208 //=======================================================================
 209 //function : InitWires
 210 //purpose  :
 211 //=======================================================================
 212
 213 void  Geom2dHatch_Elements::InitWires()  {
 214   NumWire = 0;
 215 }
 216
 217 //=======================================================================
 218 //function : RejectWire NYI
 219 //purpose  :
 220 //=======================================================================
 221
 222 Standard_Boolean Geom2dHatch_Elements::RejectWire(const gp_Lin2d& ,
 223                                                    const Standard_Real) const
 224 {
 225   return Standard_False;
 226 }
 227
 228 //=======================================================================
 229 //function : InitEdges
 230 //purpose  :
 231 //=======================================================================
 232
 233 void  Geom2dHatch_Elements::InitEdges()  {
 234   NumEdge = 0;
 235   Iter.Initialize(myMap);
 236 }
 237
 238 //=======================================================================
 239 //function : RejectEdge NYI
 240 //purpose  :
 241 //=======================================================================
 242
 243 Standard_Boolean Geom2dHatch_Elements::RejectEdge(const gp_Lin2d& ,
 244                                                   const Standard_Real ) const
 245 {
 246   return Standard_False;
 247 }
 248
 249
 250 //=======================================================================
 251 //function : CurrentEdge
 252 //purpose  :
 253 //=======================================================================
 254
 255 void  Geom2dHatch_Elements::CurrentEdge(Geom2dAdaptor_Curve& E,
 256                                         TopAbs_Orientation& Or) const
 257 {
 258   void *ptrmyMap = (void *)(&myMap);
 259   Geom2dHatch_Element& Item=((Geom2dHatch_MapOfElements*)ptrmyMap)->ChangeFind(Iter.Key());
 260
 261   E = Item.ChangeCurve();
 262   Or= Item.Orientation();
 263 #if 0
 264   E.Edge() = TopoDS::Edge(myEExplorer.Current());
 265   E.Face() = myFace;
 266   Or = E.Edge().Orientation();
 267 #endif
 268 }
 269
 270
 271 //=======================================================================
 272 //function : MoreWires
 273 //purpose  :
 274 //=======================================================================
 275
 276 Standard_Boolean  Geom2dHatch_Elements::MoreWires() const
 277 {
 278   return (NumWire == 0);
 279 }
 280
 281 //=======================================================================
 282 //function : NextWire
 283 //purpose  :
 284 //=======================================================================
 285
 286 void Geom2dHatch_Elements::NextWire()  {
 287   NumWire++;
 288 }
 289
 290 //=======================================================================
 291 //function : MoreEdges
 292 //purpose  :
 293 //=======================================================================
 294
 295 Standard_Boolean  Geom2dHatch_Elements::MoreEdges() const  {
 296   return(Iter.More());
 297 }
 298
 299 //=======================================================================
 300 //function : NextEdge
 301 //purpose  :
 302 //=======================================================================
 303
 304 void Geom2dHatch_Elements::NextEdge()  {
 305   Iter.Next();
 306 }
 307
 308
 309