src/IntImpParGen/IntImpParGen.cxx

   1 // Created on: 1992-06-10
   2 // Created by: Laurent BUCHARD
   3 // Copyright (c) 1992-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 #include <IntImpParGen.hxx>
  18
  19 #include <gp.hxx>
  20 #include <gp_Pnt2d.hxx>
  21 #include <gp_Vec2d.hxx>
  22 #include <IntImpParGen_Tool.hxx>
  23 #include <IntRes2d_Domain.hxx>
  24 #include <IntRes2d_Position.hxx>
  25 #include <IntRes2d_Transition.hxx>
  26
  27 #define TOLERANCE_ANGULAIRE     0.00000001
  28 #define DERIVEE_PREMIERE_NULLE  0.000000000001
  29 //----------------------------------------------------------------------
  30 Standard_Real IntImpParGen::NormalizeOnDomain(Standard_Real& Param,
  31                                               const IntRes2d_Domain& TheDomain) {
  32   Standard_Real modParam = Param;
  33   if(TheDomain.IsClosed()) {
  34     Standard_Real Periode,t;
  35     TheDomain.EquivalentParameters(t,Periode);
  36     Periode-=t;
  37     while(   modParam<TheDomain.FirstParameter()
  38           && modParam+Periode < TheDomain.LastParameter()) {
  39       modParam+=Periode;
  40     }
  41     while(   modParam>TheDomain.LastParameter()
  42           && modParam-Periode > TheDomain.FirstParameter()) {
  43       modParam-=Periode;
  44     }
  45   }
  46   return(modParam);
  47 }
  48 //----------------------------------------------------------------------
  49 void IntImpParGen::DeterminePosition(IntRes2d_Position& Pos1,
  50                                      const IntRes2d_Domain& TheDomain,
  51                                      const gp_Pnt2d& Pnt1,
  52                                      const Standard_Real Param1) {
  53
  54   Pos1=IntRes2d_Middle;
  55
  56   if(TheDomain.HasFirstPoint()) {
  57     if(Pnt1.Distance(TheDomain.FirstPoint())
  58        <= TheDomain.FirstTolerance()) {
  59       Pos1=IntRes2d_Head;
  60     }
  61   }
  62
  63   if(TheDomain.HasLastPoint()) {
  64     if(Pnt1.Distance(TheDomain.LastPoint())
  65        <= TheDomain.LastTolerance()) {
  66       if(Pos1==IntRes2d_Head) {
  67         if(Abs(Param1-TheDomain.LastParameter())
  68            < Abs(Param1-TheDomain.FirstParameter()))
  69           Pos1=IntRes2d_End;
  70       }
  71       else {
  72         Pos1=IntRes2d_End;
  73       }
  74     }
  75   }
  76 }
  77 //----------------------------------------------------------------------
  78 void IntImpParGen::DetermineTransition(const IntRes2d_Position    Pos1,
  79                                        gp_Vec2d&                  Tan1,
  80                                        const gp_Vec2d&            Norm1,
  81                                        IntRes2d_Transition&       T1,
  82                                        const IntRes2d_Position    Pos2,
  83                                        gp_Vec2d&                  Tan2,
  84                                        const gp_Vec2d&            Norm2,
  85                                        IntRes2d_Transition&       T2,
  86                                        const Standard_Real        ) {
  87
  88   Standard_Boolean courbure1=Standard_True;
  89   Standard_Boolean courbure2=Standard_True;
  90   Standard_Boolean decide=Standard_True;
  91
  92   T1.SetPosition(Pos1);
  93   T2.SetPosition(Pos2);
  94
  95
  96   if (Tan1.SquareMagnitude()<=DERIVEE_PREMIERE_NULLE) {
  97     Tan1=Norm1;
  98     courbure1=Standard_False;
  99     if (Tan1.SquareMagnitude()<=DERIVEE_PREMIERE_NULLE) {    // transition undecided
 100       decide=Standard_False;
 101     }
 102   }
 103
 104   if (Tan2.SquareMagnitude()<=DERIVEE_PREMIERE_NULLE) {
 105     Tan2=Norm2;
 106     courbure2=Standard_False;
 107     if (Tan2.SquareMagnitude()<=DERIVEE_PREMIERE_NULLE) {    // transition undecided
 108       decide=Standard_False;
 109     }
 110   }
 111
 112   if (!decide) {
 113     T1.SetValue(Pos1);
 114     T2.SetValue(Pos2);
 115   }
 116   else {
 117     Standard_Real sgn=Tan1.Crossed(Tan2);
 118     Standard_Real norm=Tan1.Magnitude()*Tan2.Magnitude();
 119
 120     if (Abs(sgn)<=TOLERANCE_ANGULAIRE*norm) {   // Transition TOUCH #########
 121       Standard_Boolean opos=(Tan1.Dot(Tan2))<0;
 122       if (!(courbure1||courbure2)) {
 123         T1.SetValue(Standard_True,Pos1,IntRes2d_Unknown,opos);
 124         T2.SetValue(Standard_True,Pos2,IntRes2d_Unknown,opos);
 125       }
 126       else {
 127         gp_Vec2d Norm;
 128         Norm.SetCoord(-Tan1.Y(),Tan1.X());
 129         Standard_Real Val1,Val2;
 130         if (!courbure1) {
 131           Val1=0.0;
 132         }
 133         else {
 134           Val1=Norm.Dot(Norm1);
 135         }
 136         if (!courbure2) {
 137           Val2=0.0;
 138         }
 139         else {
 140           Val2=Norm.Dot(Norm2);
 141         }
 142
 143         if (Abs(Val1-Val2) <= TOLERANCE_ANGULAIRE) {
 144           T1.SetValue(Standard_True,Pos1,IntRes2d_Unknown,opos);
 145           T2.SetValue(Standard_True,Pos2,IntRes2d_Unknown,opos);
 146         }
 147         else if (Val2 > Val1) {
 148           T2.SetValue(Standard_True,Pos2,IntRes2d_Inside,opos);
 149           if (opos) {
 150             T1.SetValue(Standard_True,Pos1,IntRes2d_Inside,opos);
 151           }
 152           else {
 153             T1.SetValue(Standard_True,Pos1,IntRes2d_Outside,opos);
 154           }
 155         }
 156         else {         // Val1 > Val2
 157           T2.SetValue(Standard_True,Pos2,IntRes2d_Outside,opos);
 158           if (opos) {
 159             T1.SetValue(Standard_True,Pos1,IntRes2d_Outside,opos);
 160           }
 161           else {
 162             T1.SetValue(Standard_True,Pos1,IntRes2d_Inside,opos);
 163           }
 164         }
 165       }
 166     }
 167     else if (sgn<0) {
 168       T1.SetValue(Standard_False,Pos1,IntRes2d_In);
 169       T2.SetValue(Standard_False,Pos2,IntRes2d_Out);
 170     }
 171     else {     // sgn>0
 172       T1.SetValue(Standard_False,Pos1,IntRes2d_Out);
 173       T2.SetValue(Standard_False,Pos2,IntRes2d_In);
 174     }
 175   }
 176 }
 177
 178 //----------------------------------------------------------------------
 179 Standard_Boolean  IntImpParGen::DetermineTransition(const IntRes2d_Position    Pos1,
 180                                                     gp_Vec2d&                  Tan1,
 181                                                     IntRes2d_Transition&       T1,
 182                                                     const IntRes2d_Position    Pos2,
 183                                                     gp_Vec2d&                  Tan2,
 184                                                     IntRes2d_Transition&       T2,
 185                                                     const Standard_Real        ) {
 186
 187   T1.SetPosition(Pos1);
 188   T2.SetPosition(Pos2);
 189
 190   Standard_Real Tan1Magnitude = Tan1.Magnitude();
 191   if (Tan1Magnitude<=DERIVEE_PREMIERE_NULLE) {
 192     return(Standard_False);
 193   }
 194
 195   Standard_Real Tan2Magnitude = Tan2.Magnitude();
 196   if (Tan2Magnitude<=DERIVEE_PREMIERE_NULLE) {
 197     return(Standard_False);
 198   }
 199
 200   Standard_Real sgn=Tan1.Crossed(Tan2);
 201   Standard_Real norm=Tan1Magnitude*Tan2Magnitude;
 202
 203   if (Abs(sgn)<=TOLERANCE_ANGULAIRE*norm) {   // Transition TOUCH #########
 204     return(Standard_False);
 205   }
 206   else if (sgn<0) {
 207     T1.SetValue(Standard_False,Pos1,IntRes2d_In);
 208     T2.SetValue(Standard_False,Pos2,IntRes2d_Out);
 209   }
 210   else {     // sgn>0
 211     T1.SetValue(Standard_False,Pos1,IntRes2d_Out);
 212     T2.SetValue(Standard_False,Pos2,IntRes2d_In);
 213   }
 214   return(Standard_True);
 215 }