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