0024181: Text to BRep functionality
[occt.git] / src / Geom2dConvert / Geom2dConvert_CompCurveToBSplineCurve.cxx
1 // Created on: 1997-04-29
2 // Created by: Stagiaire Francois DUMONT
3 // Copyright (c) 1997-1999 Matra Datavision
4 // Copyright (c) 1999-2012 OPEN CASCADE SAS
5 //
6 // The content of this file is subject to the Open CASCADE Technology Public
7 // License Version 6.5 (the "License"). You may not use the content of this file
8 // except in compliance with the License. Please obtain a copy of the License
9 // at http://www.opencascade.org and read it completely before using this file.
10 //
11 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
12 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
13 //
14 // The Original Code and all software distributed under the License is
15 // distributed on an "AS IS" basis, without warranty of any kind, and the
16 // Initial Developer hereby disclaims all such warranties, including without
17 // limitation, any warranties of merchantability, fitness for a particular
18 // purpose or non-infringement. Please see the License for the specific terms
19 // and conditions governing the rights and limitations under the License.
20
21 #include <Geom2dConvert_CompCurveToBSplineCurve.ixx>
22
23 #include <Geom2d_BSplineCurve.hxx>
24 #include <Geom2dConvert.hxx>
25
26 #include <TColStd_Array1OfReal.hxx>
27 #include <TColStd_Array1OfInteger.hxx>
28
29 #include <TColgp_Array1OfPnt2d.hxx>
30 #include <gp_Vec2d.hxx>
31 #include <gp_Pnt2d.hxx>
32 #include <Precision.hxx>
33
34 //=======================================================================
35 //function : constructor
36 //purpose  :
37 //=======================================================================
38 Geom2dConvert_CompCurveToBSplineCurve::Geom2dConvert_CompCurveToBSplineCurve (const Convert_ParameterisationType theParameterisation)
39 : myTol  (Precision::Confusion()),
40   myType (theParameterisation)
41 {
42   //
43 }
44
45 //=======================================================================
46 //function : constructor
47 //purpose  :
48 //=======================================================================
49 Geom2dConvert_CompCurveToBSplineCurve::
50 Geom2dConvert_CompCurveToBSplineCurve(const Handle(Geom2d_BoundedCurve)& BasisCurve, 
51                                       const Convert_ParameterisationType Parameterisation) :
52                                       myTol(Precision::Confusion()),
53                                       myType(Parameterisation)
54 {
55   Handle(Geom2d_BSplineCurve) Bs = 
56       Handle(Geom2d_BSplineCurve)::DownCast(BasisCurve);
57   if (!Bs.IsNull()) { 
58     myCurve =  Handle(Geom2d_BSplineCurve)::DownCast(BasisCurve->Copy()); 
59   }
60   else {
61     myCurve = Geom2dConvert::CurveToBSplineCurve (BasisCurve, myType);
62   }
63 }
64
65 //=======================================================================
66 //function : Add
67 //purpose  :
68 //=======================================================================
69
70 Standard_Boolean Geom2dConvert_CompCurveToBSplineCurve::
71 Add(const Handle(Geom2d_BoundedCurve)& NewCurve,
72     const Standard_Real Tolerance,
73     const Standard_Boolean After)
74 {
75   // conversion
76   Handle(Geom2d_BSplineCurve) Bs = Handle(Geom2d_BSplineCurve)::DownCast (NewCurve);
77   if (!Bs.IsNull())
78   {
79     Bs = Handle(Geom2d_BSplineCurve)::DownCast (NewCurve->Copy());
80   }
81   else
82   {
83     Bs = Geom2dConvert::CurveToBSplineCurve (NewCurve, myType);
84   }
85   if (myCurve.IsNull())
86   {
87     myCurve = Bs;
88     return Standard_True;
89   }
90
91   myTol = Tolerance;
92
93   Standard_Integer LBs = Bs->NbPoles(), LCb = myCurve->NbPoles();
94   
95   // myCurve est elle fermee ?
96   if (myCurve->Pole(LCb).Distance(myCurve->Pole(1))< myTol){
97     if(After){
98       // Ajout Apres ?
99       if (myCurve->Pole(LCb).Distance(Bs->Pole(LBs)) < myTol) {Bs->Reverse();}
100       if (myCurve->Pole(LCb).Distance(Bs->Pole(1)) < myTol) {
101         Add(myCurve, Bs, Standard_True);
102         return Standard_True;
103       }
104     }
105     else{
106       // Ajout avant ?  
107       if (myCurve->Pole(1).Distance(Bs->Pole(1)) < myTol) {Bs->Reverse();}
108       if (myCurve->Pole(1).Distance(Bs->Pole(LBs)) < myTol) {
109         Add(Bs, myCurve, Standard_False);
110         return Standard_True;
111       }
112     }
113   }
114   // Ajout Apres ?
115   else {
116
117     Standard_Real d1 = myCurve->Pole(LCb).Distance(Bs->Pole(1));
118     Standard_Real d2 = myCurve->Pole(LCb).Distance(Bs->Pole(LBs));
119     if (( d1  < myTol) || ( d2 < myTol)) {
120       if (d2 < d1) {Bs->Reverse();}
121       Add(myCurve, Bs, Standard_True);
122       return Standard_True;
123     }
124   // Ajout avant ?  
125     else { 
126       d1 = myCurve->Pole(1).Distance(Bs->Pole(1));
127       d2 = myCurve->Pole(1).Distance(Bs->Pole(LBs));
128       if ( (d1 < myTol) || (d2 < myTol)) {
129         if (d1 < d2) {Bs->Reverse();}
130         Add(Bs, myCurve, Standard_False );
131         return Standard_True;
132       }
133     }
134   }  
135   return Standard_False;
136 }
137
138 //=======================================================================
139 //function : Add
140 //purpose  :
141 //=======================================================================
142
143 void Geom2dConvert_CompCurveToBSplineCurve::Add( 
144       Handle(Geom2d_BSplineCurve)& FirstCurve, 
145       Handle(Geom2d_BSplineCurve)& SecondCurve,
146       const Standard_Boolean After)
147 {
148 // Harmonisation des degres.
149   Standard_Integer Deg = Max(FirstCurve->Degree(), SecondCurve->Degree());
150   if (FirstCurve->Degree() < Deg) { FirstCurve->IncreaseDegree(Deg); }
151   if (SecondCurve->Degree() < Deg)  { SecondCurve->IncreaseDegree(Deg); }
152
153 // Declarationd
154   Standard_Real L1, L2, U_de_raccord;
155   Standard_Integer ii, jj;
156   Standard_Real  Ratio=1, Ratio1, Ratio2, Delta1, Delta2;
157   Standard_Integer NbP1 = FirstCurve->NbPoles(), NbP2 = SecondCurve->NbPoles();
158   Standard_Integer NbK1 = FirstCurve->NbKnots(), NbK2 = SecondCurve->NbKnots();
159   TColStd_Array1OfReal Noeuds (1, NbK1+NbK2-1);
160   TColgp_Array1OfPnt2d Poles (1, NbP1+ NbP2-1);
161   TColStd_Array1OfReal Poids  (1, NbP1+ NbP2-1);
162   TColStd_Array1OfInteger Mults (1, NbK1+NbK2-1);
163
164   // Ratio de reparametrisation (C1 si possible)
165   L1 = FirstCurve->DN(FirstCurve->LastParameter(), 1).Magnitude();
166   L2 = SecondCurve->DN(SecondCurve->FirstParameter(), 1). Magnitude();
167
168   if ( (L1 > Precision::Confusion()) && (L2 > Precision::Confusion()) ) {
169     Ratio = L1 / L2;
170   }
171   if ( (Ratio < Precision::Confusion()) || (Ratio > 1/Precision::Confusion()) ) {Ratio = 1;}
172
173   if (After) {
174 // On ne bouge pas la premiere courbe
175     Ratio1 = 1;
176     Delta1 = 0;
177     Ratio2 = 1/Ratio;
178     Delta2 = Ratio2*SecondCurve->Knot(1) - FirstCurve->Knot(NbK1);
179     U_de_raccord = FirstCurve->LastParameter();
180   }
181   else {
182 // On ne bouge pas la seconde courbe
183     Ratio1 = Ratio;
184     Delta1 = Ratio1*FirstCurve->Knot(NbK1) - SecondCurve->Knot(1);
185     Ratio2 = 1;
186     Delta2 = 0;
187     U_de_raccord = SecondCurve->FirstParameter();
188   }    
189
190 // Les Noeuds
191
192   for (ii=1; ii<NbK1; ii++) {
193     Noeuds(ii) = Ratio1*FirstCurve->Knot(ii) - Delta1;
194     Mults(ii) = FirstCurve->Multiplicity(ii);
195   }
196   Noeuds(NbK1) = U_de_raccord;
197   Mults(NbK1) = FirstCurve->Degree();
198   for (ii=2, jj=NbK1+1; ii<=NbK2; ii++, jj++) {
199     Noeuds(jj) = Ratio2*SecondCurve->Knot(ii) - Delta2;
200     Mults(jj) = SecondCurve->Multiplicity(ii);
201   } 
202  Ratio = FirstCurve->Weight(NbP1) ;
203  Ratio /=  SecondCurve->Weight(1) ;
204 // Les Poles et Poids
205   for (ii=1;  ii<NbP1; ii++) {
206      Poles(ii) =  FirstCurve->Pole(ii);
207      Poids(ii) =  FirstCurve->Weight(ii);
208    }
209   for (ii=1, jj=NbP1;  ii<=NbP2; ii++, jj++) {
210      Poles(jj) =   SecondCurve->Pole(ii);
211 //
212 // attentiion les poids ne se raccord pas forcement C0
213 // d'ou Ratio
214 //
215      Poids(jj) =   Ratio * SecondCurve->Weight(ii);
216    }
217   
218 // Creation de la BSpline
219   myCurve = new (Geom2d_BSplineCurve) (Poles, Poids, Noeuds, Mults, Deg);
220
221 // Reduction eventuelle de la multiplicite
222   Standard_Boolean Ok = Standard_True;
223   Standard_Integer M = Mults(NbK1);
224   while ( (M>0) && Ok) {
225     M--;
226     Ok = myCurve->RemoveKnot(NbK1, M, myTol);
227   }
228 }
229
230 //=======================================================================
231 //function : BSplineCurve
232 //purpose  :
233 //=======================================================================
234
235 Handle(Geom2d_BSplineCurve) Geom2dConvert_CompCurveToBSplineCurve::BSplineCurve() const 
236 {
237   return myCurve;
238 }
239
240 //=======================================================================
241 //function : Clear
242 //purpose  :
243 //=======================================================================
244
245 void Geom2dConvert_CompCurveToBSplineCurve::Clear()
246 {
247   myCurve.Nullify();
248 }