src/GccGeo/GccGeo_Circ2dTanOnRad.cdl

   1 -- Created on: 1991-04-03
   2 -- Created by: Remi GILET
   3 -- Copyright (c) 1991-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 generic class Circ2dTanOnRad from GccGeo (
  18     TheCurve         as any; --
  19     TheTool          as any; --
  20     TheQCurve        as any; -- as QualifiedCurv from GccEnt (TheCurve)
  21     TheParGenCurve   as any; -- as ParGenCurve from GccGeo
  22                              --               (TheCurve)
  23     TheHParGenCurve  as Transient;
  24     TheCurvePGTool   as any; -- as CurvePGTool from GccGeo
  25                              --               (Thecurve,
  26                              --                TheTool,
  27                              --                TheParGenCurve)
  28     TheIntConicCurve as any; -- as IntConicCurveOfGOffsetInter
  29     TheIntCurveCurve as any) -- as GOffSetInter from Geom2dInt
  30                              --                (TheParGenCurve,
  31                              --                 TheCurvePGTool)
  32
  33         ---Purpose: This class implements the algorithms used to
  34         --          create a 2d circle tangent to a 2d entity,
  35         --          centered on a 2d entity and with a given radius.
  36         --          More than one argument must be a curve.
  37         --          The arguments of all construction methods are :
  38         --             - The qualified element for the tangency constrains
  39         --             (QualifiedCirc, QualifiedLin, QualifiedCurvPoints).
  40         --             - The Center element (circle, line, curve).
  41         --             - A real Tolerance.
  42         --          Tolerance is only used in the limits cases.
  43         --          For example :
  44         --          We want to create a circle tangent to an OutsideCurv Cu1
  45         --          centered on a line OnLine with a radius Radius and with
  46         --          a tolerance Tolerance.
  47         --          If we did not use Tolerance it is impossible to
  48         --          find a solution in the following case : OnLine is
  49         --          outside Cu1. There is no intersection point between Cu1
  50         --          and OnLine. The distance between the line and the
  51         --          circle is greater than Radius.
  52         --          With Tolerance we will give a solution if the
  53         --          distance between Cu1 and OnLine is lower than or
  54         --          equal Tolerance.
  55
  56 -- inherits Entity from Standard
  57
  58 uses Lin2d            from gp,
  59      Circ2d           from gp,
  60      Pnt2d            from gp,
  61      Array1OfCirc2d   from TColgp,
  62      Array1OfPnt2d    from TColgp,
  63      QualifiedCirc    from GccEnt,
  64      QualifiedLin     from GccEnt,
  65      Array1OfReal     from TColStd,
  66      Array1OfInteger  from TColStd,
  67      Position         from GccEnt,
  68      Array1OfPosition from GccEnt
  69
  70 raises NegativeValue from Standard,
  71        OutOfRange    from Standard,
  72        BadQualifier  from GccEnt,
  73        NotDone       from StdFail
  74
  75 is
  76
  77 -- On a line .............................................................
  78
  79 Create(Qualified1 :        TheQCurve              ;
  80        OnLine     :        Lin2d     from gp      ;
  81        Radius     :        Real      from Standard;
  82        Tolerance  :        Real      from Standard) returns Circ2dTanOnRad
  83     ---Purpose: This methods implements the algorithms used to create
  84     --          2d Circles tangent to a curve and centered on a 2d Line
  85     --          with a given radius.
  86     --          Tolerance is used to find solution in every limit cases.
  87 raises NegativeValue, BadQualifier;
  88     ---Purpose: raises NegativeValue in case of NegativeRadius.
  89
  90 -- -- On a circle ...........................................................
  91
  92 Create(Qualified1 :        TheQCurve              ;
  93        OnCirc     :        Circ2d    from gp      ;
  94        Radius     :        Real      from Standard;
  95        Tolerance  :        Real      from Standard) returns Circ2dTanOnRad
  96     ---Purpose: This methods implements the algorithms used to create
  97     --          2d Circles tangent to a curve and centered on a 2d Circle
  98     --          with a given radius.
  99     --          Tolerance is used to find solution in every limit cases.
 100 raises NegativeValue, BadQualifier;
 101     ---Purpose: raises NegativeValue in case of NegativeRadius.
 102
 103 -- On a curve ............................................................
 104
 105 Create(Qualified1 :        QualifiedCirc from GccEnt  ;
 106        OnCurv     :        TheCurve                   ;
 107        Radius     :        Real          from Standard;
 108        Tolerance  :        Real          from Standard) returns Circ2dTanOnRad
 109     ---Purpose: This methods implements the algorithms used to create
 110     --          2d Circles tangent to a circle and centered on a 2d curve
 111     --          with a given radius.
 112     --          Tolerance is used to find solution in every limit cases.
 113 raises NegativeValue, BadQualifier;
 114     ---Purpose: raises NegativeValue in case of NegativeRadius.
 115
 116 Create(Qualified1 :        QualifiedLin  from GccEnt  ;
 117        OnCurv     :        TheCurve                   ;
 118        Radius     :        Real          from Standard;
 119        Tolerance  :        Real          from Standard) returns Circ2dTanOnRad
 120     ---Purpose: This methods implements the algorithms used to create
 121     --          2d Circles tangent to a 2d Line and centered on a 2d curve
 122     --          with a given radius.
 123     --          Tolerance is used to find solution in every limit cases.
 124 raises NegativeValue, BadQualifier;
 125     ---Purpose: raises NegativeValue in case of NegativeRadius.
 126
 127 Create(Qualified1 :        TheQCurve              ;
 128        OnCurv     :        TheCurve               ;
 129        Radius     :        Real      from Standard;
 130        Tolerance  :        Real      from Standard) returns Circ2dTanOnRad
 131     ---Purpose: This methods implements the algorithms used to create
 132     --          2d Circles tangent to a 2d curve and centered on a 2d curve
 133     --          with a given radius.
 134     --          Tolerance is used to find solution in every limit cases.
 135 raises NegativeValue, BadQualifier;
 136     ---Purpose: raises NegativeValue in case of NegativeRadius.
 137
 138 Create(Point1     :        Pnt2d    from gp      ;
 139        OnCurv     :        TheCurve              ;
 140        Radius     :        Real     from Standard;
 141        Tolerance  :        Real     from Standard) returns Circ2dTanOnRad
 142     ---Purpose: This methods implements the algorithms used to create
 143     --          2d Circles passing through a 2d point and centered on a
 144     --          2d curve with a given radius.
 145     --          Tolerance is used to find solution in every limit cases.
 146 raises NegativeValue;
 147     ---Purpose: raises NegativeValue in case of NegativeRadius.
 148
 149 -- -- ....................................................................
 150
 151 IsDone(me) returns Boolean from Standard
 152 is static;
 153         ---Purpose: This method returns True if the construction
 154         --          algorithm succeeded.
 155
 156 NbSolutions(me) returns Integer from Standard
 157         ---Purpose: This method returns the number of solutions.
 158 raises NotDone
 159 is static;
 160         ---Purpose: It raises NotDone if the construction algorithm
 161         --          didn't succeed.
 162
 163 ThisSolution(me                           ;
 164              Index : Integer from Standard) returns Circ2d from gp
 165     ---Purpose: Returns the solution number Index and raises OutOfRange
 166     --          exception if Index is greater than the number of solutions.
 167     --          Be careful: the Index is only a way to get all the
 168     --          solutions, but is not associated to theses outside the
 169     --          context of the algorithm-object.
 170 raises OutOfRange, NotDone
 171 is static;
 172     ---Purpose: It raises NotDone if the construction algorithm
 173     --          didn't succeed.
 174     --          It raises OutOfRange if Index is greater than the
 175     --          number of solutions.
 176
 177 WhichQualifier(me                                  ;
 178                Index   :     Integer  from Standard;
 179                Qualif1 : out Position from GccEnt  )
 180 raises OutOfRange, NotDone
 181 is static;
 182     -- It returns the informations about the qualifiers of the tangency
 183     -- arguments concerning the solution number Index.
 184     -- It returns the real qualifiers (the qualifiers given to the
 185     -- constructor method in case of enclosed, enclosing and outside
 186     -- and the qualifiers computedin case of unqualified).
 187
 188 Tangency1(me                                     ;
 189           Index         : Integer   from Standard;
 190           ParSol,ParArg : out Real  from Standard;
 191           PntSol        : out Pnt2d from gp      )
 192     ---Purpose: Returns informations about the tangency point between the
 193     --          result number Index and the first argument.
 194     --          ParSol is the intrinsic parameter of the point on the
 195     --          solution curv.
 196     --          ParArg is the intrinsic parameter of the point on the
 197     --          argument curv.
 198     --          PntSol is the tangency point on the solution curv.
 199     --          PntArg is the tangency point on the argument curv.
 200 raises OutOfRange, NotDone
 201 is static;
 202     ---Purpose: It raises NotDone if the construction algorithm
 203     --          didn't succeed.
 204     --          It raises OutOfRange if Index is greater than the
 205     --          number of solutions.
 206
 207 CenterOn3 (me                                     ;
 208            Index         : Integer   from Standard;
 209            ParArg        : out Real  from Standard;
 210            PntSol        : out Pnt2d from gp      )
 211     ---Purpose: Returns informations about the center (on the curv)
 212     --          of the result.
 213     --          ParArg is the intrinsic parameter of the point on
 214     --          the argument curv.
 215     --          PntSol is the center point of the solution curv.
 216 raises OutOfRange, NotDone
 217 is static;
 218     ---Purpose: It raises NotDone if the construction algorithm
 219     --          didn't succeed.
 220     --          It raises OutOfRange if Index is greater than the
 221     --          number of solutions.
 222
 223 IsTheSame1(me                           ;
 224            Index : Integer from Standard) returns Boolean from Standard
 225     ---Purpose: Returns True if the solution number Index is equal to
 226     --          the first argument and False in the other cases.
 227 raises OutOfRange, NotDone
 228 is static;
 229     ---Purpose: It raises NotDone if the construction algorithm
 230     --          didn't succeed.
 231     --          It raises OutOfRange if Index is greater than the
 232     --          number of solutions.
 233
 234 fields
 235
 236     WellDone : Boolean from Standard;
 237     ---Purpose: True if the algorithm succeeded.
 238
 239     NbrSol   : Integer from Standard;
 240     ---Purpose: The number of possible solutions. We have to decide about the
 241     --          status of the multiple solutions...
 242
 243     cirsol   : Array1OfCirc2d from TColgp;
 244     ---Purpose : The solutions.
 245
 246     qualifier1 : Array1OfPosition from GccEnt;
 247     -- The qualifiers of the first argument.
 248
 249     TheSame1 : Array1OfInteger from TColStd;
 250     ---Purpose: 1 if the solution and the first argument are the same in the
 251     -- tolerance of Tolerance.
 252     -- 0 in the other cases.
 253
 254     pnttg1sol   : Array1OfPnt2d from TColgp;
 255     ---Purpose: The tangency point between the solution and the first
 256     --          argument on the solution.
 257
 258     pntcen3   : Array1OfPnt2d from TColgp;
 259     ---Purpose: The center point of the solution on the first argument.
 260
 261     par1sol   : Array1OfReal from TColStd;
 262     ---Purpose: The parameter of the tangency point between the solution
 263     --          and the first argument on thesolution.
 264
 265     pararg1   : Array1OfReal from TColStd;
 266     ---Purpose: The parameter of the tangency point between the solution
 267     --          and the first argument on the first argument.
 268
 269     parcen3   : Array1OfReal from TColStd;
 270     ---Purpose: The parameter of the center point of the solution on the
 271     --          second argument.
 272
 273 end Circ2dTanOnRad;