9294c8f7 |
1 | // Created on: 2017-06-16 |
2 | // Created by: Natalia ERMOLAEVA |
3 | // Copyright (c) 2017 OPEN CASCADE SAS |
4 | // |
5 | // This file is part of Open CASCADE Technology software library. |
6 | // |
7 | // This library is free software; you can redistribute it and/or modify it under |
8 | // the terms of the GNU Lesser General Public License version 2.1 as published |
9 | // by the Free Software Foundation, with special exception defined in the file |
10 | // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT |
11 | // distribution for complete text of the license and disclaimer of any warranty. |
12 | // |
13 | // Alternatively, this file may be used under the terms of Open CASCADE |
14 | // commercial license or contractual agreement. |
15 | |
16 | #include <Draw.hxx> |
17 | #include <DrawTrSurf.hxx> |
18 | #include <Draw_Interpretor.hxx> |
19 | #include <GccAna_Circ2d3Tan.hxx> |
20 | #include <GccEnt.hxx> |
21 | #include <GccEnt_QualifiedLin.hxx> |
22 | #include <GccEnt_QualifiedCirc.hxx> |
23 | #include <Geom2d_Line.hxx> |
24 | #include <Geom2d_Circle.hxx> |
25 | #include <Geom2dAdaptor_Curve.hxx> |
26 | #include <GeometryTest.hxx> |
27 | #include <GeometryTest_DrawableQualifiedCurve2d.hxx> |
28 | #include <Precision.hxx> |
29 | #include <TCollection_AsciiString.hxx> |
30 | #include <stdio.h> |
31 | |
32 | //======================================================================= |
33 | //function : qcircle |
34 | //purpose : Parses command: "qcircle name x y radius [-unqualified|-enclosing|-enclosed|-outside|-noqualifier]" |
35 | //======================================================================= |
36 | static Standard_Integer qcurve (Draw_Interpretor&, Standard_Integer theArgsNb, const char** theArgVec) |
37 | { |
38 | if (theArgsNb < 5) |
39 | { |
04232180 |
40 | std::cout << "Error: wrong number of arguments.\n"; |
9294c8f7 |
41 | return 1; |
42 | } |
43 | |
44 | Handle(Geom2d_Curve) aResult2d; |
45 | TCollection_AsciiString aPositionType; |
46 | if (!strcmp (theArgVec[0], "qcircle")) |
47 | { |
48 | if (theArgsNb == 5 || theArgsNb == 6) |
49 | aResult2d = new Geom2d_Circle (gp_Ax22d (gp_Pnt2d (Draw::Atof (theArgVec[2]), Draw::Atof (theArgVec[3])), |
50 | gp_Dir2d (1,0)), Draw::Atof (theArgVec[4])); |
51 | else if (theArgsNb == 7 || theArgsNb == 8) |
52 | aResult2d = new Geom2d_Circle (gp_Ax22d (gp_Pnt2d (Draw::Atof (theArgVec[2]), Draw::Atof (theArgVec[3])), |
53 | gp_Dir2d (Draw::Atof (theArgVec[4]), Draw::Atof (theArgVec[5]))), Draw::Atof (theArgVec[6])); |
54 | |
55 | if (theArgsNb == 6) |
56 | aPositionType = theArgVec[5]; |
57 | else if (theArgsNb == 8) |
58 | aPositionType = theArgVec[7]; |
59 | } |
60 | else if(!strcmp (theArgVec[0], "qline")) |
61 | { |
62 | if (theArgsNb < 6) |
63 | { |
04232180 |
64 | std::cout << "Error: wrong number of arguments.\n"; |
9294c8f7 |
65 | return 1; |
66 | } |
67 | aResult2d = new Geom2d_Line (gp_Pnt2d (Draw::Atof (theArgVec[2]), Draw::Atof (theArgVec[3])), |
68 | gp_Dir2d (Draw::Atof (theArgVec[4]), Draw::Atof (theArgVec[5]))); |
69 | if (theArgsNb == 7) |
70 | aPositionType = theArgVec[6]; |
71 | } |
72 | else |
73 | { |
04232180 |
74 | std::cout << "Error: wrong command name.\n"; |
9294c8f7 |
75 | return 1; |
76 | } |
77 | |
78 | GccEnt_Position aKindOfPosition = GccEnt_unqualified; |
79 | if (!aPositionType.IsEmpty()) |
80 | { |
81 | GccEnt_Position aParameterPosition; |
82 | if (GccEnt::PositionFromString (aPositionType.ToCString(), aParameterPosition)) |
83 | aKindOfPosition = aParameterPosition; |
84 | } |
85 | |
86 | Draw::Set (theArgVec[1], new GeometryTest_DrawableQualifiedCurve2d (aResult2d, aKindOfPosition)); |
87 | return 0; |
88 | } |
89 | |
90 | //======================================================================= |
91 | //function : solutions |
92 | //purpose : |
93 | //======================================================================= |
94 | static Standard_Integer solutions (Draw_Interpretor& theDI, GccAna_Circ2d3Tan& theCirTan3, const char* theName) |
95 | { |
96 | if (!theCirTan3.IsDone()) |
97 | { |
04232180 |
98 | std::cout << "GccAna_Circ2d3Tan is not done"; |
9294c8f7 |
99 | return 1; |
100 | } |
101 | |
102 | TCollection_AsciiString aName = TCollection_AsciiString (theName) + "_"; |
103 | GccEnt_Position aQualifier1, aQualifier2, aQualifier3; |
104 | Standard_Real aParSol, aParArg; |
105 | gp_Pnt2d aPntSol; |
106 | for (Standard_Integer aSolId = 1; aSolId <= theCirTan3.NbSolutions(); aSolId++) |
107 | { |
108 | Handle(Geom2d_Circle) aCircle = new Geom2d_Circle (theCirTan3.ThisSolution (aSolId)); |
109 | TCollection_AsciiString aSolIdName = aName; |
110 | aSolIdName += TCollection_AsciiString (aSolId); |
111 | DrawTrSurf::Set (aSolIdName.ToCString(), aCircle); |
112 | theCirTan3.WhichQualifier (aSolId, aQualifier1, aQualifier2, aQualifier3); |
113 | theDI << "circle: " << aSolIdName.ToCString() << ", " << "qualifiers: " << GccEnt::PositionToString (aQualifier1) |
114 | << ", " << GccEnt::PositionToString (aQualifier2) << ", " << GccEnt::PositionToString (aQualifier3) << "\n"; |
115 | |
116 | theDI << " tangent points: point (parameter on solution, parameter on argument)\n"; |
117 | // the first tangent point |
118 | if (theCirTan3.IsTheSame1 (aSolId)) |
119 | theDI << " " << "= the solution number " << aSolId << " is equal to the first argument\n"; |
120 | else |
121 | { |
122 | theCirTan3.Tangency1 (aSolId, aParSol, aParArg, aPntSol); |
123 | TCollection_AsciiString aTanPntIdName = aSolIdName + "_tp_1"; |
124 | DrawTrSurf::Set (aTanPntIdName.ToCString(), aPntSol); |
125 | theDI << " " << aTanPntIdName.ToCString() << " (" << aParSol << ", " << aParArg << ")\n"; |
126 | } |
127 | // the second tangent point |
128 | if (theCirTan3.IsTheSame2 (aSolId)) |
129 | theDI << " " << "= the solution number " << aSolId << " is equal to the second argument\n"; |
130 | else |
131 | { |
132 | theCirTan3.Tangency2 (aSolId, aParSol, aParArg, aPntSol); |
133 | TCollection_AsciiString aTanPntIdName = aSolIdName + "_tp_2"; |
134 | DrawTrSurf::Set (aTanPntIdName.ToCString(), aPntSol); |
135 | theDI << " " << aTanPntIdName.ToCString() << " (" << aParSol << ", " << aParArg << ")\n"; |
136 | } |
137 | // the third tangent point |
138 | if (theCirTan3.IsTheSame3 (aSolId)) |
139 | theDI << " " << "= the solution number " << aSolId << " is equal to the third argument\n"; |
140 | else |
141 | { |
142 | theCirTan3.Tangency3 (aSolId, aParSol, aParArg, aPntSol); |
143 | TCollection_AsciiString aTanPntIdName = aSolIdName + "_tp_3"; |
144 | DrawTrSurf::Set (aTanPntIdName.ToCString(), aPntSol); |
145 | theDI << " " << aTanPntIdName.ToCString() << " (" << aParSol << ", " << aParArg << ")"; |
146 | } |
147 | if (aSolId != theCirTan3.NbSolutions()) |
148 | theDI << "\n"; |
149 | } |
150 | return 0; |
151 | } |
152 | |
153 | //======================================================================= |
154 | //function : circ2d3Tan |
155 | //purpose : Parses command: [circ2d3Tan cname qcicrle1/qlin1/point1 qcicrle2/qlin2/point2 qcicrle3/qlin3/point3 |
156 | // tolerance] |
157 | //======================================================================= |
158 | static Standard_Integer circ2d3Tan (Draw_Interpretor& theDI, Standard_Integer theArgsNb, const char** theArgVec) |
159 | { |
160 | if (theArgsNb < 5) |
161 | { |
04232180 |
162 | std::cout << "Error: wrong number of arguments.\n"; |
9294c8f7 |
163 | return 1; |
164 | } |
165 | |
166 | Handle(GeometryTest_DrawableQualifiedCurve2d) aQCurve1 = |
167 | Handle(GeometryTest_DrawableQualifiedCurve2d)::DownCast (Draw::Get (theArgVec[2])); |
168 | Handle(GeometryTest_DrawableQualifiedCurve2d) aQCurve2 = |
169 | Handle(GeometryTest_DrawableQualifiedCurve2d)::DownCast (Draw::Get (theArgVec[3])); |
170 | Handle(GeometryTest_DrawableQualifiedCurve2d) aQCurve3 = |
171 | Handle(GeometryTest_DrawableQualifiedCurve2d)::DownCast (Draw::Get (theArgVec[4])); |
172 | |
173 | gp_Pnt2d aPoint1, aPoint2, aPoint3; |
174 | Standard_Boolean anIsPoint1 = DrawTrSurf::GetPoint2d (theArgVec[2], aPoint1); |
175 | Standard_Boolean anIsPoint2 = DrawTrSurf::GetPoint2d (theArgVec[3], aPoint2); |
176 | Standard_Boolean anIsPoint3 = DrawTrSurf::GetPoint2d (theArgVec[4], aPoint3); |
177 | |
178 | Standard_Real aTolerance = Precision::Confusion(); |
179 | if (theArgsNb > 5) |
180 | aTolerance = Draw::Atof (theArgVec[5]); |
181 | |
182 | if (aQCurve1.IsNull()) // <point, point, point> |
183 | { |
184 | if (!anIsPoint1 || !anIsPoint2 || !anIsPoint3) |
185 | { |
04232180 |
186 | std::cout << "Error: wrong points definition.\n"; |
9294c8f7 |
187 | return 1; |
188 | } |
189 | GccAna_Circ2d3Tan aCircBuilder (aPoint1, aPoint2, aPoint3, aTolerance); |
190 | return solutions (theDI, aCircBuilder, theArgVec[1]); |
191 | } |
192 | |
193 | // the first curve is not NULL |
194 | if (aQCurve2.IsNull()) // <qcircle, point, point> or <qlin, point, point> |
195 | { |
196 | if (!anIsPoint2 || !anIsPoint3) |
197 | { |
04232180 |
198 | std::cout << "Error: wrong points definition.\n"; |
9294c8f7 |
199 | return 1; |
200 | } |
201 | Geom2dAdaptor_Curve anAdaptorCurve1 (aQCurve1->GetCurve()); |
202 | if (anAdaptorCurve1.GetType() == GeomAbs_Circle) |
203 | { |
204 | GccEnt_QualifiedCirc aQualifiedCircle1 (anAdaptorCurve1.Circle(), aQCurve1->GetPosition()); |
205 | GccAna_Circ2d3Tan aCircBuilder (aQualifiedCircle1, aPoint2, aPoint3, aTolerance); |
206 | return solutions (theDI, aCircBuilder, theArgVec[1]); |
207 | } |
208 | else if (anAdaptorCurve1.GetType() == GeomAbs_Line) |
209 | { |
210 | GccEnt_QualifiedLin aQualifiedLin1 (anAdaptorCurve1.Line(), aQCurve1->GetPosition()); |
211 | GccAna_Circ2d3Tan aCircBuilder (aQualifiedLin1, aPoint2, aPoint3, aTolerance); |
212 | return solutions (theDI, aCircBuilder, theArgVec[1]); |
213 | } |
04232180 |
214 | std::cout << "Error: wrong curve type.\n"; |
9294c8f7 |
215 | return 1; |
216 | } |
217 | |
218 | // the first and the second curves are not NULL |
219 | if (aQCurve3.IsNull()) // <qcircle, qcircle, point> or <qcircle, qlin, point> or <qlin, qlin, point> |
220 | { |
221 | if (!anIsPoint3) |
222 | { |
04232180 |
223 | std::cout << "Error: wrong point definition.\n"; |
9294c8f7 |
224 | return 1; |
225 | } |
226 | Geom2dAdaptor_Curve anAdaptorCurve1 (aQCurve1->GetCurve()); |
227 | Geom2dAdaptor_Curve anAdaptorCurve2 (aQCurve2->GetCurve()); |
228 | if (anAdaptorCurve1.GetType() == GeomAbs_Circle && anAdaptorCurve2.GetType() == GeomAbs_Circle) |
229 | { |
230 | GccEnt_QualifiedCirc aQualifiedCircle1 (anAdaptorCurve1.Circle(), aQCurve1->GetPosition()); |
231 | GccEnt_QualifiedCirc aQualifiedCircle2 (anAdaptorCurve2.Circle(), aQCurve2->GetPosition()); |
232 | GccAna_Circ2d3Tan aCircBuilder (aQualifiedCircle1, aQualifiedCircle2, aPoint3, aTolerance); |
233 | return solutions (theDI, aCircBuilder, theArgVec[1]); |
234 | } |
235 | else if (anAdaptorCurve1.GetType() == GeomAbs_Circle && anAdaptorCurve2.GetType() == GeomAbs_Line) |
236 | { |
237 | GccEnt_QualifiedCirc aQualifiedCircle1 (anAdaptorCurve1.Circle(), aQCurve1->GetPosition()); |
238 | GccEnt_QualifiedLin aQualifiedLin2 (anAdaptorCurve2.Line(), aQCurve2->GetPosition()); |
239 | GccAna_Circ2d3Tan aCircBuilder (aQualifiedCircle1, aQualifiedLin2, aPoint3, aTolerance); |
240 | return solutions (theDI, aCircBuilder, theArgVec[1]); |
241 | } |
242 | else if (anAdaptorCurve1.GetType() == GeomAbs_Line && anAdaptorCurve2.GetType() == GeomAbs_Line) |
243 | { |
244 | GccEnt_QualifiedLin aQualifiedLin1 (anAdaptorCurve1.Line(), aQCurve1->GetPosition()); |
245 | GccEnt_QualifiedLin aQualifiedLin2 (anAdaptorCurve2.Line(), aQCurve2->GetPosition()); |
246 | GccAna_Circ2d3Tan aCircBuilder (aQualifiedLin1, aQualifiedLin2, aPoint3, aTolerance); |
247 | return solutions (theDI, aCircBuilder, theArgVec[1]); |
248 | } |
04232180 |
249 | std::cout << "Error: wrong curve type.\n"; |
9294c8f7 |
250 | return 1; |
251 | } |
252 | |
253 | // the first, the second and the third curves are not NULL |
254 | // <qcircle, qcircle, qcircle> or <qcircle, qcircle, qlin>, <qcircle, qlin, qlin>, <qlin, qlin, qlin> |
255 | Geom2dAdaptor_Curve anAdaptorCurve1 (aQCurve1->GetCurve()); |
256 | Geom2dAdaptor_Curve anAdaptorCurve2 (aQCurve2->GetCurve()); |
257 | Geom2dAdaptor_Curve anAdaptorCurve3 (aQCurve3->GetCurve()); |
258 | if (anAdaptorCurve1.GetType() == GeomAbs_Circle && anAdaptorCurve2.GetType() == GeomAbs_Circle && |
259 | anAdaptorCurve3.GetType() == GeomAbs_Circle) |
260 | { |
261 | GccEnt_QualifiedCirc aQualifiedCircle1 (anAdaptorCurve1.Circle(), aQCurve1->GetPosition()); |
262 | GccEnt_QualifiedCirc aQualifiedCircle2 (anAdaptorCurve2.Circle(), aQCurve2->GetPosition()); |
263 | GccEnt_QualifiedCirc aQualifiedCircle3 (anAdaptorCurve3.Circle(), aQCurve3->GetPosition()); |
264 | GccAna_Circ2d3Tan aCircBuilder (aQualifiedCircle1, aQualifiedCircle2, aQualifiedCircle3, aTolerance); |
265 | return solutions (theDI, aCircBuilder, theArgVec[1]); |
266 | } |
267 | if (anAdaptorCurve1.GetType() == GeomAbs_Circle && anAdaptorCurve2.GetType() == GeomAbs_Circle && |
268 | anAdaptorCurve3.GetType() == GeomAbs_Line) |
269 | { |
270 | GccEnt_QualifiedCirc aQualifiedCircle1 (anAdaptorCurve1.Circle(), aQCurve1->GetPosition()); |
271 | GccEnt_QualifiedCirc aQualifiedCircle2 (anAdaptorCurve2.Circle(), aQCurve2->GetPosition()); |
272 | GccEnt_QualifiedLin aQualifiedLin3 (anAdaptorCurve3.Line(), aQCurve3->GetPosition()); |
273 | GccAna_Circ2d3Tan aCircBuilder (aQualifiedCircle1, aQualifiedCircle2, aQualifiedLin3, aTolerance); |
274 | return solutions (theDI, aCircBuilder, theArgVec[1]); |
275 | } |
276 | if (anAdaptorCurve1.GetType() == GeomAbs_Circle && anAdaptorCurve2.GetType() == GeomAbs_Line && |
277 | anAdaptorCurve3.GetType() == GeomAbs_Line) |
278 | { |
279 | GccEnt_QualifiedCirc aQualifiedCircle1 (anAdaptorCurve1.Circle(), aQCurve1->GetPosition()); |
280 | GccEnt_QualifiedLin aQualifiedLin2 (anAdaptorCurve2.Line(), aQCurve2->GetPosition()); |
281 | GccEnt_QualifiedLin aQualifiedLin3 (anAdaptorCurve3.Line(), aQCurve3->GetPosition()); |
282 | GccAna_Circ2d3Tan aCircBuilder (aQualifiedCircle1, aQualifiedLin2, aQualifiedLin3, aTolerance); |
283 | return solutions (theDI, aCircBuilder, theArgVec[1]); |
284 | } |
285 | if (anAdaptorCurve1.GetType() == GeomAbs_Line && anAdaptorCurve2.GetType() == GeomAbs_Line && |
286 | anAdaptorCurve3.GetType() == GeomAbs_Line) |
287 | { |
288 | GccEnt_QualifiedLin aQualifiedLin1 (anAdaptorCurve1.Line(), aQCurve1->GetPosition()); |
289 | GccEnt_QualifiedLin aQualifiedLin2 (anAdaptorCurve2.Line(), aQCurve2->GetPosition()); |
290 | GccEnt_QualifiedLin aQualifiedLin3 (anAdaptorCurve3.Line(), aQCurve3->GetPosition()); |
291 | GccAna_Circ2d3Tan aCircBuilder (aQualifiedLin1, aQualifiedLin2, aQualifiedLin3, aTolerance); |
292 | return solutions (theDI, aCircBuilder, theArgVec[1]); |
293 | } |
294 | |
04232180 |
295 | std::cout << "Error: wrong curve type.\n"; |
9294c8f7 |
296 | return 1; |
297 | } |
298 | |
299 | //======================================================================= |
300 | //function : CurveTanCommands |
301 | //purpose : |
302 | //======================================================================= |
303 | void GeometryTest::CurveTanCommands (Draw_Interpretor& theCommands) |
304 | { |
305 | static Standard_Boolean aLoaded = Standard_False; |
306 | if (aLoaded) return; |
307 | aLoaded = Standard_True; |
308 | |
309 | DrawTrSurf::BasicCommands (theCommands); |
310 | |
311 | const char* aGroup; |
312 | aGroup = "GEOMETRY tangent curves creation"; |
313 | |
314 | theCommands.Add ("qcircle", |
315 | "qcircle name {x y [ux uy] radius} [-unqualified|-enclosing|-enclosed|-outside|-noqualifier]" |
316 | "\n\t\t: Creates qualified circle.", |
317 | __FILE__, qcurve, aGroup); |
318 | |
319 | theCommands.Add ("qline", |
320 | "qline name x y dx dy [-unqualified|-enclosing|-enclosed|-outside|-noqualifier]" |
321 | "\n\t\t: Creates qualified line.", |
322 | __FILE__, qcurve, aGroup); |
323 | |
324 | theCommands.Add ("circ2d3Tan", |
325 | "circ2d3Tan cname {qcicrle1|qlin1|point1} {qcicrle2|qlin2|point2} {qcicrle3|qlin3|point3} [tolerance]" |
326 | "\n\t\t: Creates 2d circles tangent to 3 arguments. The arguments are points, lines or circles." |
327 | "\n\t\t: Possible arguments combinations:" |
328 | "\n\t\t: <qcircle, qcircle, qcircle>," |
329 | "\n\t\t: <qcircle, qcircle, qlin>," |
330 | "\n\t\t: <qcircle, qcircle, point>," |
331 | "\n\t\t: <qcircle, qlin, qlin>," |
332 | "\n\t\t: <qcircle, qlin, point>," |
333 | "\n\t\t: <qcircle, qlin, qlin>," |
334 | "\n\t\t: <qcircle, point, point>," |
335 | "\n\t\t: <qlin, qlin, qlin>," |
336 | "\n\t\t: <qlin, qlin, point>," |
337 | "\n\t\t: <qlin, point, point>," |
338 | "\n\t\t: <point, point, point>.", |
339 | __FILE__, circ2d3Tan, aGroup); |
340 | } |