0020716: Eliminate usage of "config.h" header file
[occt.git] / src / TestTopOpe / TestTopOpe_HDSCommands.cxx
CommitLineData
b311480e 1// Created on: 1994-10-24
2// Created by: Jean Yves LEBEY
3// Copyright (c) 1994-1999 Matra Datavision
973c2be1 4// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e 5//
973c2be1 6// This file is part of Open CASCADE Technology software library.
b311480e 7//
d5f74e42 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
973c2be1 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.
b311480e 13//
973c2be1 14// Alternatively, this file may be used under the terms of Open CASCADE
15// commercial license or contractual agreement.
7fd59977 16
7fd59977 17#include <TestTopOpe.hxx>
18#include <TestTopOpe_HDSDisplayer.hxx>
19#include <TestTopOpeDraw_DrawableSHA.hxx>
20#include <TestTopOpeDraw_DrawableP3D.hxx>
21#include <TestTopOpeDraw_DrawableC3D.hxx>
22#include <TestTopOpeDraw_TTOT.hxx>
23#include <TestTopOpeDraw_Displayer.hxx>
24#include <TopOpeBRepDS_connex.hxx>
25#include <TopOpeBRepDS_Point.hxx>
26#include <TopOpeBRepDS_Curve.hxx>
27#include <TopOpeBRepDS_PointIterator.hxx>
28#include <TopOpeBRepDS_PointExplorer.hxx>
29#include <TopOpeBRepDS_CurveExplorer.hxx>
30#include <TopOpeBRepDS_Explorer.hxx>
31#include <TopOpeBRepDS_TKI.hxx>
32#include <TopOpeBRepDS_Check.hxx>
33#include <TopOpeBRepDS_Dumper.hxx>
34#include <TopOpeBRepDS.hxx>
35#include <Geom_TrimmedCurve.hxx>
36#include <BRep_Tool.hxx>
37#include <TopoDS.hxx>
38#include <TopLoc_Location.hxx>
39#include <Geom_Curve.hxx>
40#include <GeomAdaptor_Curve.hxx>
41#include <GeomAbs_CurveType.hxx>
42#include <GeomAdaptor_Surface.hxx>
43#include <GeomAbs_SurfaceType.hxx>
44#include <GeomAPI_ProjectPointOnCurve.hxx>
45#include <BRepAdaptor_Curve.hxx>
46#include <TColStd_ListOfInteger.hxx>
47#include <TColStd_ListIteratorOfListOfInteger.hxx>
48#include <TopOpeBRepDS_define.hxx>
49#include <DBRep.hxx>
50#include <Draw_Appli.hxx>
51#include <DrawTrSurf_Curve.hxx>
52#include <Draw_Interpretor.hxx>
53#include <DrawTrSurf.hxx>
54
7fd59977 55class TSEEpar {
56public:
57 TSEEpar(const TCollection_AsciiString& s) { set(s); }
58 void set(const TCollection_AsciiString& s) {
59 miskind = misshap = misgeom = missect = misdege = misafev = misedcu = Standard_False;
60 mTK = TopOpeBRepDS_UNKNOWN; mTS = TopAbs_SHAPE;
61 char* sK = (char *)s.ToCString();
62 miskind = TestTopOpeDraw_TTOT::StringToKind(s,mTK);
63 if ( miskind ) {
64 misshap = TopOpeBRepDS::IsTopology(mTK);
65 if (misshap) mTS = TopOpeBRepDS::KindToShape(mTK);
66 else misgeom = TopOpeBRepDS::IsGeometry(mTK);
67 }
68 else if ( ! strcasecmp(sK,"s") ) {
69 misshap = Standard_True; mTS = TopAbs_SHAPE;
70 }
71 else if ( ! strcasecmp(sK,"se") ) {
72 missect = Standard_True; mTK = TopOpeBRepDS_EDGE;
73 }
74 else if ( ! strcasecmp(sK,"de") ) {
75 misdege = Standard_True; mTK = TopOpeBRepDS_EDGE;
76 }
77 else if ( ! strcasecmp(sK,"fev") ) {
78 misafev = Standard_True;
79 }
80 else if ( ! strcasecmp(sK,"ec") ) {
81 misedcu = Standard_True;
82 }
83 }
84 Standard_Boolean iskind() { return miskind;}
85 Standard_Boolean isshap() { return misshap;}
86 Standard_Boolean isgeom() { return misgeom;}
87 Standard_Boolean issect() { return missect;}
88 Standard_Boolean isdege() { return misdege;}
89 Standard_Boolean isafev() { return misafev;}
90 Standard_Boolean isedcu() { return misedcu;}
91 TopOpeBRepDS_Kind TK() {return mTK;}
92 TopAbs_ShapeEnum TS() {return mTS;}
93private:
94 Standard_Boolean miskind,misshap,misgeom,missect,misdege,misafev,misedcu;
95 TopOpeBRepDS_Kind mTK; TopAbs_ShapeEnum mTS;
96};
97
98class TDSpar : public TSEEpar {
99public:
100 TDSpar(const TCollection_AsciiString& s) : TSEEpar(s) {}
101};
102
103#define ISINTEGER(MMstr) ((strspn((MMstr),"0123456789") == strlen((MMstr))))
104
1d0a9d4d 105TestTopOpe_HDSDisplayer* PHDSD = NULL;
106static TestTopOpeDraw_Displayer* POCD = NULL;
7fd59977 107//Standard_IMPORT extern Standard_Integer TopOpeBRepDS_GLOBALHDSinterfselector;
108Standard_IMPORT Standard_Integer TopOpeBRepDS_GLOBALHDSinterfselector;
109
110static Standard_Boolean SFindKeep = Standard_False;
111static Standard_Boolean GFindKeep = Standard_False;
112static Standard_Boolean PrintDistancePP = Standard_False;
113static Standard_Integer SelectRankShape = 0;
114static Standard_Boolean DisOri = Standard_False;
115static Standard_Boolean TolFlag = Standard_False;
116static Standard_Real OldParFlag = -1.0;
117static Standard_Real ParFlag = -1.0;
118
119class tsee_entity {
120public:
121 Standard_Boolean myEOK;
122 TestTopOpe_HDSDisplayer* myEPHDSD;
123 Handle(TopOpeBRepDS_HDataStructure) myEHDS; TopOpeBRepDS_DataStructure *myEPDS;
124 TopOpeBRepDS_Kind myETK;TopAbs_ShapeEnum myETS;Standard_Integer myEindex;
125 Standard_Boolean myEiskind,myEisshape,myEisgeome,myEissect;
126 TCollection_AsciiString myEnamedbrep,myEnamedisp; Draw_ColorKind myEnamecolor;
127
128//JR/Hp :
129 tsee_entity() {
130// tsee_entity::tsee_entity() {
131 myEOK = Standard_False;
132 if (PHDSD == NULL) return; myEPHDSD = PHDSD;
133 myEHDS = myEPHDSD->CurrentHDS(); myEPDS = (TopOpeBRepDS_DataStructure*)&myEHDS->ChangeDS();
134 myETK = TopOpeBRepDS_UNKNOWN;myETS = TopAbs_SHAPE; myEindex = 0;
135 myEiskind = myEisshape = myEisgeome = myEissect = Standard_False;
136 myEnamedbrep = ""; myEnamedisp = ""; myEnamecolor = Draw_blanc;
137 myEOK = Standard_True;
138 }
139
140 Standard_Boolean IsP() const { return (myETK == TopOpeBRepDS_POINT); }
141 Standard_Boolean IsV() const { return (myETK == TopOpeBRepDS_VERTEX); }
142 Standard_Boolean Is0() const { return IsP() || IsV(); }
143 Standard_Integer Set(Standard_Integer na,const char** a,Standard_Integer iargK,Standard_Integer iargI);
144 void Delete() ;
145 Standard_EXPORT virtual ~tsee_entity() {Delete() ;} ;
146 void virtual Dump() const;
147 void virtual See() = 0;
148};
149
150void tsee_entity::Delete()
151{}
152
153Standard_Integer tsee_entity::Set(Standard_Integer na,const char** a,Standard_Integer iargK,Standard_Integer iargI) {
154 myEOK = Standard_False;
155 if (iargK>=na) return 1; if (iargI>=na) return 1;
91322f44 156 TCollection_AsciiString ascK = a[iargK]; myEindex = Draw::Atoi(a[iargI]);
7fd59977 157 myEiskind = TestTopOpeDraw_TTOT::StringToKind(ascK,myETK);
158 if (!myEiskind) return 1; if (myETK == TopOpeBRepDS_UNKNOWN) return 1;
159
160 myEisshape = TopOpeBRepDS::IsTopology(myETK);
161 if (myEisshape) {
162 if ((myEindex < 1) || (myEindex > myEPDS->NbShapes())) return 0;
163 myETS = TopOpeBRepDS::KindToShape(myETK);
164 const TopoDS_Shape& S = myEPDS->Shape(myEindex);
165 if (myETS != S.ShapeType()) return 0;
166 myEPHDSD->ShapeName(myEindex,S,myEnamedbrep);
167 myEPHDSD->ShapeDisplayName(myEindex,S,myEnamedisp);
168 }
169
170 myEisgeome = TopOpeBRepDS::IsGeometry(myETK);
171 if (myEisgeome) {
172 if (IsP()) {
173 TopOpeBRepDS_PointExplorer pex(myEHDS->DS());
174 if (!pex.IsPoint(myEindex)) return 1;
175 }
176 TestTopOpeDraw_TTOT::GeometryName(myEindex,myETK,myEnamedbrep);
177 myEPHDSD->GeometryDisplayName(myEindex,myETK,myEnamedisp);
178 }
179
180 myEnamecolor = TestTopOpeDraw_TTOT::GeometryColor(myETK);
181 myEOK = Standard_True;
182 return 0;
183}
184
185void tsee_entity::Dump() const {
186 TopOpeBRepDS_Dumper Dumper(myEHDS);
187 if (myEisgeome) Dumper.DumpGeometry(myETK,myEindex,cout);
188 if (myEisshape) Dumper.DumpTopology(myETK,myEindex,cout);
189}
190
191class tsee_entity0 : public tsee_entity {
192public:
193
194 gp_Pnt Pnt() const;
195 void See();
196
197};
198
199gp_Pnt tsee_entity0::Pnt() const
200{
b3a7aa39 201 if (!Is0()) Standard_Failure::Raise("not 0d");
7fd59977 202 gp_Pnt P;
203 if (IsP()) P = myEPDS->Point(myEindex).Point();
204 else if (IsV()) P = BRep_Tool::Pnt(TopoDS::Vertex(myEPDS->Shape(myEindex)));
205 return P;
206}
207
208static void SetPoint
209(const TCollection_AsciiString& namedbrep,const TCollection_AsciiString& namedisp,const Draw_Color& namecolor,const TopOpeBRepDS_Point& P)
210{
211 Handle(TestTopOpeDraw_DrawableP3D) D;
212 if(TolFlag) {
213 D = new TestTopOpeDraw_DrawableP3D(P.Point(),Draw_CircleZoom,namecolor,
214 namedisp.ToCString(),namecolor,
215 P.Tolerance());
216 } else {
217 D = new TestTopOpeDraw_DrawableP3D(P.Point(),Draw_Square,namecolor,
218 namedisp.ToCString(),namecolor);
219 }
220 char *pname = (char *)namedbrep.ToCString();
221 Draw::Set(pname,Handle(Draw_Marker3D)::DownCast(D));
222
223}
224void tsee_entity0::See()
225{
226 if (IsP()) ::SetPoint(myEnamedbrep,myEnamedisp,myEnamecolor,myEPDS->Point(myEindex));
227 if (IsV()) POCD->DisplayShape(myEnamedbrep,myEnamedisp,myEPDS->Shape(myEindex));
228}
229
230//-----------------------------------------------
231static void SetCurve
232//-----------------------------------------------
233(const TCollection_AsciiString& namedbrep,
234 const TCollection_AsciiString& namedisp,
235 const Draw_Color& namecolor,
236 const TopOpeBRepDS_Curve& DSC,
237 const Standard_Integer iC)
238{
239 if ( !PHDSD ) return;
240 const Handle(Geom_Curve) GC = DSC.Curve();
241 if ( GC.IsNull() ) { cout<<"Curve() nulle"<<endl; return; }
242
7fd59977 243 Standard_Real f = GC->FirstParameter();
244 Standard_Real l = GC->LastParameter();
245
246 GeomAdaptor_Curve GAC(GC);
247 GeomAbs_CurveType GACt = GAC.GetType();
248 if ( GACt == GeomAbs_Line ) {
249 Standard_Real fline = RealLast(),lline = RealFirst();
250 Standard_Integer imother = DSC.Mother(),igood;
251 if(imother) igood = imother;
252 else igood = iC;
253 TopOpeBRepDS_PointIterator it = PHDSD->CurrentHDS()->CurvePoints(igood);
254 for(; it.More(); it.Next()) {
255 Standard_Real p = it.Parameter();
256 fline = Min(fline,p); lline = Max(fline,p);
257 }
258 f = fline;
259 l = lline;
260 }
261
262 Handle(Geom_TrimmedCurve) GTC = new Geom_TrimmedCurve(GC,f,l);
263 Handle(TestTopOpeDraw_DrawableC3D) D;
264 D = new TestTopOpeDraw_DrawableC3D(GTC,namecolor,namedisp.ToCString(),namecolor);
265 char *pname = (char *)namedbrep.ToCString();
266 Draw::Set(pname,Handle(DrawTrSurf_Curve)::DownCast(D));
267}
268
269static TopoDS_Shape bidbid;
270static const TopoDS_Shape& GetShape(const Standard_Integer IS,const TopAbs_ShapeEnum TS)
271{
272 Standard_Boolean TypeControl = Standard_True;
273 if ( !PHDSD ) return bidbid;
274
275 static TopoDS_Shape ShapeNull;
276 const TopOpeBRepDS_DataStructure& BDS = PHDSD->CurrentBDS();
277
278 // check on shape index and on shape kind if kind differs from TopAbs_SHAPE
279 Standard_Integer ns = BDS.NbShapes();
280 if ( IS < 1 || IS > ns) {
281 TopAbs::Print(TS,cout);cout<<" "<<IS<<" does not exist in DS"<<endl;
282 return ShapeNull;
283 }
284 else if ( !PHDSD->ShapeKind(IS,TS) ) {
285 if ( TypeControl ) {
286 cout<<"Shape "<<IS;
287 cout<<" is not a ";TopAbs::Print(TS,cout);
288 cout<<" but a "; TopAbs::Print(BDS.Shape(IS,SFindKeep).ShapeType(),cout);
289 cout<<endl;
290 }
291 return ShapeNull;
292 }
293
294 const TopoDS_Shape& S = BDS.Shape(IS,SFindKeep);
295 return S;
296}
297
298static const TopoDS_Shape& GetShape(const Standard_Integer IS)
299{
300 if ( !PHDSD ) return bidbid;
301 const TopOpeBRepDS_DataStructure& BDS = PHDSD->CurrentBDS();
302 const TopoDS_Shape& S = BDS.Shape(IS);
303 return S;
304}
305
7fd59977 306//-----------------------------------------------------------------------
307// SeeSectionEdge
308//-----------------------------------------------------------------------
309static Standard_Integer SeeSectionEdge(const Standard_Integer ISE)
310{
311 if ( !PHDSD || !POCD ) return 0;
312
313 Standard_Integer nse = PHDSD->CurrentBDS().NbSectionEdges();
314 if ( ISE < 1 || ISE > nse ) return 0;
315 const TopoDS_Shape& SE = PHDSD->CurrentBDS().SectionEdge(ISE);
316 if (SE.IsNull()) return 0;
7fd59977 317
318 TCollection_AsciiString namedbrep; PHDSD->SectionEdgeName(ISE,SE,namedbrep);
319 TCollection_AsciiString namedisp; PHDSD->SectionEdgeDisplayName(ISE,SE,namedisp);
320 POCD->DisplayGeometry(Standard_True);
321 POCD->DisplayShape(namedbrep,namedisp,SE);
322 return 0;
323}
324
325//-----------------------------------------------------------------------
326// SeeShapeIS
327//-----------------------------------------------------------------------
328Standard_Integer SeeShapeIS(const Standard_Integer I,const TopoDS_Shape& S)
329{
330 if ( !PHDSD || !POCD) return 0;
331
332 if (S.IsNull()) return 0;
333 TCollection_AsciiString namedbrep; PHDSD->ShapeName(I,S,namedbrep);
334 TCollection_AsciiString namedisp = namedbrep;
335 // NameDisplay = *name/name* if S subshape of shape1/shape2
336 TCollection_AsciiString ast = "*";
337 const TopOpeBRepDS_DataStructure& BDS = PHDSD->CurrentBDS();
338 // if the Shape was removed from the DS, "*" is replaced by "~"
339 if(!BDS.HasShape(S))
340 ast = "~";
341 Standard_Boolean of1 = PHDSD->SubShape(S,1);if(of1) namedisp = ast+namedisp;
342 Standard_Boolean of2 = PHDSD->SubShape(S,2);if(of2) namedisp = namedisp+ast;
343 if (SelectRankShape == 1 && !of1) return 0;
344 if (SelectRankShape == 2 && !of2) return 0;
345
346 if (S.ShapeType()==TopAbs_EDGE) POCD->DisplayGeometry(Standard_True);
347 else POCD->DisplayGeometry(DisOri);
348 if((S.ShapeType()==TopAbs_VERTEX) && TolFlag) {
349 const TopoDS_Vertex& V = TopoDS::Vertex(S);
350 Standard_Real Tol = BRep_Tool::Tolerance(V);
351 POCD->SetTol(Tol);
352 }
353 POCD->DisplayShape(namedbrep,namedisp,S);
354
355 return 0;
356}
357
358
359//-----------------------------------------------------------------------
360// SeeShape
361//-----------------------------------------------------------------------
362static Standard_Integer SeeShape(TCollection_AsciiString namedbrep)
363{
364 if ( !PHDSD || !POCD ) return 0;
365
366 const char* pname = (const char *)namedbrep.ToCString();
367 TopoDS_Shape S = DBRep::Get(pname);
368 if ( S.IsNull() ) return 0;
369 TCollection_AsciiString namedisp;
370 PHDSD->ShapeDisplayName(namedbrep,S,namedisp);
371 POCD->DisplayShape(namedbrep,namedisp,S);
372 return 0;
373}
374
375//-----------------------------------------------------------------------
376// SeePoint
377//-----------------------------------------------------------------------
378static Standard_Integer SeePoint(const Standard_Integer I)
379{
380 if ( !PHDSD ) return 0;
381
382 const TopOpeBRepDS_DataStructure& BDS = PHDSD->CurrentBDS();
383 if (I < 1 || I > BDS.NbPoints()) return 0;
384
385 TopOpeBRepDS_PointExplorer pex(BDS);
386 Standard_Boolean isp = pex.IsPoint(I);
387 if (!isp) return 0;
388
389 const TopOpeBRepDS_Point& P = BDS.Point(I);
390 TopOpeBRepDS_Kind K = TopOpeBRepDS_POINT;
391 TCollection_AsciiString namedbrep; TestTopOpeDraw_TTOT::GeometryName(I,K,namedbrep);
392 TCollection_AsciiString namedisp; PHDSD->GeometryDisplayName(I,K,namedisp);
393 Draw_ColorKind namecolor = TestTopOpeDraw_TTOT::GeometryColor(K);
394 SetPoint(namedbrep,namedisp,namecolor,P);
395 return 0;
396}
397
398//-----------------------------------------------------------------------
399// SeeCurve
400//-----------------------------------------------------------------------
401static Standard_Integer SeeCurve(const Standard_Integer I)
402{
403 if ( !PHDSD ) return 0;
404
405 const TopOpeBRepDS_DataStructure& BDS = PHDSD->CurrentBDS();
406 if (I < 1 || I > BDS.NbCurves()) return 0;
407
408 TopOpeBRepDS_CurveExplorer cex(BDS,GFindKeep);
409 Standard_Boolean isc = cex.IsCurve(I);
410 if (!isc) return 0;
411
412 const TopOpeBRepDS_Curve& C = BDS.Curve(I);
413 TopOpeBRepDS_Kind K = TopOpeBRepDS_CURVE;
414 TCollection_AsciiString namedbrep; TestTopOpeDraw_TTOT::GeometryName(I,K,namedbrep);
415 TCollection_AsciiString namedisp; PHDSD->GeometryDisplayName(I,K,namedisp);
416 Draw_ColorKind namecolor = TestTopOpeDraw_TTOT::GeometryColor(K);
417 SetCurve(namedbrep,namedisp,namecolor,C,I);
418 return 0;
419}
420
421
422//-----------------------------------------------------------------------
423// SeeSurface NYI
424//-----------------------------------------------------------------------
425Standard_Integer SeeSurface(const Standard_Integer I) // NYI
426{
427 if ( !PHDSD ) return 0;
428
429 const TopOpeBRepDS_DataStructure& BDS = PHDSD->CurrentBDS();
430 if (I < 1 || I > BDS.NbSurfaces()) return 0;
431 return 0;
432}
433
434//-----------------------------------------------------------------------
435// SeeEdgeCurve
436//-----------------------------------------------------------------------
437static Standard_Integer SeeEdgeCurve(const Standard_Integer IE,const TopoDS_Shape& SE)
438{
439 if ( !POCD ) return 0;
440
441 if (SE.IsNull()) return 0;
442 const TopoDS_Edge& E = TopoDS::Edge(SE);
443 TopLoc_Location L;Standard_Real f,l;Handle(Geom_Curve) GC=BRep_Tool::Curve(E,L,f,l);
444 TCollection_AsciiString namedbrep="E";TestTopOpeDraw_TTOT::CatCurveName(IE,namedbrep);
445 TCollection_AsciiString namedisp="E";TestTopOpeDraw_TTOT::CatCurveDisplayName(IE,GC,namedisp);
446 POCD->DisplayGeometry(Standard_True);
447 POCD->DisplayShape(namedbrep,namedisp,SE);
448 return 0;
449}
450
451//-----------------------------------------------------------------------
452// SeeGeometry
453//-----------------------------------------------------------------------
454static Standard_Integer SeeGeometry(const Standard_Integer IG,const TopOpeBRepDS_Kind TK)
455{
456 if (TK == TopOpeBRepDS_POINT) return SeePoint(IG);
457 else if (TK == TopOpeBRepDS_CURVE) return SeeCurve(IG);
458 else if (TK == TopOpeBRepDS_SURFACE) return SeeSurface(IG);
459 return 0;
460}
461
462//-----------------------------------------------------------------------
463// SeeGeometry
464//-----------------------------------------------------------------------
7fd59977 465static Standard_Integer SeeGeometry(const TopOpeBRepDS_Kind TK)
466{
467 if ( !PHDSD ) return 0;
468
469 const TopOpeBRepDS_DataStructure& BDS = PHDSD->CurrentBDS();
470
7fd59977 471 if (TK == TopOpeBRepDS_POINT) {
472 TopOpeBRepDS_PointExplorer pex(BDS,GFindKeep);
473 for (; pex.More(); pex.Next()) {
474 Standard_Integer ig = pex.Index();
475 SeeGeometry(ig,TK);
476 }
477 }
478 else if (TK == TopOpeBRepDS_CURVE) {
479 TopOpeBRepDS_CurveExplorer cex(BDS,GFindKeep);
480 for (; cex.More(); cex.Next()) {
481 Standard_Integer ig = cex.Index();
482 SeeGeometry(ig,TK);
483 }
484 }
485 else if (TK == TopOpeBRepDS_SURFACE) { //NYI
486 }
487 return 0;
488}
489
490//-----------------------------------------------------------------------
491// TOPOPE_SeeShape
492//-----------------------------------------------------------------------
493Standard_Integer TOPOPE_SeeShape(char* name)
494{
495 TCollection_AsciiString asc = name;
496 Standard_Integer res = SeeShape(asc);
497 return res;
498}
499
500//-----------------------------------------------------------------------
7fd59977 501// suppressarg : remove a[d],modify na--
502//-----------------------------------------------------------------------
1d0a9d4d 503void suppressarg(Standard_Integer& na,const char** a,const Standard_Integer d)
7fd59977 504{
505 for(Standard_Integer i=d;i<na;i++) {
506 a[i]=a[i+1];
507 a[i+1]=NULL;
508 }
509 na--;
510}
511
512//-----------------------------------------------------------------------
513// suppressargs : remove a[*] from <f> to <l>,modify na = na - (l - f)
514//-----------------------------------------------------------------------
515Standard_EXPORT void suppressargs(Standard_Integer& na,const char** a,const Standard_Integer f,const Standard_Integer l)
516{
517 if(l == f)
518 suppressarg(na,a,l);
519 if(l <= f) return;
520 for(Standard_Integer i=0;i<na-l;i++) {
521 a[i+f]=a[i+l+1];
522 a[i+l+1]=NULL;
523 }
524 na -= l-f+1;
525}
526
527//-----------------------------------------------------------------------
7fd59977 528// tsee_flags
529//-----------------------------------------------------------------------
530static void tsee_flags(Standard_Integer& na,const char** a) {
531 GFindKeep = Standard_False;
532 PrintDistancePP = Standard_False;
533 SelectRankShape = 0;
534
535 for (Standard_Integer ia = 1; ia < na; ia++) {
536 if (!strcasecmp(a[ia],"-k")) {
537 suppressarg(na,a,ia);
538 GFindKeep = Standard_True;
539 }
540 else if (!strcasecmp(a[ia],"-d")) {
541 // tsee -d p 4 7 : display p_4,p_7 + tds p 4 7 + calculate distance (p_4,p_7)
542 suppressarg(na,a,ia);
543 PrintDistancePP = Standard_True;
544 }
545 else if (!strcasecmp(a[ia],"-1")) {
546 // tsee -1 s 4 : display s_4 <=> s_4 is subshape of the 1st argument
547 suppressarg(na,a,ia);
548 SelectRankShape = 1;
549 }
550 else if (!strcasecmp(a[ia],"-2")) {
551 // tsee -2 s 4 : display s_4 <=> s_4 is subshape of the 2nd argument
552 suppressarg(na,a,ia);
553 SelectRankShape = 2;
554 }
555 else if (!strcasecmp(a[ia],"-p") && (ia < na-1)) {
556 suppressargs(na,a,ia,ia+1);
91322f44 557 Standard_Real t = Draw::Atof(a[ia+1]);
7fd59977 558 if (t >= 0. && t <= 1.) {
559 OldParFlag = ParFlag; ParFlag = t;
560 }
561 }
562 }
563}
564
565void OthersCommands_help(const char* CommandName,const char* syntaxe = "");
566//-----------------------------------------------------------------------
567// tsee_help
568//-----------------------------------------------------------------------
569static void tsee_help(const char* CommandName, Draw_Interpretor& di)
570{
571 di<<""<<"\n";
572 di<<"tsee : Draw entities of data structure (DS) loaded by TestTopOpe::CurrentDS()."<<"\n";
573 di<<"DS entities are shapes and geometries accessed by a <type> and an <index>."<<"\n";
574 di<<"basic usage :"<<"\n";
575 di<<" tsee <type> <index1 index2 ...>"<<"\n";
576 di<<"<type> = so sh f w e v s for solid/shell/face/wire/edge/vertex/shape"<<"\n";
577 di<<" su cu p for surface/curve/point (N.B : su is NYI)"<<"\n";
578 di<<"<index> = integer"<<"\n";
579 di<<"example : 'tsee e 3' will draw the edge of index 3"<<"\n";
580 di<<" 'tsee e 3 6' will draw the edges of index 3 and 6"<<"\n";
581 di<<" 'tsee e' will draw all the edges."<<"\n";
582 di<<""<<"\n";
583 di<<"Index values of DS entities may be given by the 'tds' command which prints"<<"\n";
584 di<<"the content of the DS for each shape and geometry type."<<"\n";
585 di<<"Entities are drawn with a specific color according to their type."<<"\n";
586 di<<""<<"\n";
587 di<<"Naming : "<<"\n";
588 di<<"'tsee <t> <i>' creates the drawable object named <t>_<i>."<<"\n";
589 di<<"This name is displayed near the entity in one if the forms : "<<"\n";
590 di<<" *<t>_<i> meaning entity belongs to the first shape of current operation."<<"\n";
591 di<<" <t>_<i>* meaning entity belongs to the second shape of current operation."<<"\n";
592 di<<""<<"\n";
593 di<<"Same Domain shapes : "<<"\n";
594 di<<"'tsee <type> sd' to display all shapes of <type> having same domain data."<<"\n";
595 di<<"example : 'tsee e sd' to display all edges sharing a 1d geometric domain"<<"\n";
596 di<<" with other edges."<<"\n";
597 di<<""<<"\n";
598 di<<"Optional flags :"<<"\n";
599 OthersCommands_help(CommandName);
600 di<<"Other types :"<<"\n";
601 di<<"'tsee fev' : displays all faces,then edges,then vertices."<<"\n";
602 di<<"'tsee es <i>' displays edge described as section edge <i>."<<"\n";
603 di<<" The name of a section edge likes t_i<j>,where :"<<"\n";
604 di<<" - i is the edge index in the set of section edge,"<<"\n";
605 di<<" - j is edge index in the DS (as any edge)."<<"\n";
606 di<<""<<"\n";
607}
608
609static void tseei_help(Draw_Interpretor& di)
610{
611 di<<""<<"\n";
612 di<<"tseei : Draws entities of data structure (DS) loaded by TestTopOpe::CurrentDS()."<<"\n";
613 di<<"Draws the objects appearing in interferences DS objects."<<"\n";
614 di<<"See command 'tsee' for discussion about DS objects."<<"\n";
615 di<<"\n";
616}
617
618static void tki_help(Draw_Interpretor& di)
619{
620 di<<""<<"\n";
621 di<<"tki,tkig,tkis : Groups interferences of DS objects"<<"\n";
622 di<<" by geometry (g),or support (s),and index."<<"\n";
623 di<<"See command 'tsee' for discussion about DS objects."<<"\n";
624 di<<"(Test of class TopOpeBRepDS_TKI)"<<"\n";
625 di<<"\n";
626}
627
628static void tds_help(Draw_Interpretor& di)
629{
630 di<<""<<"\n";
631 di<<"tds : dump current DS (loaded by CurrentDS())"<<"\n";
632 di<<"basic usage : tds <-arg> type <index1 index2 ...>"<<"\n";
633 di<<"\n";
634 di<<"Description of curve geometry (type = c) : <-arg> = -t -k -s -l"<<"\n";
635 di<<"\t-k : print only the curve with keep = Standard_True"<<"\n";
636 di<<"\t-l : (long) print all poles and knots for BSplines curves"<<"\n";
637 di<<"\t-s : (short) print only 4 poles and 4 knots for BSplines curves"<<"\n";
638 di<<"on shapes (type = s|so|sh|f|w|e|v) : <-arg> = -ssi"<<"\n";
639 di<<"\t-ssi : print only ShapeShapeInterferences"<<"\n";
640 di<<""<<"\n";
641 di<<"See command 'tsee' for discussion about type and <index1 index2 ...>."<<"\n";
642 di<<"\n";
643}
644
645typedef Standard_Integer (*tf_SeeShape)(const Standard_Integer I,const TopoDS_Shape& S);
1d0a9d4d 646extern void OthersCommands_flags(Standard_Integer& na,const char** a,TestTopOpeDraw_Displayer& TD);
7fd59977 647void COUTNOHDS(Draw_Interpretor& di) {di<<"no current HDS"<<"\n";}
648Standard_Integer tsee_SeeShapefunc(Draw_Interpretor& di,Standard_Integer na_in,const char** a,tf_SeeShape SeeShapefunc)
649{
650 if (na_in == 1 || (na_in == 2 && !strcasecmp(a[1],"-h"))) {
651 tsee_help(a[0], di);
652 return 0;
653 }
654
655 Standard_Integer na = na_in;
656 if ((PHDSD == NULL) || (POCD == NULL)) return 0;
657
658 const Handle(TopOpeBRepDS_HDataStructure)& HDS = PHDSD->CurrentHDS();
659 if (HDS.IsNull()) { COUTNOHDS(di); return 0; }
660 if (na < 2) return 1;
661 const TopOpeBRepDS_DataStructure& BDS = PHDSD->CurrentBDS();
662
663 POCD->InitDisplayer();
664 TolFlag = Standard_False;
665 tsee_flags(na,a);
666 OthersCommands_flags(na,a,*POCD);
667 TolFlag = POCD->TolIs();
668 DisOri = POCD->DisplayGeometry();
669
670 Standard_Integer i1arg = 1;
671 TSEEpar Tpar(a[i1arg]);
672
673// Standard_Integer ia,is,ig;
674 Standard_Integer ia,is;
675
676 if ( PrintDistancePP ) {
677 tsee_entity0 E1,E2;
678 if (na == 4) { // tsee p 3 4
679 if (E1.Set(na,a,i1arg+0,i1arg+1)) return 1;
680 if (E2.Set(na,a,i1arg+0,i1arg+2)) return 1;
681 }
682 else if (na == 5) { // tsee p 3 v 4
683 if (E1.Set(na,a,i1arg+0,i1arg+1)) return 1;
684 if (E2.Set(na,a,i1arg+2,i1arg+3)) return 1;
685 }
686 if (!E1.myEOK || !E2.myEOK) return 1;
687
688 E1.See();E2.See();
689 E1.Dump();E2.Dump();
690 di<<"Distance "<<E1.myEnamedbrep.ToCString()<<" "<<E2.myEnamedbrep.ToCString()<<" : "<<E1.Pnt().Distance(E2.Pnt())<<"\n";
691
692 } // PrintDistancePP
693
694 else if ( Tpar.isshap() ) {
695 // na == 2 : display all DS shapes of type TS
91322f44 696 // na > 2 : display DS shapes of type TS of index Draw::Atoi(a[2]..a[narg-1])
7fd59977 697 if (na == 2 ) {
698 TopOpeBRepDS_Explorer x(HDS,Tpar.TS(),Standard_False);
699 for(;x.More();x.Next()) (*SeeShapefunc)(x.Index(),x.Current());
700 }
701 else {
702 if ( !strcmp(a[i1arg+1],"sd") ) { // shapes HasSameDomain of type TS
703 TopOpeBRepDS_Explorer x(HDS,Tpar.TS(),Standard_False);
704 for (;x.More();x.Next()) {
705 Standard_Boolean isSsd = HDS->HasSameDomain(x.Current());
706 if (isSsd ) (*SeeShapefunc)(x.Index(),x.Current());
707 }
708 }
709 else if (Tpar.isshap() && (Tpar.TS() == TopAbs_EDGE) && (na>=2) && POCD->ParIs()) {
710 // see edges [4..na[ with of the name in t in [0..1] / range
711 if (na == 2) {
712 TopOpeBRepDS_Explorer x(HDS,TopAbs_EDGE,Standard_False);
713 for (;x.More();x.Next()) (*SeeShapefunc)(x.Index(),x.Current());
714 }
715 else {
716 for (ia = i1arg+1; ia < na; ia++) {
91322f44 717 is = Draw::Atoi(a[ia]);
7fd59977 718 (*SeeShapefunc)(is,GetShape(is,Tpar.TS()));
719 }
720 }
721 ParFlag = OldParFlag;
722 }
723 else {
724 for (ia = i1arg+1; ia < na; ia++) {
91322f44 725 is = Draw::Atoi(a[ia]);
7fd59977 726 (*SeeShapefunc)(is,GetShape(is,Tpar.TS()));
727 }
728 }
729 }
730 } // isshap
731
732 else if ( Tpar.isgeom() ) {
733 // na == 2 : display all DS geometries of type TK
91322f44 734 // na > 2 : display DS geometries of type TK index Draw::Atoi(a[2])..a[narg-1])
7fd59977 735 if (na == 2 ) SeeGeometry(Tpar.TK());
91322f44 736 else for (ia = i1arg+1; ia < na; ia++) SeeGeometry(Standard_Integer(Draw::Atoi(a[ia])),Tpar.TK());
7fd59977 737 }
738
739 else if ( Tpar.isafev() ) {
740 // faces then edges then vertices
741 TopOpeBRepDS_Explorer x;
742 for (x.Init(HDS,TopAbs_FACE,Standard_False);x.More();x.Next()) (*SeeShapefunc)(x.Index(),GetShape(x.Index()));
743 for (x.Init(HDS,TopAbs_EDGE,Standard_False);x.More();x.Next()) (*SeeShapefunc)(x.Index(),GetShape(x.Index()));
744 for (x.Init(HDS,TopAbs_VERTEX,Standard_False);x.More();x.Next()) (*SeeShapefunc)(x.Index(),GetShape(x.Index()));
745 }
746
747 else if ( Tpar.isedcu() ) {
748 // na == 2 : display curves of all DS edges
91322f44 749 // na > 2 : display curve of DS edges index Draw::Atoi(a[2])..a[narg-1])
7fd59977 750 if ( na == 2 ) {
751 TopOpeBRepDS_Explorer x(HDS,TopAbs_EDGE,Standard_False);
752 for (;x.More();x.Next()) SeeEdgeCurve(x.Index(),x.Edge());
753 }
754 else {
755 for (ia = i1arg+1; ia < na; ia++) {
91322f44 756 is = Draw::Atoi(a[ia]);
7fd59977 757 SeeEdgeCurve(is,GetShape(is,TopAbs_EDGE));
758 }
759 }
760 }
761
762 else if ( Tpar.issect() ) { // na=2 all section edges,na>2 section edges (a[2]..a[na-1])
763 Standard_Integer ise,nse = BDS.NbSectionEdges();
764 if (na == 2) for (ise = 1; ise<=nse; ise++) SeeSectionEdge(ise);
91322f44 765 else for (ia = i1arg+1; ia<na; ia++) SeeSectionEdge(Draw::Atoi(a[ia]));
7fd59977 766 }
767
768 else if (Tpar.isdege()) {
769 TopOpeBRepDS_Explorer x;
770 for (x.Init(HDS,TopAbs_EDGE);x.More();x.Next()) {
771 if (BRep_Tool::Degenerated(x.Edge())) (*SeeShapefunc)(x.Index(),GetShape(x.Index()));
772 }
773 }
774
775 return 0;
776} // tsee_SeeShapefunc
777
778//-----------------------------------------------------------------------
779// tsee
780//-----------------------------------------------------------------------
781Standard_Integer tsee(Draw_Interpretor& di,Standard_Integer na_in,const char** a)
782{
783 if (na_in == 1 || (na_in == 2 && !strcasecmp(a[1],"-h"))) {
784 tsee_help(a[0],di);
785 return 0;
786 }
787 tf_SeeShape ssf = (tf_SeeShape)SeeShapeIS;
788 Standard_Integer r = tsee_SeeShapefunc(di,na_in,a,ssf);
789 return r;
790} // tsee
791
792//-----------------------------------------------------------------------
793// SeeAnyKI
794//-----------------------------------------------------------------------
795Standard_Integer SeeAnyKI(const TopOpeBRepDS_Kind TK,const Standard_Integer I) {
7fd59977 796 TopAbs_ShapeEnum TS = TopAbs_COMPOUND;
7fd59977 797 Standard_Boolean isshape,isgeome; isshape = isgeome = Standard_False;
798 isshape = TopOpeBRepDS::IsTopology(TK);
799 if (isshape) TS = TopOpeBRepDS::KindToShape(TK);
800 else isgeome = TopOpeBRepDS::IsGeometry(TK);
801 if (isshape) SeeShapeIS(I,GetShape(I,TS));
802 else if (isgeome) SeeGeometry(I,TK);
803 return 0;
804}
805
806//-----------------------------------------------------------------------
807void AddShapeKI
808//-----------------------------------------------------------------------
809(TColStd_ListOfInteger& LOK,TColStd_ListOfInteger& LOI,
810 const TopOpeBRepDS_Kind K,const Standard_Integer I)
811{
7fd59977 812 Standard_Boolean isshape,isgeome; isshape = isgeome = Standard_False;
813 isshape = TopOpeBRepDS::IsTopology(K);
96a95605
DB
814 if (!isshape)
815 isgeome = TopOpeBRepDS::IsGeometry(K);
7fd59977 816
817 if (LOK.IsEmpty() && LOI.IsEmpty()) {
818 LOK.Append((Standard_Integer)K); LOI.Append(I);
819 return;
820 }
821
822 // to sort, it is considered that :
823 // POINT == VERTEX,CURVE == EDGE,SURFACE == FACE
824
7fd59977 825 TopAbs_ShapeEnum SKtri=TopAbs_COMPOUND;
1d47d8d0 826
7fd59977 827 if (isshape) SKtri = TopOpeBRepDS::KindToShape(K);
828 else if (isgeome) {
829 if (K == TopOpeBRepDS_POINT) SKtri = TopAbs_VERTEX;
830 else if (K == TopOpeBRepDS_CURVE) SKtri = TopAbs_EDGE;
831 else if (K == TopOpeBRepDS_SURFACE) SKtri = TopAbs_FACE;
832 }
833 else return;
834
835 TColStd_ListIteratorOfListOfInteger ITLOK(LOK);
836 TColStd_ListIteratorOfListOfInteger ITLOI(LOI);
837 Standard_Boolean equa = Standard_False;
838 for (; ITLOK.More(),ITLOI.More(); ITLOK.Next(),ITLOI.Next()) {
839//JR/Hp
840 Standard_Integer ifK = ITLOK.Value() ;
841 TopOpeBRepDS_Kind fK = (TopOpeBRepDS_Kind) ifK ;
842 TopAbs_ShapeEnum fSK = TopOpeBRepDS::KindToShape(fK);
843// TopOpeBRepDS_Kind fK = (TopOpeBRepDS_Kind)ITLOK.Value(); TopAbs_ShapeEnum fSK = TopOpeBRepDS::KindToShape(fK);
844 Standard_Integer fI = ITLOI.Value();
845 if (SKtri == fSK && I == fI) {
846 equa = Standard_True;
847 break;
848 }
849 if (SKtri <= fSK) {
850 LOK.InsertBefore((Standard_Integer)K,ITLOK);
851 LOI.InsertBefore(I,ITLOI);
852 break;
853 }
854 }
855 if ( !ITLOK.More() && !equa) {
856 LOK.Append((Standard_Integer)K);
857 LOI.Append(I);
858 }
859}
860
861//-----------------------------------------------------------------------
862// SeeShapeISI
863//-----------------------------------------------------------------------
864Standard_Integer SeeShapeISI(const Standard_Integer I,const TopoDS_Shape& S,Draw_Interpretor& di)
865{
866 if ( !PHDSD ) return 0;
867 const Handle(TopOpeBRepDS_HDataStructure)& HDS = PHDSD->CurrentHDS();
868 if (S.IsNull()) return 0;
869 SeeShapeIS(I,S);
870
871 TopOpeBRepDS_Kind SK = TopOpeBRepDS::ShapeToKind(S.ShapeType());
872 const TopOpeBRepDS_DataStructure& BDS = HDS->DS();
873 const TopOpeBRepDS_ListOfInterference& LOI = BDS.ShapeInterferences(S);
874 TopOpeBRepDS_ListIteratorOfListOfInterference ITLOI(LOI);
875 TColStd_ListOfInteger LOKK,LOII;
876
877 for (;ITLOI.More();ITLOI.Next()) {
878 const Handle(TopOpeBRepDS_Interference)& HI = ITLOI.Value();
879 const TopOpeBRepDS_Transition& T = HI->Transition();
880
881 TopAbs_ShapeEnum sb = T.ShapeBefore();TopOpeBRepDS_Kind sbk = TopOpeBRepDS::ShapeToKind(sb);
882 Standard_Integer sbi = T.IndexBefore();
883 TopAbs_ShapeEnum sa = T.ShapeAfter();TopOpeBRepDS_Kind sak = TopOpeBRepDS::ShapeToKind(sa);
884 Standard_Integer sai = T.IndexAfter();
885 TopOpeBRepDS_Kind gk,sk; Standard_Integer gi,si; HI->GKGSKS(gk,gi,sk,si);
886
887 AddShapeKI(LOKK,LOII,sbk,sbi);
888 AddShapeKI(LOKK,LOII,sak,sai);
889 AddShapeKI(LOKK,LOII,gk,gi);
890 AddShapeKI(LOKK,LOII,sk,si);
891 }
892
893 TColStd_ListIteratorOfListOfInteger ITLOKK,ITLOII;
894
895 ITLOKK.Initialize(LOKK); ITLOII.Initialize(LOII);
896 Standard_Boolean ya = ITLOKK.More();
897 TopOpeBRepDS::Print(SK,I,cout,""," : ");
898 for(; ITLOKK.More(),ITLOII.More(); ITLOKK.Next(),ITLOII.Next()) {
899//JR/Hp
900 Standard_Integer ikk = ITLOKK.Value() ;
901 TopOpeBRepDS_Kind kk = (TopOpeBRepDS_Kind) ikk ;
902 Standard_Integer ii = ITLOII.Value();
903// TopOpeBRepDS_Kind kk = (TopOpeBRepDS_Kind)ITLOKK.Value(); Standard_Integer ii = ITLOII.Value();
904 TopOpeBRepDS::Print(kk,ii,cout,""," ");
905 }
906 if (ya) di<<"\n"; else di<<"no shape interference"<<"\n";
907
908 ITLOKK.Initialize(LOKK); ITLOII.Initialize(LOII);
909 for(; ITLOKK.More(),ITLOII.More(); ITLOKK.Next(),ITLOII.Next()) {
910//JR/Hp
911 Standard_Integer ikk =ITLOKK.Value() ;
912 TopOpeBRepDS_Kind kk = (TopOpeBRepDS_Kind) ikk ;
913 Standard_Integer ii = ITLOII.Value();
914// TopOpeBRepDS_Kind kk = (TopOpeBRepDS_Kind)ITLOKK.Value(); Standard_Integer ii = ITLOII.Value();
915 SeeAnyKI(kk,ii);
916 }
917 //POP pour WNT
918 return 0;
919
920} // SeeShapeISI
921
922//-----------------------------------------------------------------------
923// SeeShapeTKIG
924//-----------------------------------------------------------------------
925Standard_Integer SeeShapeTKIG(const Standard_Integer I,const TopoDS_Shape& S)
926{
927 if ( !PHDSD ) return 0;
928 const Handle(TopOpeBRepDS_HDataStructure)& HDS = PHDSD->CurrentHDS();
929 if (S.IsNull()) return 0;
930 SeeShapeIS(I,S);
931
932 TopOpeBRepDS_Kind SK = TopOpeBRepDS::ShapeToKind(S.ShapeType());
933 const TopOpeBRepDS_ListOfInterference& LOI = HDS->DS().ShapeInterferences(S);
934 TopOpeBRepDS_TKI tki;
935 TCollection_AsciiString s1,s2;
936
937 tki.Clear();
938 tki.FillOnGeometry(LOI);
939 s1=TopOpeBRepDS::SPrint(SK,I,""," by G : \n");
940 tki.Init();if (tki.More()) s2="\n";else s2="";
941 tki.DumpTKIIterator(s1,s2);
942
943 return 0;
944} // SeeShapeTKIG
945
946//-----------------------------------------------------------------------
947// SeeShapeTKIS
948//-----------------------------------------------------------------------
949Standard_Integer SeeShapeTKIS(const Standard_Integer I,const TopoDS_Shape& S)
950{
951 if ( !PHDSD ) return 0;
952 const Handle(TopOpeBRepDS_HDataStructure)& HDS = PHDSD->CurrentHDS();
953 if (S.IsNull()) return 0;
954 SeeShapeIS(I,S);
955
956 TopOpeBRepDS_Kind SK = TopOpeBRepDS::ShapeToKind(S.ShapeType());
957 const TopOpeBRepDS_ListOfInterference& LOI = HDS->DS().ShapeInterferences(S);
958 TopOpeBRepDS_TKI tki;
959 TCollection_AsciiString s1,s2;
960
961 tki.Clear();
962 tki.FillOnSupport(LOI);
963 s1=TopOpeBRepDS::SPrint(SK,I,""," by S : \n");
964 tki.Init();if (tki.More()) s2="\n";else s2="";
965 tki.DumpTKIIterator(s1,s2);
966
967 return 0;
968} // SeeShapeTKIS
969
970//-----------------------------------------------------------------------
971// SeeShapeTKI
972//-----------------------------------------------------------------------
973Standard_Integer SeeShapeTKI(const Standard_Integer I,const TopoDS_Shape& S,Draw_Interpretor& di)
974{
975 di<<"\n";
976 SeeShapeTKIG(I,S);
977 SeeShapeTKIS(I,S);
978 return 0;
979} // SeeShapeTKI
980
981//-----------------------------------------------------------------------
982// tseei
983//-----------------------------------------------------------------------
984Standard_Integer tseei(Draw_Interpretor& di,Standard_Integer na_in,const char** a)
985{
986 if (na_in == 1) { tseei_help(di); return 0; }
987 tf_SeeShape ssf = (tf_SeeShape)SeeShapeISI;
988 Standard_Integer r = tsee_SeeShapefunc(di,na_in,a,ssf);
989 return r;
990} // tseei
991
992//-----------------------------------------------------------------------
993// tki
994//-----------------------------------------------------------------------
995Standard_Integer tki(Draw_Interpretor& di,Standard_Integer na_in,const char** a)
996{
997 if (na_in == 1) { tki_help(di); return 0; }
998
999 tf_SeeShape ssf = NULL;
1000 if ( !strcasecmp(a[0],"tki") ) ssf = (tf_SeeShape)SeeShapeTKI;
1001 else if ( !strcasecmp(a[0],"tkig") ) ssf = (tf_SeeShape)SeeShapeTKIG;
1002 else if ( !strcasecmp(a[0],"tkis") ) ssf = (tf_SeeShape)SeeShapeTKIS;
1003 if (ssf == NULL) return 0;
1004
1005 Standard_Integer r = tsee_SeeShapefunc(di,na_in,a,ssf);
1006 return r;
1007} // tki
1008
1009//-----------------------------------------------------------------------
1010// 0 = tds
1011// 1 = kind of DS object to dump = [s] [so sh f w e v] [se] [su c p]
1012// 2,3 ... = [i1,i2 ...] = indices of DS object to see
1013//-----------------------------------------------------------------------
1014Standard_Integer tds(Draw_Interpretor& di,Standard_Integer na,const char** a)
1015{
1016 Standard_Boolean TDSkeep,TDScompact; TDSkeep = TDScompact = Standard_False;
1017 TopOpeBRepDS_GLOBALHDSinterfselector = 0;
1018
1019 Standard_Integer ia ;
1020 for ( ia = 0; ia < na; ia++) {
1021 if (!strcasecmp(a[ia],"-ssi")) {
1022 TopOpeBRepDS_GLOBALHDSinterfselector = 1;
1023 suppressarg(na,a,ia);
1024 continue;
1025 }
1026 else if (!strncmp(a[ia],"-",1)) {
1027 TCollection_AsciiString as = a[ia];
1028 as.Remove(1,1);
1029 for(Standard_Integer i = 1;i <= as.Length(); i++) {
1030 if (as.Value(i) == 'k') TDSkeep = Standard_True;
1031 else if(as.Value(i) == 'l') TDScompact = Standard_False;
1032 else if(as.Value(i) == 's') TDScompact = Standard_True;
1033 else if(as.Value(i) == 'h') { tds_help(di); return 0; }
1034 }
1035 suppressarg(na,a,ia);
1036 }
1037 }
1038
1039 if (PHDSD == NULL) return 0;
1040 const Handle(TopOpeBRepDS_HDataStructure)& HDS = PHDSD->CurrentHDS();
1041 if (HDS.IsNull()) {COUTNOHDS(di);return 0;}
6e6cd5d9 1042 PHDSD->CurrentBDS();
7fd59977 1043
1044 TopOpeBRepDS_Dumper Dumper(HDS);
1045 if ( na == 1 ) { Dumper.Dump(cout,TDSkeep,TDScompact); return 0; }
1046
1047 TDSpar Tpar(a[1]);
1048 Standard_Integer ids;
1049
1050 if (na == 2) {
1051 if (Tpar.isshap()) {
1052 if (Tpar.TS() != TopAbs_SHAPE) Dumper.DumpTopology(Tpar.TK(),cout);
1053 else Dumper.DumpTopology(cout);
1054 }
1055 else if (Tpar.isgeom()) {
1056 Dumper.DumpGeometry(Tpar.TK(),cout,TDSkeep,TDScompact);
1057 }
1058 else if (Tpar.issect()) {
1059 Dumper.DumpSectionEdge(Tpar.TK(),cout);
1060 }
1061 else if (Tpar.isafev()) {
1062 TopOpeBRepDS_Explorer x;
1063 for (x.Init(HDS,TopAbs_FACE,TDSkeep);x.More();x.Next()) Dumper.DumpTopology(x.Type(),x.Index(),cout);
1064 for (x.Init(HDS,TopAbs_EDGE,TDSkeep);x.More();x.Next()) Dumper.DumpTopology(x.Type(),x.Index(),cout);
1065 for (x.Init(HDS,TopAbs_VERTEX,TDSkeep);x.More();x.Next()) Dumper.DumpTopology(x.Type(),x.Index(),cout);
1066 }
1067
1068 else if (Tpar.isdege()) {
1069 TopOpeBRepDS_Explorer x;
1070 for (x.Init(HDS,TopAbs_EDGE,TDSkeep);x.More();x.Next()) {
1071 if (BRep_Tool::Degenerated(x.Edge())) Dumper.DumpTopology(x.Type(),x.Index(),cout);
1072 }
1073 }
1074 return 0;
1075 } // (na == 2)
1076
91322f44 1077 // nna > 2 : dump DS entities of type TK index Draw::Atoi(a[2])..a[narg-1])
7fd59977 1078 for (ia = 2; ia < na; ia++) {
1079
1080 if ( !strcmp(a[ia],"sd") ) { // dump all shapes HasSameDomain of type TS
1081 for (TopOpeBRepDS_Explorer x(HDS,Tpar.TS(),Standard_False);x.More();x.Next()) {
1082 Standard_Boolean isSsd = HDS->HasSameDomain(x.Current());
1083 if (isSsd ) Dumper.DumpTopology(Tpar.TK(),x.Index(),cout);
1084 }
1085 }
1086 else {
91322f44 1087 ids = Draw::Atoi(a[ia]);
7fd59977 1088 if ( Tpar.isshap() ) {
1089 if (Tpar.TS() != TopAbs_SHAPE) Dumper.DumpTopology(Tpar.TK(),ids,cout);
1090 else {
1091 TopAbs_ShapeEnum t = HDS->Shape(ids,SFindKeep).ShapeType();
1092 TopOpeBRepDS_Kind k = TopOpeBRepDS::ShapeToKind(t);
1093 Dumper.DumpTopology(k,ids,cout);
1094 }
1095 }
1096 else if ( Tpar.isgeom() ) {
1097 Dumper.DumpGeometry(Tpar.TK(),ids,cout,TDSkeep,TDScompact);
1098 }
1099 else if ( Tpar.issect() ) {
1100 Dumper.DumpSectionEdge(TopOpeBRepDS_EDGE,ids,cout);
1101 }
1102 }
1103 } // ia < na
1104
1105 return 0;
1106}
1107
1108Standard_Integer TPPE(Draw_Interpretor& di,Standard_Integer na,const char** a)
1109{
1110 if (PHDSD == NULL) return 0;
1111 const Handle(TopOpeBRepDS_HDataStructure)& HDS = PHDSD->CurrentHDS();
1112 if ( HDS.IsNull() ) { COUTNOHDS(di); return 0; }
1113
1114 if (na != 5) return 1;
1115 Standard_Boolean ok = Standard_True;
1116
1117 gp_Pnt pds;
1118 TopoDS_Edge ed;
1119
91322f44 1120 Standard_Integer ip = Draw::Atoi(a[2]);
1121 Standard_Integer ie = Draw::Atoi(a[4]);
7fd59977 1122 ok = ok && (ip >= 1); ok = ok && (ie >= 1);
1123 if (!ok) {
1124 di <<" bad data"<<"\n";
1125 return 1;
1126 }
1127
1128 ok = Standard_False;
1129 if (!strcmp("p",a[1])){
1130 ok = Standard_True;
1131 ok = ok && (ip <= HDS->NbPoints());
1132 if (ok) pds = HDS->Point(ip).Point();
1133 if (!ok) di<<" geometry "<<ip<<" is not a point"<<"\n";
1134 }
1135 if (!strcmp("v",a[1])){
1136 ok = Standard_True;
1137 ok = ok && (ip <= HDS->NbShapes());
1138 if (ok) {
1139 TopoDS_Shape sh = HDS->Shape(ip,SFindKeep);
1140 ok = ok && (sh.ShapeType() == TopAbs_VERTEX);
1141 if (ok) pds =BRep_Tool::Pnt(TopoDS::Vertex(sh));
1142 }
1143 if (!ok) di<<" shape "<<ip<<" is not a vertex"<<"\n";
1144 }
1145 if (!strcmp("e",a[3])){
1146 ok = ok && (ie <= HDS->NbShapes());
1147 if (ok) {
1148 TopoDS_Shape sh = HDS->Shape(ie,SFindKeep);
1149 ok = ok && (sh.ShapeType() == TopAbs_EDGE);
1150 if (ok) ed = TopoDS::Edge(sh);
1151 }
1152 if (!ok) di<<" shape "<<ie<<" is not an edge"<<"\n";
1153
1154 } else ok = Standard_False;
1155
1156 Standard_Real dmin=0;
1157 gp_Pnt pproj;
1158 if (ok) {
1159 Standard_Real f,l;
1160 Handle(Geom_Curve) cu = BRep_Tool::Curve(ed,f,l);
1161 GeomAPI_ProjectPointOnCurve ponc(pds,cu,f,l);
1162 ok = ponc.NbPoints() >= 1;
1163
1164 if (ok) {
1165 dmin = ponc.LowerDistance();
1166 Standard_Real par = ponc.LowerDistanceParameter();
1167 BRepAdaptor_Curve bc(ed);
1168 pproj = bc.Value(par);
1169 }
1170 }
1171
1172 if (ok) {
1173 TCollection_AsciiString pp("p");
1174 pp.AssignCat(ip); pp.AssignCat("e"); pp.AssignCat(ie);
1175 char* ppp = (char *)pp.ToCString();
1176 DrawTrSurf::Set(ppp,pproj);
1177 di<<"dist point "<<ip<<" on edge "<<ie<<" = "<<dmin<<"\n";
1178 } else di<<"projection failed"<<"\n";
1179
1180 return ok;
1181} // TPPE
1182
1183void FUN_ChkIntgInterf(Draw_Interpretor& di) //***Check Integrity Interference
1184{
1185 if ( PHDSD == NULL ) return;
1186 PHDSD->CurrentHDS()->ChkIntg();
1187 di<<"Check interference integrity completed"<<"\n";
1188}
1189
1190void FUN_ChkIntgSamDomain(Draw_Interpretor& di) //***Check Integrity SameDomain
1191{
1192 if ( PHDSD == NULL ) return;
1193 TopOpeBRepDS_Check C(PHDSD->CurrentHDS());
1194 if(C.ChkIntgSamDom())
1195 di<<"Check SameDomain integrity completed"<<"\n";
1196}
1197
1198void FUN_ChkIntg(Draw_Interpretor& di) //***Check Integrity
1199{
1200 if ( PHDSD == NULL ) return;
1201 FUN_ChkIntgInterf(di);
1202 FUN_ChkIntgSamDomain(di);
1203}
1204
1205void FUN_ChkVertex(Draw_Interpretor& di) //***Check Vertex SameDomain
1206{
1207 if ( PHDSD == NULL ) return;
1208 TopOpeBRepDS_Check C(PHDSD->CurrentHDS());
1209 if(C.OneVertexOnPnt())
1210 di<<"Check Structure Vertex SameDomain Complete"<<"\n";
1211}
1212
1213//---------------------------------------------------------
1214Standard_Integer topochk(Draw_Interpretor& di,Standard_Integer na,const char** a)
1215{
1216 if (strcmp(a[0],"topochk")) return 1;
1217
1218 if(na < 2) {
1219 ::FUN_ChkIntg(di);
1220 ::FUN_ChkVertex(di);
1221 }
1222 else if(na > 2) return 1;
1223 else if(!strcmp (a[1],"-i")) ::FUN_ChkIntg(di);
1224 else if(!strncmp(a[1],"-i",2)) {
1225 if (!strcmp(a[1],"-ii")) ::FUN_ChkIntgInterf(di);
1226 else if(!strcmp(a[1],"-isd")) ::FUN_ChkIntgSamDomain(di);
1227 }
1228 else if(!strcmp (a[1],"-s")) ::FUN_ChkVertex(di);
1229 else {
1230 di<<"option : -i = check DS full integrity"<<"\n";
1231 di<<"option : -ii = check only interferences"<<"\n";
1232 di<<"option : -isd = check only SameDomain data"<<"\n"<<"\n";
1233 di<<"option : -s = check only SameDomain data on vertex"<<"\n";
1234 return 1;
1235 }
1236 return 0;
1237}
1238
1239//-----------------------------------------------------------------------
1240// SeeShapeTCX
1241//-----------------------------------------------------------------------
1242Standard_Integer SeeShapeTCX(const Standard_Integer I,const TopoDS_Shape& S)
1243{
1244 if ( !PHDSD ) return 0;
1245 const Handle(TopOpeBRepDS_HDataStructure)& HDS = PHDSD->CurrentHDS();
1246 if (S.IsNull()) return 0;
1247 FDSCNX_Dump(HDS,I);
1248 return 0;
1249} // SeeShapeTCX
1250
1251static void tcx_help(Draw_Interpretor& di)
1252{
1253 di<<"tcx : function not documented"<<"\n";
1254}
1255
1256//-----------------------------------------------------------------------
1257// tcx
1258//-----------------------------------------------------------------------
1259Standard_Integer tcx(Draw_Interpretor& di,Standard_Integer na_in,const char** a)
1260{
1261 if (na_in == 1) { tcx_help(di); return 0; }
1262 Standard_Integer r = tsee_SeeShapefunc(di,na_in,a,SeeShapeTCX);
1263 return r;
1264} // tcx
1265
1266#if 0
1267//---------------------------------------------------------
1268Standard_Integer tcx(Draw_Interpretor& di,Standard_Integer na,const char** a)
1269{
1270 if (PHDSD == NULL) return 0;
1271 const Handle(TopOpeBRepDS_HDataStructure)& HDS = PHDSD->CurrentHDS();
1272 if ( HDS.IsNull() ) { COUTNOHDS(di); return 0; }
1273 if (na == 1) FDSCNX_Dump(HDS);
1274 else if (na == 2) {
91322f44 1275 if (ISINTEGER(a[1])) FDSCNX_Dump(HDS,Draw::Atoi(a[1]));
7fd59977 1276 else
1277 }
1278 return 0;
1279}
1280#endif
1281
1282//-----------------------------------------------------------------------
1283Standard_Integer tdsri(Draw_Interpretor& di,Standard_Integer na_in,const char** a)
1284{
1285 if (na_in == 1 || (na_in == 2 && !strcasecmp(a[1],"-h"))) {
1286 tsee_help(a[0],di);
1287 return 0;
1288 }
1289 Standard_Integer na = na_in;
1290 if ((PHDSD == NULL) || (POCD == NULL)) return 0;
1291 const Handle(TopOpeBRepDS_HDataStructure)& HDS = PHDSD->CurrentHDS();
1292 if (HDS.IsNull()) { COUTNOHDS(di); return 0; }
1293 if (na < 5) return 1;
1294 TopOpeBRepDS_DataStructure& BDS = HDS->ChangeDS();
1295
1296 Standard_Integer i1arg = 1;
1297 TDSpar Tpar(a[i1arg]);
1298
1299 if ( strcasecmp(a[i1arg + 2],"i") ) return 0;
91322f44 1300 Standard_Integer ii = Draw::Atoi(a[i1arg + 3]);
7fd59977 1301// Standard_Integer ia,is,ig;
96a95605 1302 Standard_Integer is;
7fd59977 1303 if ( Tpar.isshap() ) {
91322f44 1304 is = Draw::Atoi(a[i1arg + 1]);
7fd59977 1305 const TopoDS_Shape& s = GetShape(is,Tpar.TS()); if (s.IsNull()) return 0;
1306 TopOpeBRepDS_ListOfInterference& li = BDS.ChangeShapeInterferences(is);
1307 Standard_Integer i=0; TopOpeBRepDS_ListIteratorOfListOfInterference it(li);
1308 while (it.More()) {
1309 if(++i == ii) {
1310 it.Value()->Dump(cout,"\n--> remove ","\n");
1311 li.Remove(it);
1312 }
1313 else it.Next();
1314 }
1315 }
7fd59977 1316 return 0;
1317} // tdsri
1318
1319//=======================================================================
1320//function : DSCommands
1321//purpose :
1322//=======================================================================
1323void TestTopOpe::HDSCommands(Draw_Interpretor& theCommands)
1324{
1325 static Standard_Boolean done = Standard_False;
1326 if (done) return;
1327 done = Standard_True;
1328 PHDSD = (TestTopOpe_HDSDisplayer*) new (TestTopOpe_HDSDisplayer);
1329 POCD = (TestTopOpeDraw_Displayer*) new (TestTopOpeDraw_Displayer);
1330
1331 const char* g = "Topological operation data structure commands";
1332 theCommands.Add("tseei","no args to get help",__FILE__,tseei,g);
1333 theCommands.Add("tsee","no args to get help ",__FILE__,tsee,g);
1334 theCommands.Add("tki","no args to get help ",__FILE__,tki,g);
1335 theCommands.Add("tkig","no args to get help ",__FILE__,tki,g);
1336 theCommands.Add("tkis","no args to get help ",__FILE__,tki,g);
1337 theCommands.Add("tds","-h to get help ",__FILE__,tds,g);
1338 theCommands.Add("tppe","tppe p/v <ip> e <ie>",__FILE__,TPPE);
1339 theCommands.Add("topochk","check current DS (loaded by CurrentDS()",__FILE__,topochk,g);
1340 theCommands.Add("tcx","dump connexity information",__FILE__,tcx,g);
1341 theCommands.Add("tdsri","remove interference : tdsri type itype iinterf",__FILE__,tdsri,g);
1342}