Commit | Line | Data |
---|---|---|
b311480e | 1 | // Created on: 1999-04-27 |
2 | // Created by: Andrey BETENEV | |
3 | // Copyright (c) 1999-1999 Matra Datavision | |
4 | // Copyright (c) 1999-2012 OPEN CASCADE SAS | |
5 | // | |
6 | // The content of this file is subject to the Open CASCADE Technology Public | |
7 | // License Version 6.5 (the "License"). You may not use the content of this file | |
8 | // except in compliance with the License. Please obtain a copy of the License | |
9 | // at http://www.opencascade.org and read it completely before using this file. | |
10 | // | |
11 | // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its | |
12 | // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France. | |
13 | // | |
14 | // The Original Code and all software distributed under the License is | |
15 | // distributed on an "AS IS" basis, without warranty of any kind, and the | |
16 | // Initial Developer hereby disclaims all such warranties, including without | |
17 | // limitation, any warranties of merchantability, fitness for a particular | |
18 | // purpose or non-infringement. Please see the License for the specific terms | |
19 | // and conditions governing the rights and limitations under the License. | |
20 | ||
7fd59977 | 21 | // pdn 01.06.99 S4205: handling not-SameRange edges |
22 | // abv 22.07.99 implementing patch indices | |
23 | // svv 10.01.00 porting on DEC | |
24 | ||
25 | #include <ShapeFix_ComposeShell.ixx> | |
26 | ||
27 | #include <Precision.hxx> | |
28 | #include <gp_Pnt2d.hxx> | |
29 | #include <gp_Lin2d.hxx> | |
30 | #include <gp_Dir2d.hxx> | |
31 | ||
32 | #include <TColStd_Array1OfInteger.hxx> | |
33 | #include <TColStd_Array1OfBoolean.hxx> | |
34 | #include <TColStd_Array1OfReal.hxx> | |
35 | #include <TColStd_HArray1OfReal.hxx> | |
36 | #include <TColgp_SequenceOfPnt2d.hxx> | |
37 | #include <TColStd_SequenceOfReal.hxx> | |
38 | ||
39 | #include <IntRes2d_IntersectionSegment.hxx> | |
40 | #include <IntRes2d_IntersectionPoint.hxx> | |
41 | #include <IntRes2d_Domain.hxx> | |
42 | ||
43 | #include <Geom2dInt_GInter.hxx> | |
44 | #include <Geom_Curve.hxx> | |
45 | #include <Geom2d_Line.hxx> | |
46 | #include <Geom2dAdaptor_Curve.hxx> | |
47 | #include <GeomAdaptor_Surface.hxx> | |
48 | ||
49 | #include <TopoDS.hxx> | |
50 | #include <TopoDS_Vertex.hxx> | |
51 | #include <TopoDS_Edge.hxx> | |
52 | #include <TopoDS_Wire.hxx> | |
53 | #include <TopoDS_Shell.hxx> | |
54 | #include <TopoDS_Iterator.hxx> | |
55 | #include <TopTools_MapOfShape.hxx> | |
56 | #include <TopTools_DataMapOfShapeListOfShape.hxx> | |
57 | ||
58 | #include <BRepTools.hxx> | |
59 | #include <Bnd_Box2d.hxx> | |
60 | #include <BndLib_Add2dCurve.hxx> | |
61 | #include <BRepTopAdaptor_FClass2d.hxx> | |
62 | #include <BRep_Tool.hxx> | |
63 | #include <BRep_Builder.hxx> | |
64 | ||
65 | #include <ShapeExtend.hxx> | |
66 | #include <ShapeExtend_WireData.hxx> | |
67 | #include <ShapeBuild_Vertex.hxx> | |
68 | #include <ShapeBuild_Edge.hxx> | |
69 | #include <ShapeAnalysis.hxx> | |
70 | #include <ShapeAnalysis_Edge.hxx> | |
71 | #include <ShapeAnalysis_WireOrder.hxx> | |
72 | #include <ShapeFix_Wire.hxx> | |
73 | #include <ShapeFix_Edge.hxx> | |
74 | #include <ShapeFix_WireSegment.hxx> | |
75 | #include <ShapeAnalysis_Curve.hxx> | |
76 | #include <ShapeBuild_ReShape.hxx> | |
77 | #include <ShapeAnalysis_TransferParametersProj.hxx> | |
78 | #include <ShapeFix_Face.hxx> | |
79 | #include <ShapeAnalysis_Surface.hxx> | |
80 | #include <gp_Pnt.hxx> | |
81 | #include <Extrema_ExtPC2d.hxx> | |
82 | #include <ShapeAnalysis.hxx> | |
83 | ||
84 | //======================================================================= | |
85 | //function : ShapeFix_ComposeShell | |
86 | //purpose : | |
87 | //======================================================================= | |
88 | ||
89 | ShapeFix_ComposeShell::ShapeFix_ComposeShell () : | |
90 | myStatus(0), myClosedMode(Standard_False) | |
91 | { | |
92 | myTransferParamTool = new ShapeAnalysis_TransferParametersProj; | |
93 | } | |
94 | ||
95 | ||
96 | //======================================================================= | |
97 | //function : Init | |
98 | //purpose : | |
99 | //======================================================================= | |
100 | ||
101 | void ShapeFix_ComposeShell::Init (const Handle(ShapeExtend_CompositeSurface) &Grid, | |
102 | const TopLoc_Location& L, | |
103 | const TopoDS_Face &Face, | |
104 | const Standard_Real Prec) | |
105 | { | |
106 | myGrid = Grid; | |
107 | myUClosed = myGrid->IsUClosed(); | |
108 | myVClosed = myGrid->IsVClosed(); | |
109 | myUPeriod = myGrid->UJointValue(myGrid->NbUPatches()+1) - myGrid->UJointValue(1); | |
110 | myVPeriod = myGrid->VJointValue(myGrid->NbVPatches()+1) - myGrid->VJointValue(1); | |
111 | ||
112 | // DTK-CKY 100531 : protection against very thin face | |
113 | // Test "isclosed" should be filtered on the overall (non trimmed) surface, must be closed | |
114 | Handle(Geom_Surface) theSurface = BRep_Tool::Surface(Face,myLoc); | |
115 | Standard_Real U0,U1,V0,V1; | |
116 | theSurface->Bounds(U0,U1,V0,V1); | |
117 | if (myUClosed) { | |
118 | gp_Pnt P0 = theSurface->Value(U0,(V0+V1)/2.); | |
119 | gp_Pnt P1 = theSurface->Value(U1,(V0+V1)/2.); | |
120 | if (P0.Distance(P1) > Precision::Confusion()*10) | |
121 | myUClosed = Standard_False; | |
122 | } | |
123 | if (myVClosed) { | |
124 | gp_Pnt P0 = theSurface->Value((U0+U1)/2.,V0); | |
125 | gp_Pnt P1 = theSurface->Value((U0+U1)/2.,V1); | |
126 | if (P0.Distance(P1) > Precision::Confusion()*10) | |
127 | myVClosed = Standard_False; | |
128 | } | |
129 | // DTK-CKY 100531 end | |
130 | ||
131 | myLoc = L; | |
132 | //smh#8 | |
133 | TopoDS_Shape tmpF = Face.Oriented ( TopAbs_FORWARD ); | |
134 | myFace = TopoDS::Face ( tmpF ); // for correct dealing with seams | |
135 | myOrient = Face.Orientation(); | |
136 | SetPrecision(Prec); | |
137 | myStatus = ShapeExtend::EncodeStatus ( ShapeExtend_OK ); | |
138 | ||
139 | // Compute resolution (checking in 2d is necessary for splitting | |
140 | // degenerated edges and avoiding NotClosed) | |
141 | myUResolution = myVResolution = RealLast(); | |
142 | for ( Standard_Integer i=1; i <= myGrid->NbUPatches(); i++ ) { | |
143 | Standard_Real uRange = myGrid->UJointValue(i+1)-myGrid->UJointValue(i); | |
144 | for ( Standard_Integer j=1; j <= myGrid->NbVPatches(); j++ ) { | |
145 | Standard_Real vRange = myGrid->VJointValue(j+1)-myGrid->VJointValue(j); | |
146 | Standard_Real u1,u2,v1,v2; | |
147 | myGrid->Patch(i,j)->Bounds(u1,u2,v1,v2); | |
148 | GeomAdaptor_Surface GAS ( myGrid->Patch(i,j) ); | |
149 | Standard_Real ures = GAS.UResolution ( 1. )*uRange/(u2-u1); | |
150 | Standard_Real vres = GAS.VResolution ( 1. )*vRange/(v2-v1); | |
151 | if ( ures >0. && myUResolution > ures ) myUResolution = ures; | |
152 | if ( vres >0. && myVResolution > vres ) myVResolution = vres; | |
153 | } | |
154 | } | |
155 | if ( myUResolution == RealLast() ) myUResolution = ::Precision::Parametric ( 1. ); | |
156 | if ( myVResolution == RealLast() ) myVResolution = ::Precision::Parametric ( 1. ); | |
157 | } | |
158 | ||
159 | ||
160 | //======================================================================= | |
161 | //function : Perform | |
162 | //purpose : | |
163 | //======================================================================= | |
164 | ||
165 | Standard_Boolean ShapeFix_ComposeShell::Perform () | |
166 | { | |
167 | myStatus = ShapeExtend::EncodeStatus ( ShapeExtend_OK ); | |
168 | myInvertEdgeStatus = Standard_False; | |
169 | ||
170 | ShapeFix_SequenceOfWireSegment seqw; // working data: wire segments | |
171 | ||
172 | // Init seqw by initial set of wires (with corresponding orientation) | |
173 | LoadWires ( seqw ); | |
174 | if(seqw.Length() == 0) { | |
175 | myStatus = ShapeExtend::EncodeStatus ( ShapeExtend_FAIL6 ); | |
176 | return Standard_False; | |
177 | } | |
178 | ||
179 | // Split edges in the wires by grid and add internal segments of grid (parts of cutting lines) | |
180 | SplitByGrid ( seqw ); | |
181 | ||
182 | // Split all the wires into segments by common vertices (intersections) | |
183 | BreakWires ( seqw ); | |
184 | ||
185 | // Then, collect resulting wires | |
186 | ShapeFix_SequenceOfWireSegment wires; // resulting wires | |
187 | CollectWires ( wires, seqw ); | |
188 | ||
189 | // And construct resulting faces | |
190 | TopTools_SequenceOfShape faces; | |
191 | DispatchWires ( faces, wires ); | |
192 | ||
193 | // Finally, construct resulting shell | |
194 | if ( faces.Length() !=1 ) { | |
195 | TopoDS_Shell S; | |
196 | BRep_Builder B; | |
197 | B.MakeShell ( S ); | |
198 | for ( Standard_Integer i=1; i <= faces.Length(); i++ ) | |
199 | B.Add ( S, faces(i) ); | |
200 | myResult = S; | |
201 | } | |
202 | else myResult = faces(1); | |
203 | myResult.Orientation ( myOrient ); | |
204 | ||
205 | myStatus |= ShapeExtend::EncodeStatus ( ShapeExtend_DONE1 ); | |
206 | return Standard_True; | |
207 | } | |
208 | ||
209 | ||
210 | //======================================================================= | |
211 | //function : SplitEdges | |
212 | //purpose : | |
213 | //======================================================================= | |
214 | ||
215 | void ShapeFix_ComposeShell::SplitEdges () | |
216 | { | |
217 | myStatus = ShapeExtend::EncodeStatus ( ShapeExtend_OK ); | |
218 | ||
219 | ShapeFix_SequenceOfWireSegment seqw; // working data: wire segments | |
220 | ||
221 | // Init seqw by initial set of wires (with corresponding orientation) | |
222 | LoadWires ( seqw ); | |
223 | ||
224 | // Split edges in the wires by grid and add internal segments of grid (parts of cutting lines) | |
225 | SplitByGrid ( seqw ); | |
226 | } | |
227 | ||
228 | ||
229 | //======================================================================= | |
230 | //function : Result | |
231 | //purpose : | |
232 | //======================================================================= | |
233 | ||
234 | const TopoDS_Shape& ShapeFix_ComposeShell::Result () const | |
235 | { | |
236 | return myResult; | |
237 | } | |
238 | ||
239 | ||
240 | //======================================================================= | |
241 | //function : Status | |
242 | //purpose : | |
243 | //======================================================================= | |
244 | ||
245 | Standard_Boolean ShapeFix_ComposeShell::Status (const ShapeExtend_Status status) const | |
246 | { | |
247 | return ShapeExtend::DecodeStatus ( myStatus, status ); | |
248 | } | |
249 | ||
250 | ||
251 | //======================================================================= | |
252 | // PRIVATE (working) METHODS | |
253 | //======================================================================= | |
254 | ||
255 | #define TOLINT 1.e-10 // precision for intersection | |
256 | ||
257 | // Local definitions: characteristics of intersection point | |
258 | ||
259 | #define IOR_UNDEF 0 // undefined side | |
260 | #define IOR_LEFT 1 // to left side of cutting line | |
261 | #define IOR_RIGHT 2 // to right side of cutting line | |
262 | #define IOR_BOTH 3 // crossing | |
263 | #define IOR_POS 4 // in case of cycle on full period, whether first point is right | |
264 | ||
265 | #define ITP_INTER 8 // crossing | |
266 | #define ITP_BEGSEG 16 // start of tangential segment | |
267 | #define ITP_ENDSEG 32 // stop of tangential segment | |
268 | #define ITP_TANG 64 // tangential point | |
269 | ||
270 | ||
271 | //======================================================================= | |
272 | //function : PointLineDeviation | |
273 | //purpose : auxilary | |
274 | //======================================================================= | |
275 | // Return (signed) deviation of point from line | |
276 | static Standard_Real PointLineDeviation (const gp_Pnt2d &p, const gp_Lin2d &line) | |
277 | { | |
278 | gp_Dir2d dir = line.Direction(); | |
279 | gp_Dir2d n ( -dir.Y(), dir.X() ); | |
280 | return n.XY() * ( p.XY() - line.Location().XY() ); | |
281 | } | |
282 | ||
283 | ||
284 | //======================================================================= | |
285 | //function : PointLinePosition | |
286 | //purpose : auxilary | |
287 | //======================================================================= | |
288 | // Define position of point relative to line | |
289 | static Standard_Integer PointLinePosition (const gp_Pnt2d &p, const gp_Lin2d &line, | |
290 | Standard_Real &dev) | |
291 | { | |
292 | dev = PointLineDeviation ( p, line ); | |
293 | return ( dev > TOLINT ? IOR_LEFT : ( dev < -TOLINT ? IOR_RIGHT : IOR_UNDEF ) ); | |
294 | } | |
295 | ||
296 | ||
297 | //======================================================================= | |
298 | //function : PointLinePosition | |
299 | //purpose : auxilary | |
300 | //======================================================================= | |
301 | // Define position of point relative to line | |
302 | static Standard_Integer PointLinePosition (const gp_Pnt2d &p, const gp_Lin2d &line) | |
303 | { | |
304 | Standard_Real dev; | |
305 | return PointLinePosition ( p, line, dev ); | |
306 | } | |
307 | ||
308 | ||
309 | //======================================================================= | |
310 | //function : ParamPointsOnLine | |
311 | //purpose : auxilary | |
312 | //======================================================================= | |
313 | // Compute parameter of point on line | |
314 | static inline Standard_Real ParamPointOnLine (const gp_Pnt2d &p, const gp_Lin2d &line) | |
315 | { | |
316 | return line.Direction().XY() * ( p.XY() - line.Location().XY() ); | |
317 | } | |
318 | ||
319 | ||
320 | //======================================================================= | |
321 | //function : ParamPointsOnLine | |
322 | //purpose : auxilary | |
323 | //======================================================================= | |
324 | // Compute parameter of two points on line (as intersection of segment) | |
325 | static Standard_Real ParamPointsOnLine (const gp_Pnt2d &p1, const gp_Pnt2d &p2, | |
326 | const gp_Lin2d &line) | |
327 | { | |
328 | Standard_Real dist1 = PointLineDeviation ( p1, line ); | |
329 | Standard_Real dist2 = PointLineDeviation ( p2, line ); | |
330 | // in most cases, one of points is on line | |
331 | if ( Abs ( dist1 ) < ::Precision::PConfusion() ) { | |
332 | if ( Abs ( dist2 ) < ::Precision::PConfusion() ) | |
333 | return 0.5 * ( ParamPointOnLine ( p1, line ) + ParamPointOnLine ( p2, line ) ); | |
334 | return ParamPointOnLine ( p1, line ); | |
335 | } | |
336 | if ( Abs ( dist2 ) < ::Precision::PConfusion() ) | |
337 | return ParamPointOnLine ( p2, line ); | |
338 | // just protection | |
339 | if ( dist2 * dist1 >0 ) | |
340 | return 0.5 * ( ParamPointOnLine ( p1, line ) + ParamPointOnLine ( p2, line ) ); | |
341 | // else compute intersection | |
342 | return ( ParamPointOnLine ( p1, line ) * dist2 - | |
343 | ParamPointOnLine ( p2, line ) * dist1 ) / ( dist2 - dist1 ); | |
344 | } | |
345 | ||
346 | ||
347 | //======================================================================= | |
348 | //function : ProjectPointOnLine | |
349 | //purpose : auxilary | |
350 | //======================================================================= | |
351 | // Compute projection of point on line | |
352 | static inline gp_Pnt2d ProjectPointOnLine (const gp_Pnt2d &p, const gp_Lin2d &line) | |
353 | { | |
354 | return line.Location().XY() + line.Direction().XY() * ParamPointOnLine ( p, line ); | |
355 | } | |
356 | ||
357 | ||
358 | //======================================================================= | |
359 | //function : ApplyContext | |
360 | //purpose : auxilary | |
361 | //======================================================================= | |
362 | // Apply context to one edge in the wire and put result into this wire | |
363 | static Standard_Integer ApplyContext (ShapeFix_WireSegment &wire, | |
364 | const Standard_Integer iedge, | |
365 | const Handle(ShapeBuild_ReShape) &context) | |
366 | { | |
367 | TopoDS_Edge edge = wire.Edge ( iedge ); | |
368 | TopoDS_Shape res = context->Apply ( edge ); | |
369 | ||
370 | if ( res.IsSame ( edge ) ) return 1; | |
371 | ||
372 | if ( res.ShapeType() == TopAbs_EDGE ) { | |
373 | wire.SetEdge ( iedge, TopoDS::Edge ( res ) ); | |
374 | return 1; | |
375 | } | |
376 | ||
377 | Standard_Integer index = iedge; | |
378 | ||
379 | Handle(ShapeExtend_WireData) segw = new ShapeExtend_WireData; | |
380 | segw->ManifoldMode() = Standard_False; | |
381 | for ( TopoDS_Iterator it(res); it.More(); it.Next() ) { | |
382 | TopoDS_Edge E = TopoDS::Edge ( it.Value() ); | |
383 | if ( ! E.IsNull() ) segw->Add ( E ); | |
384 | #ifdef DEB | |
385 | else cout << "Error: ShapeFix_ComposeShell, ApplyContext: wrong mapping of edge" << endl; | |
386 | #endif | |
387 | } | |
388 | ||
389 | // add edges into the wire in correct order | |
390 | if ( segw->NbEdges() >0 ) { | |
391 | Standard_Integer ind, iumin, iumax, ivmin, ivmax; | |
392 | wire.GetPatchIndex ( iedge, iumin, iumax, ivmin, ivmax ); | |
393 | Standard_Integer nbEdges = segw->NbEdges(); | |
394 | for ( Standard_Integer i=1; i <= nbEdges; i++, index++ ) { | |
395 | ind = ( edge.Orientation() == TopAbs_FORWARD || edge.Orientation() == TopAbs_INTERNAL ? i : segw->NbEdges()-i+1 ); | |
396 | TopoDS_Edge aE = segw->Edge ( ind ); | |
397 | if ( i==1 ) wire.SetEdge ( index, aE ); | |
398 | else wire.AddEdge ( index, aE, iumin, iumax, ivmin, ivmax ); | |
399 | } | |
400 | } | |
401 | #ifdef DEB | |
402 | else cout << "Warning: ShapeFix_ComposeShell, ApplyContext: edge is to remove - not implemented" << endl; | |
403 | #endif | |
404 | ||
405 | return index - iedge; | |
406 | } | |
407 | ||
408 | ||
409 | //======================================================================= | |
410 | //function : IsCoincided | |
411 | //purpose : auxilary | |
412 | //======================================================================= | |
413 | // check points coincidence | |
414 | static inline Standard_Integer IsCoincided (const gp_Pnt2d &p1, const gp_Pnt2d &p2, | |
415 | const Standard_Real UResolution, | |
416 | const Standard_Real VResolution, | |
417 | const Standard_Real tol) | |
418 | { | |
419 | //pdn Maximal accuracy is working precision of intersector. | |
420 | Standard_Real UTolerance = UResolution * tol; | |
421 | Standard_Real VTolerance = VResolution * tol; | |
422 | return Abs ( p1.X() - p2.X() ) <= Max(TOLINT,UTolerance) && | |
423 | Abs ( p1.Y() - p2.Y() ) <= Max(TOLINT,VTolerance); | |
424 | } | |
425 | ||
426 | ||
427 | //======================================================================= | |
428 | //function : GetPatchIndex | |
429 | //purpose : auxilary | |
430 | //======================================================================= | |
431 | // computes index for the patch by given parameter Param | |
432 | static Standard_Integer GetPatchIndex (const Standard_Real Param, | |
433 | const Handle(TColStd_HArray1OfReal) &Params, | |
434 | const Standard_Boolean isClosed) | |
435 | { | |
436 | Standard_Integer NP = Params->Upper(); | |
437 | Standard_Real period = Params->Value(NP) - Params->Value(1); | |
438 | Standard_Real shift = 0; | |
439 | if ( isClosed ) | |
440 | shift = ShapeAnalysis::AdjustToPeriod ( Param, Params->Value(1), Params->Value(NP) ); | |
441 | Standard_Real p = Param + shift; | |
442 | ||
443 | // locate patch: the same algo as in SE_CS::LocateParameter() | |
444 | Standard_Integer i; // svv #1 | |
445 | for ( i = 2; i < NP; i++ ) { | |
446 | // Standard_Real par = Params->Value(i); | |
447 | if ( p < Params->Value(i) ) break; | |
448 | } | |
449 | i--; | |
450 | ||
451 | Standard_Real ish = shift / period; | |
452 | Standard_Integer ishift = (Standard_Integer)( ish <0 ? ish - 0.5 : ish + 0.5 ); | |
453 | return i - ishift * ( NP - 1 ); | |
454 | } | |
455 | ||
456 | ||
457 | //======================================================================= | |
458 | //function : LoadWires | |
459 | //purpose : | |
460 | //======================================================================= | |
461 | ||
462 | void ShapeFix_ComposeShell::LoadWires (ShapeFix_SequenceOfWireSegment &seqw) const | |
463 | { | |
464 | seqw.Clear(); | |
465 | ||
466 | // Init seqw by initial set of wires (with corresponding orientation) | |
467 | for ( TopoDS_Iterator iw(myFace,Standard_False); iw.More(); iw.Next() ) { | |
468 | //smh#8 | |
469 | TopoDS_Shape tmpW = Context()->Apply ( iw.Value() ) ; | |
470 | if(tmpW.ShapeType() != TopAbs_WIRE) { | |
471 | if(tmpW.ShapeType() == TopAbs_VERTEX) { | |
472 | ShapeFix_WireSegment seg; //(( isOuter ? TopAbs_REVERSED : TopAbs_FORWARD ) ); | |
473 | seg.SetVertex(TopoDS::Vertex(tmpW)); | |
474 | seg.Orientation(tmpW.Orientation()); | |
475 | seqw.Append ( seg ); | |
476 | } | |
477 | continue; | |
478 | } | |
479 | TopoDS_Wire wire = TopoDS::Wire ( tmpW ); | |
480 | ||
481 | Standard_Boolean isNonManifold = ( wire.Orientation() != TopAbs_REVERSED && | |
482 | wire.Orientation() != TopAbs_FORWARD ); | |
483 | ||
484 | ||
485 | ||
486 | // protect against INTERNAL/EXTERNAL wires | |
487 | // if ( wire.Orientation() != TopAbs_REVERSED && | |
488 | // wire.Orientation() != TopAbs_FORWARD ) continue; | |
489 | ||
490 | // determine orientation of the wire | |
491 | // TopoDS_Face face = TopoDS::Face ( myFace.EmptyCopied() ); | |
492 | // B.Add ( face, wire ); | |
493 | // Standard_Boolean isOuter = ShapeAnalysis::IsOuterBound ( face ); | |
494 | ||
495 | if(isNonManifold) { | |
496 | ||
497 | Handle(ShapeExtend_WireData) sbwd = new ShapeExtend_WireData ( wire ,Standard_True,Standard_False); | |
498 | //pdn protection againts of wires w/o edges | |
499 | Standard_Integer nbEdges = sbwd->NbEdges(); | |
500 | if(nbEdges) { | |
501 | ||
502 | //wire segments for non-manifold topology should have INTERNAL orientation | |
503 | ShapeFix_WireSegment seg ( sbwd, TopAbs_INTERNAL); | |
504 | seqw.Append ( seg ); | |
505 | } | |
506 | } | |
507 | else { | |
508 | //splitting wires containing manifold and non-manifold parts on a separate | |
509 | //wire segment | |
510 | ||
511 | Handle(ShapeExtend_WireData) sbwdM = new ShapeExtend_WireData(); | |
512 | Handle(ShapeExtend_WireData) sbwdNM = new ShapeExtend_WireData(); | |
513 | sbwdNM->ManifoldMode() = Standard_False; | |
514 | TopoDS_Iterator aIt(wire); | |
515 | for( ; aIt.More(); aIt.Next()) { | |
516 | TopoDS_Edge E = TopoDS::Edge ( aIt.Value() ); | |
517 | if(E.Orientation() == TopAbs_FORWARD || E.Orientation() == TopAbs_REVERSED) | |
518 | sbwdM->Add(E); | |
519 | else | |
520 | sbwdNM->Add(E); | |
521 | } | |
522 | Standard_Integer nbMEdges = sbwdM->NbEdges(); | |
523 | Standard_Integer nbNMEdges = sbwdNM->NbEdges(); | |
524 | if(nbNMEdges) { | |
525 | ShapeFix_WireSegment seg ( sbwdNM, TopAbs_INTERNAL); //(( isOuter ? TopAbs_REVERSED : TopAbs_FORWARD ) ); | |
526 | seqw.Append ( seg ); | |
527 | } | |
528 | if(nbMEdges) { | |
529 | // Orientation is set so as to allow the segment to be traversed in only one direction | |
530 | // skl 01.04.2002 | |
531 | Handle(ShapeFix_Wire) sfw = new ShapeFix_Wire; | |
532 | sfw->Load ( sbwdM ); | |
533 | Standard_Integer stat=0; | |
534 | Handle(Geom_Surface) gs = BRep_Tool::Surface(myFace); | |
535 | if( gs->IsUPeriodic() && gs->IsVPeriodic() ) { | |
536 | // For torus-like shapes, first reorder in 2d since reorder is indifferent in 3d | |
537 | ShapeAnalysis_WireOrder sawo(Standard_False, 0); | |
538 | ShapeAnalysis_Edge sae; | |
539 | for(Standard_Integer i = 1; i <= nbMEdges; i++) { | |
540 | Standard_Real f,l; | |
541 | Handle(Geom2d_Curve) c2d; | |
542 | //smh#8 | |
543 | TopoDS_Shape tmpF = myFace.Oriented(TopAbs_FORWARD); | |
544 | if(!sae.PCurve(sbwdM->Edge(i),TopoDS::Face(tmpF),c2d,f,l)) | |
545 | continue; | |
546 | sawo.Add(c2d->Value(f).XY(),c2d->Value(l).XY()); | |
547 | } | |
548 | sawo.Perform(); | |
549 | stat = (sawo.Status() < 0 ? -1 : 1); | |
550 | sfw->FixReorder(sawo); | |
551 | } | |
552 | ||
553 | sfw->FixReorder(); | |
554 | if (sfw->StatusReorder(ShapeExtend_DONE3)) | |
555 | stat=-1; | |
556 | ||
557 | if( stat < 0 ) { | |
558 | BRep_Builder B; | |
559 | TopoDS_Shape dummy = myFace.EmptyCopied(); | |
560 | TopoDS_Face face = TopoDS::Face ( dummy ); | |
561 | B.Add ( face, wire ); | |
562 | Standard_Boolean isOuter = ShapeAnalysis::IsOuterBound ( face ); | |
563 | TopoDS_Wire w = sbwdM->Wire(); | |
564 | dummy = myFace.EmptyCopied(); | |
565 | face = TopoDS::Face ( dummy ); | |
566 | B.Add ( face, w ); | |
567 | Standard_Boolean isOuterAfter = ShapeAnalysis::IsOuterBound ( face ); | |
568 | if(isOuter!=isOuterAfter) | |
569 | sbwdM->Reverse(face); | |
570 | } | |
571 | ||
572 | ShapeFix_WireSegment seg ( sbwdM, TopAbs_REVERSED ); //(( isOuter ? TopAbs_REVERSED : TopAbs_FORWARD ) ); | |
573 | seqw.Append ( seg ); | |
574 | } | |
575 | } | |
576 | ||
577 | } | |
578 | } | |
579 | ||
580 | ||
581 | //======================================================================= | |
582 | //function : ComputeCode | |
583 | //purpose : compute code for wire segment between two intersections (by deviation) | |
584 | //======================================================================= | |
585 | ||
586 | Standard_Integer ShapeFix_ComposeShell::ComputeCode (const Handle(ShapeExtend_WireData) &wire, | |
587 | const gp_Lin2d &line, | |
588 | const Standard_Integer begInd, | |
589 | const Standard_Integer endInd, | |
590 | const Standard_Real begPar, | |
591 | const Standard_Real endPar, | |
592 | const Standard_Boolean isInternal) | |
593 | { | |
594 | Standard_Integer code = IOR_UNDEF; | |
595 | ||
596 | ShapeAnalysis_Edge sae; | |
597 | const Standard_Integer NPOINTS = 5; // number of points for measuring deviation | |
598 | ||
599 | // track special closed case: segment starts at end of edge and ends at its beginning | |
600 | Standard_Integer special = ( begInd == endInd && | |
601 | ( wire->Edge(begInd).Orientation() == TopAbs_FORWARD || | |
602 | wire->Edge(begInd).Orientation() == TopAbs_INTERNAL) == | |
603 | ( begPar > endPar ) ? 1 : 0); | |
604 | if ( ! special && begInd == endInd && begPar == endPar && | |
605 | (myClosedMode || isInternal)) | |
606 | special = 1; | |
607 | ||
608 | // for tracking cases in closed mode | |
609 | Standard_Boolean begin=Standard_True; | |
610 | Standard_Real shift=0; | |
611 | gp_Pnt2d p2d0; | |
612 | ||
613 | // check if segment is tangency | |
614 | // Segment is considered as tangency if deviation of pcurve from line | |
615 | // (in 2d) measured by NPOINTS points is less than tolerance of edge | |
616 | // (recomputed to 2d using Resolution). | |
617 | ||
618 | Standard_Integer nb = wire->NbEdges(); | |
619 | ||
620 | Standard_Integer i; // svv #1 | |
621 | for ( i=begInd; ; i++ ) { | |
622 | if ( i > nb ) i = 1; | |
623 | TopoDS_Edge edge = wire->Edge ( i );; | |
624 | ||
625 | Handle(Geom2d_Curve) c2d; | |
626 | Standard_Real f, l; | |
627 | if ( ! sae.PCurve ( edge, myFace, c2d, f, l, Standard_False ) ) { | |
628 | myStatus |= ShapeExtend::EncodeStatus ( ShapeExtend_FAIL3 ); | |
629 | continue; | |
630 | } | |
631 | Standard_Real tol = LimitTolerance(BRep_Tool::Tolerance ( edge )); | |
632 | Standard_Boolean isreversed = ( edge.Orientation() == TopAbs_REVERSED ); | |
633 | ||
634 | Standard_Real par1 = ( i == begInd && special >=0 ? begPar : ( isreversed ? l : f ) ); | |
635 | Standard_Real par2 = ( i == endInd && special <=0 ? endPar : ( isreversed ? f : l ) ); | |
636 | Standard_Real dpar = ( par2 - par1 ) / ( NPOINTS - 1 ); | |
637 | Standard_Integer np = ( Abs ( dpar ) < ::Precision::PConfusion() ? 1 : NPOINTS ); | |
638 | Standard_Integer j; // svv #1 | |
639 | for ( j=0; j < np; j++ ) { | |
640 | Standard_Real par = par1 + dpar * j; | |
641 | gp_Pnt2d p2d = c2d->Value ( par ); | |
642 | if ( myClosedMode ) { | |
643 | if ( myUClosed && Abs ( line.Direction().X() ) < ::Precision::PConfusion() ) { | |
644 | if ( begin ) shift = ShapeAnalysis::AdjustByPeriod ( p2d.X(), line.Location().X(), myUPeriod ); | |
645 | else if ( ! j ) shift = ShapeAnalysis::AdjustByPeriod ( p2d.X()-p2d0.X(), 0., myUPeriod ); | |
646 | p2d.SetX ( p2d.X() + shift ); | |
647 | } | |
648 | if ( myVClosed && Abs ( line.Direction().Y() ) < ::Precision::PConfusion() ) { | |
649 | if ( begin ) shift = ShapeAnalysis::AdjustByPeriod ( p2d.Y(), line.Location().Y(), myVPeriod ); | |
650 | else if ( ! j ) shift = ShapeAnalysis::AdjustByPeriod ( p2d.Y()-p2d0.Y(), 0., myVPeriod ); | |
651 | p2d.SetY ( p2d.Y() + shift ); | |
652 | } | |
653 | begin = Standard_False; | |
654 | } | |
655 | p2d0 = p2d; | |
656 | Standard_Integer pos = PointLinePosition ( p2d, line ); | |
657 | if ( pos == IOR_UNDEF ) continue; | |
658 | ||
659 | // analyse the deviation | |
660 | gp_Pnt2d p2dl = ProjectPointOnLine ( p2d, line ); | |
661 | if(!IsCoincided ( p2d, p2dl, myUResolution, myVResolution, tol )) { | |
662 | if(!myClosedMode) { code = pos; break; } | |
663 | else { | |
664 | code |= pos; | |
665 | } | |
666 | } | |
667 | } | |
668 | if ( j < np ) { i = 0; break; } // not tangency | |
eafb234b | 669 | if ( i == endInd ) { |
7fd59977 | 670 | if ( special <=0 ) break; |
671 | else special = -1; | |
eafb234b | 672 | } |
7fd59977 | 673 | } |
674 | if ( myClosedMode ) { | |
675 | if ( code != IOR_UNDEF && ! begin ) { | |
676 | // in closed mode, if segment is of 2*pi length, it is BOTH | |
677 | Standard_Real dev = PointLineDeviation ( p2d0, line ); | |
678 | if ( myUClosed && Abs ( line.Direction().X() ) < ::Precision::PConfusion() ) { | |
679 | if ( Abs ( Abs ( dev ) - myUPeriod ) < 0.1 * myUPeriod ) { | |
680 | code = IOR_BOTH; | |
681 | if ( dev >0 ) code |= IOR_POS; | |
682 | } | |
683 | else if(code==IOR_BOTH) | |
684 | code=IOR_UNDEF; | |
685 | } | |
686 | if ( myVClosed && Abs ( line.Direction().Y() ) < ::Precision::PConfusion() ) { | |
687 | if ( Abs ( Abs ( dev ) - myVPeriod ) < 0.1 * myVPeriod ) { | |
688 | code = IOR_BOTH; | |
689 | if ( dev >0 ) code |= IOR_POS; | |
690 | } | |
691 | else if(code==IOR_BOTH) | |
692 | code=IOR_UNDEF; | |
693 | } | |
694 | } | |
695 | return code; | |
696 | } | |
697 | if ( i ) code = IOR_UNDEF; // tangency | |
698 | else if ( code == IOR_BOTH ) { // parity error in intersector | |
699 | code = IOR_LEFT; | |
700 | myStatus |= ShapeExtend::EncodeStatus ( ShapeExtend_FAIL2 ); | |
701 | #ifdef DEB | |
702 | cout << "Warning: ShapeFix_ComposeShell::ComputeCode: lost intersection point" << cout; | |
703 | #endif | |
704 | } | |
705 | return code; | |
706 | } | |
707 | ||
708 | ||
709 | //======================================================================= | |
710 | //function : DistributeSplitPoints | |
711 | //purpose : auxilary | |
712 | //======================================================================= | |
713 | // After applying context to (seam) edge, distribute its indices on new edges, | |
714 | // according to their parameters on that edge | |
715 | static void DistributeSplitPoints (const Handle(ShapeExtend_WireData) &sbwd, | |
716 | const TopoDS_Face myFace, | |
717 | const Standard_Integer index, | |
718 | const Standard_Integer nsplit, | |
719 | TColStd_SequenceOfInteger& indexes, | |
720 | const TColStd_SequenceOfReal& values) | |
721 | { | |
722 | Standard_Boolean isreversed = ( nsplit >0 && sbwd->Edge(index).Orientation() == TopAbs_REVERSED ); | |
723 | ||
724 | TColStd_Array1OfReal params(0,nsplit); | |
725 | Standard_Integer i; // svv #1 | |
726 | for ( i=0; i < nsplit; i++ ) { | |
727 | Standard_Real f, l; | |
728 | BRep_Tool::Range ( sbwd->Edge(index+i), myFace, f, l ); | |
729 | params.SetValue ( i, ( isreversed ? l : f ) ); | |
730 | } | |
731 | ||
732 | for ( i=1; i <= indexes.Length() && indexes(i) < index; i++ ); | |
733 | for ( Standard_Integer shift = 1; i <= indexes.Length() && indexes(i) == index; i++ ) { | |
734 | while ( shift < nsplit && isreversed != (Standard_Boolean) ( values(i) > params(shift) ) ) shift++; | |
735 | indexes.SetValue ( i, index + shift - 1 ); | |
736 | } | |
737 | for ( ; i <= indexes.Length(); i++ ) | |
738 | indexes.SetValue ( i, indexes(i) + nsplit - 1 ); | |
739 | } | |
740 | ||
741 | ||
742 | //======================================================================= | |
743 | //function : CheckByCurve3d | |
744 | //purpose : auxilary | |
745 | //======================================================================= | |
746 | static Standard_Integer CheckByCurve3d (const gp_Pnt &pos, | |
747 | const Handle(Geom_Curve) &c3d, | |
748 | const Standard_Real param, | |
749 | const gp_Trsf &T, | |
750 | const Standard_Real tol) | |
751 | { | |
752 | if ( c3d.IsNull() ) return Standard_True; | |
753 | gp_Pnt p = c3d->Value(param); | |
754 | if ( T.Form() != gp_Identity ) p.Transform ( T ); | |
755 | return pos.SquareDistance ( p ) <= tol * tol; | |
756 | } | |
757 | ||
758 | ||
759 | //======================================================================= | |
760 | //function : DefinePatch | |
761 | //purpose : auxilary | |
762 | //======================================================================= | |
763 | static void DefinePatch (ShapeFix_WireSegment &wire, const Standard_Integer code, | |
764 | const Standard_Boolean isCutByU, const Standard_Integer cutIndex, | |
765 | const Standard_Integer number = -1) | |
766 | { | |
767 | Standard_Integer nb = (number > 0 ? number : wire.NbEdges()); | |
768 | if ( isCutByU ) { | |
769 | if ( ! ( code & IOR_LEFT ) ) wire.DefineIUMin ( nb, cutIndex ); | |
770 | if ( ! ( code & IOR_RIGHT ) ) wire.DefineIUMax ( nb, cutIndex ); | |
771 | } | |
772 | else { | |
773 | if ( ! ( code & IOR_RIGHT ) ) wire.DefineIVMin ( nb, cutIndex ); | |
774 | if ( ! ( code & IOR_LEFT ) ) wire.DefineIVMax ( nb, cutIndex ); | |
775 | } | |
776 | } | |
777 | ||
778 | ||
779 | //======================================================================= | |
780 | //function : DefinePatchForWire | |
781 | //purpose : auxilary | |
782 | //======================================================================= | |
783 | static void DefinePatchForWire(ShapeFix_WireSegment &wire, const Standard_Integer code, | |
784 | const Standard_Boolean isCutByU, const Standard_Integer cutIndex) | |
785 | { | |
786 | for(Standard_Integer i = 1; i <= wire.NbEdges(); i++) | |
787 | DefinePatch(wire,code,isCutByU,cutIndex,i); | |
788 | } | |
789 | ||
790 | ||
791 | //======================================================================= | |
792 | //function : GetGridResolution | |
793 | //purpose : auxilary | |
794 | //======================================================================= | |
795 | static Standard_Real GetGridResolution(const Handle(TColStd_HArray1OfReal) SplitValues, | |
796 | const Standard_Integer cutIndex) | |
797 | { | |
798 | Standard_Integer nb = SplitValues->Length(); | |
799 | Standard_Real leftLen = (cutIndex > 1 ? SplitValues->Value(cutIndex) - SplitValues->Value(cutIndex-1) : | |
800 | SplitValues->Value(nb) -SplitValues->Value(nb-1)); | |
801 | Standard_Real rigthLen =(cutIndex < nb ? SplitValues->Value(cutIndex+1)-SplitValues->Value(cutIndex) : | |
802 | SplitValues->Value(2) - SplitValues->Value(1)); | |
803 | return Min(leftLen,rigthLen)/3.; | |
804 | } | |
805 | ||
806 | ||
807 | //======================================================================= | |
808 | //function : SplitWire | |
809 | //purpose : | |
810 | //======================================================================= | |
811 | ||
812 | ShapeFix_WireSegment ShapeFix_ComposeShell::SplitWire (ShapeFix_WireSegment &wire, | |
813 | TColStd_SequenceOfInteger& indexes, | |
814 | const TColStd_SequenceOfReal& values, | |
815 | TopTools_SequenceOfShape& vertices, | |
816 | const TColStd_SequenceOfInteger &SegmentCodes, | |
817 | const Standard_Boolean isCutByU, | |
818 | const Standard_Integer cutIndex) | |
819 | { | |
820 | BRep_Builder B; | |
821 | ShapeFix_WireSegment result; | |
822 | Handle(ShapeAnalysis_Surface) aSurfTool = | |
823 | new ShapeAnalysis_Surface ( BRep_Tool::Surface (myFace) ); | |
824 | Standard_Integer nbSplits = indexes.Length(); | |
825 | ShapeAnalysis_Edge sae; | |
826 | Standard_Integer start = 1; | |
827 | TopAbs_Orientation anWireOrient = wire.Orientation(); | |
828 | gp_Trsf T; | |
829 | if ( ! myLoc.IsIdentity() ) T = myLoc.Inverted().Transformation(); | |
830 | ||
831 | // Processing edge by edge (assuming that split points are sorted along the wire) | |
832 | for ( Standard_Integer i = 1; i <= wire.NbEdges(); i++ ) { | |
833 | ||
834 | // for already splitted seam edge, redistribute its splitting points | |
835 | Standard_Integer nsplit = ApplyContext ( wire, i, Context() ); | |
836 | if ( nsplit !=1 ) { | |
837 | DistributeSplitPoints ( wire.WireData(), myFace, i, nsplit, indexes, values ); | |
838 | if ( nsplit <=0 ) { | |
839 | #ifdef DEB | |
840 | cout << "Error: ShapeFix_ComposeShell::SplitWire: edge dismissed" << endl; | |
841 | #endif | |
842 | i--; | |
843 | continue; | |
844 | } | |
845 | } | |
846 | TopoDS_Edge edge = wire.Edge(i); | |
847 | ||
848 | Standard_Integer iumin, iumax, ivmin, ivmax; | |
849 | wire.GetPatchIndex ( i, iumin, iumax, ivmin, ivmax ); | |
850 | ||
851 | // Position code for first segment of edge | |
852 | Standard_Integer code = SegmentCodes ( start >1 ? start-1 : SegmentCodes.Length() ); | |
853 | ||
854 | // Defining split parameters on edge | |
855 | Standard_Integer stop = start; | |
856 | while ( stop <= nbSplits && indexes(stop) == i ) stop++; | |
857 | if ( stop == start ) { | |
858 | result.AddEdge ( 0, edge, iumin, iumax, ivmin, ivmax ); | |
859 | if(code!=0 || wire.Orientation()!=TopAbs_EXTERNAL) // pdn 0 code handling for extertnal wires | |
860 | DefinePatch ( result, code, isCutByU, cutIndex ); | |
861 | continue; | |
862 | } | |
863 | //find non-manifold vertices on edge | |
864 | TopTools_SequenceOfShape aNMVertices; | |
865 | TopoDS_Iterator aIt(edge,Standard_False); | |
866 | for( ; aIt.More(); aIt.Next()) { | |
867 | if(aIt.Value().Orientation() != TopAbs_FORWARD && | |
868 | aIt.Value().Orientation() != TopAbs_REVERSED) | |
869 | aNMVertices.Append(aIt.Value()); | |
870 | } | |
871 | ||
872 | // Collect data on edge | |
873 | Standard_Real tolEdge = BRep_Tool::Tolerance(edge); | |
874 | Standard_Real tol = LimitTolerance( tolEdge ); | |
875 | TopoDS_Vertex prevV = sae.FirstVertex(edge); | |
876 | TopoDS_Vertex lastV = sae.LastVertex(edge); | |
877 | Standard_Real prevVTol = LimitTolerance( BRep_Tool::Tolerance(prevV) ); | |
878 | Standard_Real lastVTol = LimitTolerance( BRep_Tool::Tolerance(lastV) ); | |
879 | gp_Pnt prevVPnt = BRep_Tool::Pnt(prevV); | |
880 | gp_Pnt lastVPnt = BRep_Tool::Pnt(lastV); | |
881 | if ( T.Form() != gp_Identity ) { | |
882 | prevVPnt.Transform ( T ); | |
883 | lastVPnt.Transform ( T ); | |
884 | } | |
885 | ||
886 | Handle(Geom_Curve) c3d; | |
887 | Standard_Real f3d, l3d; | |
888 | if ( ! sae.Curve3d ( edge, c3d, f3d, l3d ) ) { // not a crime | |
889 | c3d.Nullify(); | |
890 | f3d = l3d = 0; | |
891 | } | |
892 | ||
893 | Standard_Real firstPar, lastPar; | |
894 | Handle(Geom2d_Curve) C2d; | |
895 | if ( ! sae.PCurve ( edge, myFace, C2d, firstPar, lastPar ) ) { | |
896 | myStatus |= ShapeExtend::EncodeStatus ( ShapeExtend_FAIL2 ); | |
897 | } | |
898 | //finding sequence of non-manifold parameters | |
899 | Standard_Integer nbNMVert = aNMVertices.Length(); | |
900 | TColStd_SequenceOfReal aNMVertParams; | |
901 | if( nbNMVert) { | |
902 | Geom2dAdaptor_Curve adc(C2d); | |
903 | ||
904 | Standard_Integer n =1; | |
905 | for( ; n<= nbNMVert; n++) { | |
906 | gp_Pnt apV = BRep_Tool::Pnt(TopoDS::Vertex(aNMVertices.Value(n))); | |
907 | Standard_Real apar =firstPar; | |
908 | Standard_Real adist2 =RealLast(); | |
909 | gp_Pnt aPproj; | |
910 | if(!c3d.IsNull()) { | |
911 | ShapeAnalysis_Curve asae; | |
912 | adist2 = asae.Project(c3d,apV,Precision::Confusion(),aPproj,apar); | |
913 | adist2 *= adist2; | |
914 | } | |
915 | else { | |
916 | ||
917 | gp_Pnt2d aP2d = aSurfTool->ValueOfUV(apV,Precision::Confusion()); | |
918 | Extrema_ExtPC2d aExtr(aP2d,adc); | |
919 | if(aExtr.IsDone() && aExtr.NbExt()) { | |
920 | adist2 = aExtr.SquareDistance(1); | |
921 | Standard_Integer index =1; | |
922 | Standard_Integer k =2; | |
923 | for( ; k <= aExtr.NbExt();k++) { | |
924 | Standard_Real ad2 = aExtr.SquareDistance(k); | |
925 | if( ad2 <adist2) { | |
926 | adist2 = ad2; | |
927 | index =k; | |
928 | } | |
929 | } | |
930 | apar = aExtr.Point(index).Parameter(); | |
931 | ||
932 | } | |
933 | } | |
934 | aNMVertParams.Append(apar); | |
935 | } | |
936 | } | |
937 | ||
938 | //pdn Claculating parametric shift | |
939 | Standard_Boolean sp = (f3d == firstPar && l3d == lastPar); | |
940 | Standard_Real span2d = lastPar - firstPar; | |
941 | // Standard_Real ln2d = lastPar-prevPar; | |
942 | // Standard_Real ln3d = l3d - f3d; | |
943 | // Standard_Real fact = ln2d/ln3d; | |
944 | // Standard_Real shift = prevPar - f3d*fact; | |
945 | Standard_Real prevPar = firstPar; | |
946 | gp_Pnt2d prevPnt2d = C2d->Value(prevPar); | |
947 | gp_Pnt2d lastPnt2d = C2d->Value(lastPar); | |
948 | gp_Pnt prevPnt = myGrid->Value ( prevPnt2d ); | |
949 | gp_Pnt lastPnt = myGrid->Value ( lastPnt2d ); | |
950 | Standard_Boolean isPeriodic = C2d->IsPeriodic(); | |
951 | Standard_Real aPeriod = (isPeriodic ? C2d->Period() :0.); | |
952 | ||
953 | // Splitting edge | |
954 | Standard_Integer NbEdgesStart = result.NbEdges(); | |
955 | Standard_Boolean splitted = Standard_False; | |
956 | Standard_Real currPar=lastPar; //SK | |
957 | for ( Standard_Integer j = start; j <= stop; prevPar = currPar, j++ ) { | |
958 | if ( ! splitted && j >= stop ) { // no splitting at all | |
959 | // code = SegmentCodes ( j >1 ? j-1 : SegmentCodes.Length() ); // classification code | |
960 | break; | |
961 | } | |
962 | currPar = ( j < stop ? values.Value(j) : lastPar ); | |
963 | ||
964 | //fix for case when pcurve is periodic and first parameter of edge is more than 2P | |
965 | //method ShapeBuild_Edge::CopyRanges shift pcurve to range 0-2P and parameters of cutting | |
966 | //should be shifted too. gka SAMTECH 28.07.06 | |
967 | if(isPeriodic ) { | |
968 | if (currPar > (Max(lastPar,firstPar) +Precision::PConfusion()) || | |
969 | currPar < (Min(firstPar,lastPar)- Precision::PConfusion())) { | |
970 | Standard_Real aShift = ShapeAnalysis::AdjustByPeriod(currPar, (firstPar+lastPar)*0.5,aPeriod); | |
971 | currPar+=aShift; | |
972 | } | |
973 | } | |
974 | ||
975 | gp_Pnt2d currPnt2d; | |
976 | gp_Pnt currPnt; | |
977 | ||
978 | // Try to adjust current splitting point to previous or end of edge | |
979 | Standard_Boolean doCut = Standard_True; | |
980 | TopoDS_Vertex V; | |
981 | if ( Abs ( currPar - lastPar ) < ::Precision::PConfusion() ) { | |
982 | V = lastV; | |
983 | doCut = Standard_False; | |
984 | } | |
985 | else if ( Abs ( currPar - prevPar ) < ::Precision::PConfusion() ) { | |
986 | vertices.Append ( prevV ); | |
987 | code = SegmentCodes ( j ); // classification code - update for next segment | |
988 | continue; // no splitting at this point, go to next one | |
989 | } | |
990 | else { | |
991 | currPnt2d = C2d->Value(currPar); | |
992 | currPnt = myGrid->Value ( currPnt2d ); | |
993 | if ( currPnt.Distance ( lastVPnt ) <= lastVTol && | |
994 | lastPnt.Distance ( currPnt ) <= tol && | |
995 | CheckByCurve3d ( lastVPnt, c3d, f3d+(currPar-firstPar)*(l3d-f3d)/span2d, | |
996 | T, lastVTol ) && | |
997 | lastPnt.Distance ( myGrid->Value ( C2d->Value(0.5*(currPar+lastPar)) ) ) <= tol ) { | |
998 | V = lastV; | |
999 | Standard_Real uRes = myUResolution; | |
1000 | Standard_Real vRes = myVResolution; | |
1001 | if(isCutByU) { | |
1002 | Standard_Real gridRes = GetGridResolution(myGrid->UJointValues(),cutIndex)/tol; | |
1003 | uRes = Min(myUResolution,gridRes); | |
1004 | } | |
1005 | else { | |
1006 | Standard_Real gridRes = GetGridResolution(myGrid->VJointValues(),cutIndex)/tol; | |
1007 | vRes = Min(myVResolution,gridRes); | |
1008 | } | |
1009 | if ( IsCoincided ( lastPnt2d, currPnt2d, uRes, vRes, tol ) && | |
1010 | IsCoincided ( lastPnt2d, C2d->Value(0.5*(currPar+lastPar)), | |
1011 | uRes, vRes, tol ) ) doCut = Standard_False; | |
1012 | } | |
1013 | else if ( currPnt.Distance ( prevVPnt ) <= prevVTol && | |
1014 | prevPnt.Distance ( currPnt ) <= tol && | |
1015 | CheckByCurve3d ( prevVPnt, c3d, f3d+(currPar-firstPar)*(l3d-f3d)/span2d, | |
1016 | T, prevVTol ) && | |
1017 | prevPnt.Distance ( myGrid->Value ( C2d->Value(0.5*(currPar+prevPar)) ) ) <= tol ) { | |
1018 | V = prevV; | |
1019 | Standard_Real uRes = myUResolution; | |
1020 | Standard_Real vRes = myVResolution; | |
1021 | if(isCutByU) { | |
1022 | Standard_Real gridRes = GetGridResolution(myGrid->UJointValues(),cutIndex)/tol; | |
1023 | uRes = Min(myUResolution,gridRes); | |
1024 | } | |
1025 | else { | |
1026 | Standard_Real gridRes = GetGridResolution(myGrid->VJointValues(),cutIndex)/tol; | |
1027 | vRes = Min(myVResolution,gridRes); | |
1028 | } | |
1029 | if ( IsCoincided ( prevPnt2d, currPnt2d, uRes, vRes, tol ) && | |
1030 | IsCoincided ( prevPnt2d, C2d->Value(0.5*(currPar+prevPar)), | |
1031 | uRes, vRes, tol ) ) { | |
1032 | vertices.Append ( prevV ); | |
1033 | code = SegmentCodes ( j ); // classification code - update for next segment | |
1034 | continue; // no splitting at this point, go to next one | |
1035 | } | |
1036 | } | |
1037 | //:abv 28.05.02: OCC320 Sample_2: if maxtol = 1e-7, the vertex tolerance | |
1038 | // is actually ignored - protect against new vertex on degenerated edge | |
1039 | else if ( BRep_Tool::Degenerated(edge) && prevV.IsSame(lastV) ) { | |
1040 | V = prevV; | |
1041 | } | |
1042 | } | |
1043 | // classification code for current segment | |
1044 | if ( j > start ) code = SegmentCodes ( j >1 ? j-1 : SegmentCodes.Length() ); | |
1045 | ||
1046 | // if not adjusted, make new vertex | |
1047 | if ( V.IsNull() ) { | |
1048 | B.MakeVertex ( V, currPnt.Transformed(myLoc.Transformation()), tolEdge ); | |
1049 | vertices.Append ( V ); | |
1050 | } | |
1051 | // else adjusted to end, fill all resting vertices | |
1052 | else if ( ! doCut ) { | |
1053 | for ( ; j < stop; j++ ) vertices.Append ( lastV ); | |
1054 | if ( ! splitted ) break; // no splitting at all | |
1055 | currPar = lastPar; | |
1056 | } | |
1057 | else vertices.Append ( V ); | |
1058 | ||
1059 | // When edge is about to be splitted, copy end vertices to protect | |
1060 | // original shape from increasing tolerance after fixing SameParameter | |
1061 | if ( ! splitted ) { | |
1062 | //smh#8 | |
1063 | TopoDS_Shape emptyCopiedfV = prevV.EmptyCopied(); | |
1064 | TopoDS_Vertex fV = TopoDS::Vertex (emptyCopiedfV ); | |
1065 | Context()->Replace ( prevV, fV ); | |
1066 | TopoDS_Vertex lV; | |
1067 | if ( prevV.IsSame ( lastV ) ) { | |
1068 | //smh#8 | |
1069 | TopoDS_Shape tmpV = fV.Oriented ( lastV.Orientation() ) ; | |
1070 | lV = TopoDS::Vertex (tmpV); | |
1071 | } | |
1072 | else { | |
1073 | //smh#8 | |
1074 | TopoDS_Shape emptyCopied = lastV.EmptyCopied(); | |
1075 | lV = TopoDS::Vertex (emptyCopied); | |
1076 | Context()->Replace ( lastV, lV ); | |
1077 | } | |
1078 | if ( V.IsSame ( lastV ) ) V = lV; | |
1079 | else if ( V.IsSame ( prevV ) ) V = fV; | |
1080 | lastV = lV; | |
1081 | prevV = fV; | |
1082 | } | |
1083 | ||
1084 | // Splitting of the edge | |
1085 | splitted = Standard_True; | |
1086 | prevV.Orientation ( TopAbs_FORWARD ); | |
1087 | V.Orientation ( TopAbs_REVERSED ); | |
1088 | ShapeBuild_Edge sbe; | |
1089 | TopoDS_Edge anInitEdge = edge; | |
1090 | Standard_Boolean ismanifold = (edge.Orientation() == TopAbs_FORWARD || | |
1091 | edge.Orientation() == TopAbs_REVERSED); | |
1092 | if(!ismanifold) | |
1093 | anInitEdge.Orientation(TopAbs_FORWARD); | |
1094 | TopoDS_Edge newEdge = sbe.CopyReplaceVertices (anInitEdge, prevV, V ); | |
1095 | ||
1096 | ||
1097 | //addition internal vertices if they exists on edge | |
1098 | Standard_Integer n =1; | |
1099 | for( ; n <= aNMVertParams.Length(); n++) { | |
1100 | Standard_Real apar = aNMVertParams.Value(n); | |
1101 | TopoDS_Vertex aNMVert =TopoDS::Vertex(aNMVertices.Value(n)); | |
1102 | TopoDS_Vertex atmpV = TopoDS::Vertex(Context()->Apply(aNMVert)); | |
1103 | if(fabs(apar - prevPar) <= Precision::PConfusion()) { | |
1104 | Context()->Replace(atmpV,prevV); | |
1105 | aNMVertParams.Remove(n); | |
1106 | aNMVertices.Remove(n); | |
1107 | n--; | |
1108 | } | |
1109 | else if(fabs(apar - currPar) <= Precision::PConfusion()) { | |
1110 | Context()->Replace(atmpV,V); | |
1111 | aNMVertParams.Remove(n); | |
1112 | aNMVertices.Remove(n); | |
1113 | n--; | |
1114 | } | |
1115 | if(apar > prevPar && apar < currPar) { | |
1116 | B.Add(newEdge,atmpV); | |
1117 | aNMVertParams.Remove(n); | |
1118 | aNMVertices.Remove(n); | |
1119 | n--; | |
1120 | } | |
1121 | } | |
1122 | ||
1123 | ||
1124 | sbe.CopyPCurves ( newEdge, anInitEdge ); | |
1125 | ||
1126 | ||
1127 | Handle(ShapeAnalysis_TransferParameters) theTransferParamtool = GetTransferParamTool(); | |
1128 | theTransferParamtool->SetMaxTolerance(MaxTolerance()); | |
1129 | theTransferParamtool->Init(anInitEdge,myFace); | |
1130 | theTransferParamtool->TransferRange(newEdge,prevPar,currPar,Standard_True); | |
1131 | ||
1132 | ||
1133 | if(!ismanifold) { | |
1134 | if(code == IOR_UNDEF) //tangential segment | |
1135 | newEdge.Orientation(TopAbs_EXTERNAL); | |
1136 | else | |
1137 | newEdge.Orientation(edge.Orientation()); | |
1138 | } | |
1139 | ||
1140 | if(!sp && !BRep_Tool::Degenerated(newEdge)) | |
1141 | B.SameRange(newEdge, Standard_False); | |
1142 | //pdn take into account 0 codes (if ext) | |
1143 | if(code == 0 && wire.Orientation()==TopAbs_EXTERNAL){ | |
1144 | code = ( ( isCutByU == (Standard_Boolean)( j == 1 ) ) ? 1 : 2 ); | |
1145 | } | |
1146 | ||
1147 | result.AddEdge ( 0, newEdge, iumin, iumax, ivmin, ivmax ); | |
1148 | DefinePatch ( result, code, isCutByU, cutIndex ); | |
1149 | ||
1150 | // Changing prev parameters | |
1151 | prevV = V; | |
1152 | prevVTol = LimitTolerance( BRep_Tool::Tolerance ( V ) ); | |
1153 | prevVPnt = BRep_Tool::Pnt ( V ); | |
1154 | prevPnt = currPnt; | |
1155 | prevPnt2d = currPnt2d; | |
1156 | } | |
1157 | start = stop; | |
1158 | ||
1159 | if ( splitted ) { | |
1160 | // record replacement in context | |
1161 | // NOTE: order of edges in the replacing wire corresponds to FORWARD orientation of the edge | |
1162 | TopoDS_Wire resWire; | |
1163 | B.MakeWire ( resWire ); | |
1164 | for ( Standard_Integer k=NbEdgesStart; k < result.NbEdges(); k++ ) { | |
1165 | if ( edge.Orientation() == TopAbs_FORWARD || edge.Orientation() == TopAbs_INTERNAL) | |
1166 | B.Add ( resWire, result.Edge(k+1) ); | |
1167 | else B.Add ( resWire, result.Edge(result.NbEdges()-k+NbEdgesStart) ); | |
1168 | } | |
1169 | Context()->Replace ( edge, resWire ); | |
1170 | } | |
1171 | else { | |
1172 | if(anWireOrient == TopAbs_INTERNAL && code ==0) { | |
1173 | ShapeBuild_Edge sbe; | |
1174 | if(edge.Orientation() == TopAbs_INTERNAL) | |
1175 | edge.Orientation(TopAbs_FORWARD); | |
1176 | TopoDS_Edge e1 = sbe.Copy(edge,Standard_False); | |
1177 | Handle(Geom2d_Curve) C2d2 = Handle(Geom2d_Curve)::DownCast(C2d->Copy()); | |
1178 | B.UpdateEdge(e1,C2d,C2d2,myFace,0.); | |
1179 | e1.Orientation(TopAbs_EXTERNAL); | |
1180 | Context()->Replace ( edge,e1); | |
1181 | result.AddEdge ( 0,e1 , iumin, iumax, ivmin, ivmax ); | |
1182 | } | |
1183 | else | |
1184 | result.AddEdge ( 0, edge, iumin, iumax, ivmin, ivmax ); | |
1185 | if(code == 0 && wire.Orientation()==TopAbs_EXTERNAL){ | |
1186 | //pdn defining code for intersection of two isos | |
1187 | code = ( ( isCutByU == (Standard_Boolean)( Abs(firstPar-currPar) < Abs(lastPar-currPar) ) ) ? 2 : 1 ); | |
1188 | } | |
1189 | DefinePatch ( result, code, isCutByU, cutIndex ); | |
1190 | } | |
1191 | } | |
1192 | result.Orientation ( anWireOrient ); | |
1193 | return result; | |
1194 | } | |
1195 | ||
1196 | ||
1197 | //======================================================================= | |
1198 | //function : SplitByLine | |
1199 | //purpose : | |
1200 | //======================================================================= | |
1201 | ||
1202 | Standard_Boolean ShapeFix_ComposeShell::SplitByLine (ShapeFix_WireSegment &wire, | |
1203 | const gp_Lin2d &line, | |
1204 | const Standard_Boolean isCutByU, | |
1205 | const Standard_Integer cutIndex, | |
1206 | TColStd_SequenceOfReal &SplitLinePar, | |
1207 | TColStd_SequenceOfInteger &SplitLineCode, | |
1208 | TopTools_SequenceOfShape &SplitLineVertex) | |
1209 | { | |
1210 | ShapeAnalysis_Edge sae; | |
1211 | // prepare data on cutting line | |
1212 | Handle(Geom2d_Line) jC2d = new Geom2d_Line ( line ); | |
1213 | Geom2dAdaptor_Curve jGAC(jC2d); | |
1214 | ||
1215 | TColStd_SequenceOfInteger IntEdgeInd; // index of intersecting edge | |
1216 | TColStd_SequenceOfReal IntEdgePar; // parameter of intersection point on edge | |
1217 | TColStd_SequenceOfReal IntLinePar; // parameter of intersection point on line | |
1218 | ||
1219 | Standard_Boolean isnonmanifold = (wire.Orientation() == TopAbs_INTERNAL); | |
1220 | //gka correction for non-manifold vertices SAMTECH | |
1221 | if(wire.IsVertex()) { | |
1222 | Handle(ShapeAnalysis_Surface) aSurfTool = new ShapeAnalysis_Surface ( BRep_Tool::Surface (myFace) ); | |
1223 | TopoDS_Vertex aVert = wire.GetVertex(); | |
1224 | gp_Pnt aP3d = BRep_Tool::Pnt(aVert); | |
1225 | gp_Pnt2d aP2d = aSurfTool->ValueOfUV(aP3d,Precision::Confusion()); | |
1226 | Standard_Real dev =0.; | |
1227 | Standard_Integer code = PointLinePosition(aP2d,line,dev); | |
1228 | if(code != IOR_UNDEF) | |
1229 | return Standard_False; | |
1230 | Standard_Real par = ParamPointOnLine (aP2d,line); | |
1231 | SplitLinePar.Append ( par ); | |
1232 | //splitting codes for non-manifold topology should be tangential | |
1233 | SplitLineCode.Append (ITP_TANG); //ITP_INTER); | |
1234 | TopoDS_Vertex aVertNew; | |
1235 | BRep_Builder aB; | |
1236 | aB.MakeVertex(aVertNew,aP3d,BRep_Tool::Tolerance(aVert)); | |
1237 | aVertNew.Orientation(TopAbs_FORWARD); | |
1238 | Context()->Replace(aVert,aVertNew); | |
1239 | SplitLineVertex.Append (aVertNew); | |
1240 | wire.SetVertex(aVertNew); | |
1241 | return Standard_True; | |
1242 | } | |
1243 | const Handle(ShapeExtend_WireData) sewd = wire.WireData(); | |
1244 | ||
1245 | Standard_Integer nbe = sewd->NbEdges(); | |
1246 | ||
1247 | //:abv 31.10.01: for closed mode | |
1248 | Standard_Integer closedDir = 0; | |
1249 | if ( myClosedMode ) { | |
1250 | if ( myUClosed && Abs ( line.Direction().X() ) < ::Precision::PConfusion() ) | |
1251 | closedDir = -1; | |
1252 | else if ( myVClosed && Abs ( line.Direction().Y() ) < ::Precision::PConfusion() ) | |
1253 | closedDir = 1; | |
1254 | } | |
1255 | Standard_Real halfPeriod = 0.5 * ( closedDir ? closedDir <0 ? myUPeriod : myVPeriod : 0. ); | |
1256 | ||
1257 | //============================================ | |
1258 | // make intersections and collect all data on intersection points | |
1259 | Standard_Integer firstCode=0, prevCode=0; | |
1260 | gp_Pnt2d firstPos, prevPos; | |
1261 | Standard_Real firstDev=0., prevDev=0.; | |
1262 | for (Standard_Integer iedge = 1; iedge <= nbe; iedge++) { | |
1263 | ||
1264 | TopoDS_Edge E= sewd->Edge ( iedge ); | |
1265 | Standard_Boolean isreversed = ( E.Orientation() == TopAbs_REVERSED ); | |
1266 | ||
1267 | Standard_Real f, l; | |
1268 | Handle(Geom2d_Curve) c2d; | |
1269 | if ( ! sae.PCurve ( E, myFace, c2d, f, l, Standard_False ) ) continue; | |
1270 | ||
1271 | // get end points | |
1272 | gp_Pnt2d posf = c2d->Value(f), posl = c2d->Value(l); | |
1273 | gp_XY pppf = posf.XY(), pppl = posl.XY(); | |
1274 | ||
1275 | // In case of ClosedMode, adjust curve and end points to period on closed surface | |
1276 | //:abv 16.10.01: Ziegler_CADDY01.sat -18: if pcurve is longer than period, | |
1277 | // ensure processing of all intersections | |
1278 | Standard_Integer nbIter = 1; | |
1279 | gp_Vec2d shiftNext(0.,0.); | |
1280 | if ( myClosedMode ) { | |
1281 | ||
1282 | // get bounding box of pcurve | |
1283 | ShapeAnalysis_Curve sac; | |
1284 | Bnd_Box2d box; | |
1285 | sac.FillBndBox ( c2d, f, l, 11, Standard_True, box ); | |
1286 | Standard_Real umin, vmin, umax, vmax; | |
1287 | box.Get ( umin, vmin, umax, vmax ); | |
1288 | ||
1289 | // compute shifts and adjust points adjust | |
1290 | if ( closedDir < 0 ) { | |
1291 | Standard_Real x = line.Location().X(); | |
1292 | Standard_Real shift = ShapeAnalysis::AdjustToPeriod ( umin, x-myUPeriod, x ); | |
1293 | if ( shift != 0. ) { | |
1294 | c2d = Handle(Geom2d_Curve)::DownCast ( c2d->Copy() ); | |
1295 | gp_Vec2d V ( shift, 0. ); | |
1296 | c2d->Translate ( V ); | |
1297 | pppf.SetX ( pppf.X() + shift ); | |
1298 | pppl.SetX ( pppl.X() + shift ); | |
1299 | } | |
1300 | shiftNext.SetX ( -myUPeriod ); | |
1301 | nbIter = (Standard_Integer)( 1 + Abs ( umax + shift - x ) / myUPeriod ); | |
1302 | shift = ShapeAnalysis::AdjustByPeriod ( posf.X(), x, myUPeriod ); | |
1303 | posf.SetX ( posf.X() + shift ); | |
1304 | shift = ShapeAnalysis::AdjustByPeriod ( posl.X(), x, myUPeriod ); | |
1305 | posl.SetX ( posl.X() + shift ); | |
1306 | } | |
1307 | else if ( closedDir > 0 ) { | |
1308 | Standard_Real y = line.Location().Y(); | |
1309 | Standard_Real shift = ShapeAnalysis::AdjustToPeriod ( vmin, y-myVPeriod, y ); | |
1310 | if ( shift != 0. ) { | |
1311 | c2d = Handle(Geom2d_Curve)::DownCast ( c2d->Copy() ); | |
1312 | gp_Vec2d V ( 0., shift ); | |
1313 | c2d->Translate ( V ); | |
1314 | pppf.SetY ( pppf.Y() + shift ); | |
1315 | pppl.SetY ( pppl.Y() + shift ); | |
1316 | } | |
1317 | shiftNext.SetY ( -myVPeriod ); | |
1318 | nbIter = (Standard_Integer)( 1 + Abs ( umax + shift - y ) / myVPeriod ); | |
1319 | shift = ShapeAnalysis::AdjustByPeriod ( posf.Y(), y, myVPeriod ); | |
1320 | posf.SetY ( posf.Y() + shift ); | |
1321 | shift = ShapeAnalysis::AdjustByPeriod ( posl.Y(), y, myVPeriod ); | |
1322 | posl.SetY ( posl.Y() + shift ); | |
1323 | } | |
1324 | } | |
1325 | ||
1326 | // detect intersections at junction of two edges | |
1327 | gp_Pnt2d pos = ( isreversed ? posl : posf ); | |
1328 | Standard_Real dev; | |
1329 | Standard_Integer code = PointLinePosition ( pos, line, dev ); | |
1330 | if ( iedge ==1 ) { firstCode = code; firstPos = pos; firstDev = dev; } | |
1331 | else if ( code == IOR_UNDEF || code != prevCode ) { | |
1332 | if ( ! closedDir || Abs ( dev - prevDev ) < halfPeriod ) { | |
1333 | IntLinePar.Append ( ParamPointsOnLine ( pos, prevPos, line ) ); // !! - maybe compute exactly ? | |
1334 | IntEdgePar.Append ( isreversed ? l : f ); | |
1335 | IntEdgeInd.Append ( iedge ); | |
1336 | } | |
1337 | } | |
1338 | ||
1339 | // fill data on end point (for next edge) | |
1340 | pos = ( isreversed ? posf : posl ); | |
1341 | prevCode = PointLinePosition ( pos, line, prevDev ); | |
1342 | prevPos = pos; | |
1343 | ||
1344 | // cycle with shift in order to track all possible intersections | |
1345 | for ( Standard_Integer iter=1; iter <= nbIter; iter++ ) { | |
1346 | ||
1347 | // data for intersection | |
1348 | IntRes2d_Domain iDom ( pppf, f, TOLINT, pppl, l, TOLINT ); | |
1349 | Geom2dAdaptor_Curve iGAC(c2d); | |
1350 | ||
1351 | // intersection | |
1352 | Geom2dInt_GInter Inter; | |
1353 | Inter.Perform ( jGAC, /*jDom,*/ iGAC, iDom, TOLINT, TOLINT ); | |
1354 | ||
1355 | // Fill arrays with new intersection points | |
1356 | if ( Inter.IsDone() ) { | |
1357 | ||
1358 | Standard_Integer i; | |
1359 | for ( i = 1; i <= Inter.NbPoints(); i++ ) { | |
1360 | IntRes2d_IntersectionPoint IP = Inter.Point (i); | |
1361 | IntLinePar.Append ( IP.ParamOnFirst() ); | |
1362 | IntEdgePar.Append ( IP.ParamOnSecond() ); | |
1363 | } | |
1364 | for ( i = 1; i <= Inter.NbSegments(); i++ ) { | |
1365 | IntRes2d_IntersectionSegment IS = Inter.Segment (i); | |
1366 | if ( IS.HasFirstPoint() ) { | |
1367 | IntRes2d_IntersectionPoint IP = IS.FirstPoint(); | |
1368 | IntLinePar.Append ( IP.ParamOnFirst() ); | |
1369 | IntEdgePar.Append ( IP.ParamOnSecond() ); | |
1370 | } | |
1371 | if ( IS.HasLastPoint() ) { | |
1372 | IntRes2d_IntersectionPoint IP = IS.LastPoint(); | |
1373 | IntLinePar.Append ( IP.ParamOnFirst() ); | |
1374 | IntEdgePar.Append ( IP.ParamOnSecond() ); | |
1375 | } | |
1376 | } | |
1377 | } | |
1378 | ||
1379 | if ( iter < nbIter ) { | |
1380 | if ( iter == 1 ) c2d = Handle(Geom2d_Curve)::DownCast ( c2d->Copy() ); | |
1381 | pppf += shiftNext.XY(); | |
1382 | pppl += shiftNext.XY(); | |
1383 | c2d->Translate ( shiftNext ); | |
1384 | } | |
1385 | } | |
1386 | ||
1387 | Standard_Integer start = IntEdgeInd.Length() + 1; // first of the new points | |
1388 | ||
1389 | // Move all points into range [f,l] (intersector sometimes gives params out of range) | |
1390 | Standard_Integer i; | |
1391 | for ( i = start; i <= IntEdgePar.Length(); i++ ) { | |
1392 | if ( IntEdgePar(i) < f ) IntEdgePar.SetValue ( i, f ); | |
1393 | else if ( IntEdgePar(i) > l ) IntEdgePar.SetValue ( i, l ); | |
1394 | } | |
1395 | ||
1396 | // Sort by parameter on edge | |
1397 | for ( i = IntEdgePar.Length(); i > start; i-- ) | |
1398 | for ( Standard_Integer j = start; j < i; j++ ) { | |
1399 | if ( isreversed == (Standard_Boolean) ( IntEdgePar(j+1) < IntEdgePar(j) ) ) continue; | |
1400 | IntLinePar.Exchange ( j, j+1 ); | |
1401 | IntEdgePar.Exchange ( j, j+1 ); | |
1402 | } | |
1403 | ||
1404 | // and fill indices | |
1405 | for ( i = start; i <= IntEdgePar.Length(); i++ ) | |
1406 | IntEdgeInd.Append ( iedge ); | |
1407 | ||
1408 | // Detect intersection at closing point | |
1409 | // Only wires which are not EXTERNAL are considered (as closed) | |
1410 | if ( iedge == nbe && wire.Orientation() != TopAbs_EXTERNAL && | |
1411 | wire.Orientation() != TopAbs_INTERNAL && | |
1412 | ( prevCode == IOR_UNDEF || prevCode != firstCode ) ) { | |
1413 | if ( ! closedDir || Abs ( firstDev - prevDev ) < halfPeriod ) { | |
1414 | IntLinePar.Append ( ParamPointsOnLine ( pos, firstPos, line ) ); | |
1415 | IntEdgePar.Append ( isreversed ? f : l ); | |
1416 | IntEdgeInd.Append ( iedge ); | |
1417 | } | |
1418 | } | |
1419 | } | |
1420 | ||
1421 | if ( IntEdgePar.Length() <1 ) { | |
1422 | //pdn Defining position of wire. There is no intersection, so by any point. | |
1423 | DefinePatchForWire ( wire, firstCode, isCutByU, cutIndex ); | |
1424 | return Standard_False; //pdn ?? | |
1425 | } | |
1426 | ||
1427 | //====================================== | |
1428 | // Fill sequence of transition codes for intersection points | |
1429 | TColStd_SequenceOfInteger IntCode; // parameter of intersection point on line | |
1430 | TColStd_SequenceOfInteger SegmentCodes; // classification codes for segments of wire | |
1431 | ||
1432 | // remove duplicated points to ensure correct results of ComputeCode | |
1433 | Standard_Integer i, j = IntEdgePar.Length(); | |
1434 | if ( myClosedMode && j >1 ) { | |
1435 | for ( i = 1; i <= IntEdgePar.Length(); ) { | |
1436 | if ( i == j ) break; | |
1437 | if ( IntEdgeInd(i) == IntEdgeInd(j) && | |
1438 | Abs ( IntEdgePar(i) - IntEdgePar(j) ) < ::Precision::PConfusion() ) { | |
1439 | IntLinePar.Remove(i); | |
1440 | IntEdgePar.Remove(i); | |
1441 | IntEdgeInd.Remove(i); | |
1442 | if ( j >i ) j--; | |
1443 | continue; | |
1444 | } | |
1445 | else if ( nbe ==1 || IntEdgeInd(i) == (IntEdgeInd(j)%nbe)+1 ) { | |
1446 | TopoDS_Edge E1 = sewd->Edge ( IntEdgeInd(j) ); | |
1447 | TopoDS_Edge E2 = sewd->Edge ( IntEdgeInd(i) ); | |
1448 | Standard_Real a1, b1, a2, b2; | |
1449 | BRep_Tool::Range ( E1, myFace, a1, b1 ); | |
1450 | BRep_Tool::Range ( E2, myFace, a2, b2 ); | |
1451 | if ( Abs ( IntEdgePar(j) - ( E1.Orientation() == TopAbs_FORWARD ? b1 : a1 ) ) < ::Precision::PConfusion() && | |
1452 | Abs ( IntEdgePar(i) - ( E2.Orientation() == TopAbs_FORWARD ? a2 : b2 ) ) < ::Precision::PConfusion() ) { | |
1453 | IntLinePar.Remove(i); | |
1454 | IntEdgePar.Remove(i); | |
1455 | IntEdgeInd.Remove(i); | |
1456 | if ( j >i ) j--; | |
1457 | continue; | |
1458 | } | |
1459 | } | |
1460 | j=i++; | |
1461 | } | |
1462 | } | |
1463 | ||
1464 | // Compute segment codes (left side of line, right or tangential) | |
1465 | for ( i=1; i <= IntEdgePar.Length(); i++ ) { | |
1466 | j = ( i < IntEdgePar.Length() ? i + 1 : 1 ); | |
1467 | Standard_Integer code = ComputeCode ( sewd, line, IntEdgeInd(i), IntEdgeInd(j), | |
1468 | IntEdgePar(i), IntEdgePar(j),isnonmanifold ); | |
1469 | SegmentCodes.Append ( code ); | |
1470 | } | |
1471 | ||
1472 | // for EXTERNAL wire, i.e. another joint line, every point is double intersection | |
1473 | if ( wire.Orientation() == TopAbs_EXTERNAL ) { | |
1474 | for ( i=1; i <= IntEdgePar.Length(); i++ ) | |
1475 | IntCode.Append ( ITP_TANG | IOR_BOTH ); | |
1476 | } | |
1477 | // For real (closed) wire, analyze tangencies | |
1478 | else { | |
1479 | if(wire.Orientation() != TopAbs_INTERNAL) { | |
1480 | // Two consecutive tangential segments are considered as one, merge them. | |
1481 | for ( i=1; i <= IntEdgePar.Length(); i++ ) { | |
1482 | j = ( i > 1 ? i-1 : IntEdgePar.Length() ); | |
d30c4db9 SS |
1483 | |
1484 | int k = ( i < IntEdgePar.Length() ? i + 1 : 1 ); // [ACIS22539] | |
1485 | ||
7fd59977 | 1486 | if ( SegmentCodes(j) == IOR_UNDEF && |
d30c4db9 SS |
1487 | SegmentCodes(i) == IOR_UNDEF ) { |
1488 | ||
1489 | // Very specific case when the constructed seam edge | |
1490 | // overlaps with spur edge [ACIS22539] | |
1491 | if (myClosedMode && (IntLinePar(i) - IntLinePar(j)) * (IntLinePar(k) - IntLinePar(i)) <= 0. ) | |
1492 | continue; | |
1493 | ||
1494 | IntEdgeInd.Remove(i); | |
1495 | IntEdgePar.Remove(i); | |
1496 | IntLinePar.Remove(i); | |
1497 | SegmentCodes.Remove(i); | |
1498 | i--; | |
7fd59977 | 1499 | } |
1500 | } | |
1501 | } | |
1502 | //pdn exit if all split points removed | |
1503 | if ( IntEdgePar.Length() <1 ) { | |
1504 | //DefinePatchForWire ( wire, firstCode, isCutByU, cutIndex ); | |
1505 | return Standard_False; //pdn ?? | |
1506 | } | |
1507 | ||
1508 | // Analyze type of intersection point and encode it | |
1509 | // Three kinds of points (ITP): clear intersection, tangency in-point, | |
1510 | // beginning and end of tangential segment. | |
1511 | // Orientation (IOR) tells on which side of line edge crosses it | |
1512 | j = IntEdgePar.Length(); | |
1513 | for ( i=1; i <= IntEdgePar.Length(); j = i++ ) { | |
1514 | Standard_Integer codej = SegmentCodes(j); | |
1515 | Standard_Integer codei = SegmentCodes(i); | |
1516 | if ( myClosedMode ) { | |
1517 | if ( ( codej & IOR_BOTH ) == IOR_BOTH ) //IOR_LEFT : IOR_RIGHT | |
1518 | codej = ( codej & IOR_POS ? IOR_RIGHT : IOR_LEFT ); | |
1519 | if ( ( codei & IOR_BOTH ) == IOR_BOTH ) //IOR_RIGHT : IOR_LEFT | |
1520 | codei = ( codei & IOR_POS ? IOR_LEFT : IOR_RIGHT ); | |
1521 | } | |
1522 | Standard_Integer ipcode = ( codej | codei ); | |
1523 | if ( codej == IOR_UNDEF ) { // previous segment was tangency | |
1524 | if ( IntLinePar(i) > IntLinePar (j) ) | |
1525 | ipcode |= ITP_ENDSEG; // end of segment | |
1526 | else ipcode |= ITP_BEGSEG; // beginning of segment | |
1527 | } | |
1528 | else if ( codei == IOR_UNDEF ) { // current segment is tangency | |
1529 | if ( IntLinePar ( i < IntLinePar.Length() ? i+1 : 1 ) > IntLinePar(i) ) | |
1530 | ipcode |= ITP_BEGSEG; // beginning of segment | |
1531 | else ipcode |= ITP_ENDSEG; // end of segment | |
1532 | } | |
1533 | //internal wire can be only tangent | |
1534 | else if ( i == j ) ipcode |= ( ( ipcode & IOR_BOTH ) == IOR_BOTH && !isnonmanifold ? ITP_INTER : ITP_TANG ); | |
1535 | else if ( codei == codej || isnonmanifold) ipcode |= ITP_TANG; // tangency in-point | |
1536 | else ipcode |= ITP_INTER; // standard crossing | |
1537 | IntCode.Append ( ipcode ); | |
1538 | } | |
1539 | } | |
1540 | ||
1541 | //======================================= | |
1542 | // Split edges in the wire by intersection points and fill vertices array | |
1543 | TopTools_SequenceOfShape IntVertices; | |
1544 | wire = SplitWire ( wire, IntEdgeInd, IntEdgePar, IntVertices, | |
1545 | SegmentCodes, isCutByU, cutIndex ); | |
1546 | ||
1547 | // add all data to input arrays | |
1548 | for ( i=1; i <= IntLinePar.Length(); i++ ) { | |
1549 | SplitLinePar.Append ( IntLinePar(i) ); | |
1550 | SplitLineCode.Append ( IntCode(i) ); | |
1551 | SplitLineVertex.Append ( IntVertices(i) ); | |
1552 | } | |
1553 | ||
1554 | return Standard_True; | |
1555 | } | |
1556 | ||
1557 | ||
1558 | //======================================================================= | |
1559 | //function : SplitByLine | |
1560 | //purpose : | |
1561 | //======================================================================= | |
1562 | ||
1563 | void ShapeFix_ComposeShell::SplitByLine (ShapeFix_SequenceOfWireSegment &wires, | |
1564 | const gp_Lin2d &line, | |
1565 | const Standard_Boolean isCutByU, | |
1566 | const Standard_Integer cutIndex) | |
1567 | { | |
1568 | TColStd_SequenceOfReal SplitLinePar; | |
1569 | TColStd_SequenceOfInteger SplitLineCode; | |
1570 | TopTools_SequenceOfShape SplitLineVertex; | |
1571 | ||
1572 | // split wires one by one, collecting data on intersection points | |
1573 | Standard_Integer i; // svv #1 | |
1574 | for ( i=1; i <= wires.Length(); i++ ) { | |
1575 | SplitByLine ( wires(i), line, isCutByU, cutIndex, | |
1576 | SplitLinePar, SplitLineCode, SplitLineVertex ); | |
1577 | } | |
1578 | ||
1579 | // sort intersection points along parameter on cutting line | |
1580 | for ( i = SplitLinePar.Length(); i >1; i-- ) | |
1581 | for ( Standard_Integer j=1; j < i; j++ ) { | |
1582 | if ( SplitLinePar(j) > SplitLinePar(j+1) ) { | |
1583 | SplitLinePar.Exchange ( j, j+1 ); | |
1584 | SplitLineCode.Exchange ( j, j+1 ); | |
1585 | SplitLineVertex.Exchange ( j, j+1 ); | |
1586 | } | |
1587 | } | |
1588 | ||
1589 | // merge null-length tangential segments into one-point tangencies or intersections | |
1590 | for ( i = 1; i < SplitLinePar.Length(); i++ ) { | |
1591 | if ( Abs ( SplitLinePar(i+1) - SplitLinePar(i) ) > ::Precision::PConfusion() ) continue; | |
1592 | if ( ( SplitLineCode(i) & ITP_ENDSEG && | |
1593 | SplitLineCode(i+1) & ITP_BEGSEG ) || | |
1594 | ( SplitLineCode(i) & ITP_BEGSEG && | |
1595 | SplitLineCode(i+1) & ITP_ENDSEG ) ) { | |
1596 | Standard_Integer code = ( SplitLineCode(i) | SplitLineCode(i+1) ) & IOR_BOTH; | |
1597 | SplitLineCode.SetValue ( i, code | ( code == IOR_BOTH ? ITP_INTER : ITP_TANG ) ); | |
1598 | SplitLinePar.Remove(i+1); | |
1599 | SplitLineCode.Remove(i+1); | |
1600 | SplitLineVertex.Remove(i+1); | |
1601 | } | |
1602 | } | |
1603 | ||
1604 | // go along line, split it by intersection points and create edges | |
1605 | // (only for internal parts, in particular not for tangential segments) | |
1606 | BRep_Builder B; | |
1607 | Standard_Integer parity = 0; // 0 - out, 1 - in | |
1608 | Standard_Integer halfparity = 0; // left/right for tangential segments | |
1609 | Standard_Integer tanglevel = 0; // tangency nesting level | |
1610 | for ( i = 1; i <= SplitLinePar.Length(); i++ ) { | |
1611 | Standard_Integer code = SplitLineCode(i); | |
1612 | Standard_Boolean interior = ( ! tanglevel && parity % 2 ); // create an edge | |
1613 | if ( code & ITP_INTER ) { // crossing | |
1614 | parity++; | |
1615 | } | |
1616 | else if ( code & ITP_BEGSEG ) { // beginning of tangential segment | |
1617 | tanglevel++; | |
1618 | if ( ! halfparity ) halfparity = ( code & IOR_BOTH ); | |
1619 | else if ( halfparity != ( code & IOR_BOTH ) ) parity++; | |
1620 | } | |
1621 | else if ( code & ITP_ENDSEG ) { // end of tangential segment | |
1622 | tanglevel--; | |
1623 | if ( ! halfparity ) halfparity = ( code & IOR_BOTH ); | |
1624 | else if ( halfparity != ( code & IOR_BOTH ) ) parity++; | |
1625 | } | |
1626 | if ( tanglevel <0 ) { | |
1627 | // myStatus |= ShapeExtend::EncodeStatus ( ShapeExtend_FAIL4 ); | |
1628 | #ifdef DEB | |
1629 | cout << "Warning: ShapeFix_ComposeShell::SplitByLine: tangency level <0 !" << endl; | |
1630 | #endif | |
1631 | } | |
1632 | if ( ! interior ) continue; | |
1633 | ||
1634 | // apply context to vertices (to perform replacing/merging vertices) | |
1635 | //smh#8 | |
1636 | TopoDS_Shape tmpV1 = Context()->Apply ( SplitLineVertex(i-1) ); | |
1637 | TopoDS_Shape tmpV2 = Context()->Apply ( SplitLineVertex(i) ); | |
1638 | TopoDS_Vertex V1 = TopoDS::Vertex ( tmpV1 ); | |
1639 | TopoDS_Vertex V2 = TopoDS::Vertex ( tmpV2 ); | |
1640 | // protection against creating null-length edges | |
1641 | if ( SplitLinePar(i) - SplitLinePar(i-1) < ::Precision::PConfusion() ) { | |
1642 | ||
1643 | #ifdef DEB | |
1644 | cout << "Info: ShapeFix_ComposeShell::SplitByLine: Short segment ignored" << endl; | |
1645 | #endif | |
1646 | if ( ! V1.IsSame ( V2 ) ) { // merge coincident vertices | |
1647 | ShapeBuild_Vertex sbv; | |
1648 | TopoDS_Vertex V = sbv.CombineVertex ( V1, V2 ); | |
1649 | Context()->Replace ( V1, V.Oriented ( V1.Orientation() ) ); | |
1650 | Context()->Replace ( V2, V.Oriented ( V2.Orientation() ) ); | |
1651 | V1 = V2 = V; | |
1652 | #ifdef DEB | |
1653 | cout << "Info: ShapeFix_ComposeShell::SplitByLine: Coincided vertices merged" << endl; | |
1654 | #endif | |
1655 | } | |
1656 | continue; | |
1657 | } | |
1658 | ||
1659 | // create an edge (without 3d curve), put it in wire segment and add to sequence | |
1660 | // NOTE: i here is always >1 | |
1661 | TopoDS_Edge edge; | |
1662 | B.MakeEdge ( edge ); | |
1663 | V1.Orientation ( TopAbs_FORWARD ); | |
1664 | V2.Orientation ( TopAbs_REVERSED ); | |
1665 | B.Add ( edge, V1 ); | |
1666 | B.Add ( edge, V2 ); | |
1667 | Handle(Geom2d_Line) Lin1 = new Geom2d_Line ( line ); | |
1668 | Handle(Geom2d_Line) Lin2 = new Geom2d_Line ( line ); | |
1669 | B.UpdateEdge ( edge, Lin1, Lin2, myFace, ::Precision::Confusion() ); | |
1670 | B.Range ( edge, myFace, SplitLinePar(i-1), SplitLinePar(i) ); | |
1671 | ||
1672 | Handle(ShapeExtend_WireData) sbwd = new ShapeExtend_WireData; | |
1673 | sbwd->Add ( edge ); | |
1674 | ShapeFix_WireSegment seg ( sbwd, TopAbs_EXTERNAL ); | |
1675 | ||
1676 | // set patch indices | |
1677 | DefinePatch ( seg, IOR_UNDEF, isCutByU, cutIndex ); | |
1678 | if ( ! isCutByU ) { | |
1679 | seg.DefineIUMin ( 1, GetPatchIndex ( SplitLinePar(i-1)+::Precision::PConfusion(), | |
1680 | myGrid->UJointValues(), myUClosed ) ); | |
1681 | seg.DefineIUMax ( 1, GetPatchIndex ( SplitLinePar(i)-::Precision::PConfusion(), | |
1682 | myGrid->UJointValues(), myUClosed ) + 1 ); | |
1683 | } | |
1684 | else { | |
1685 | seg.DefineIVMin ( 1, GetPatchIndex ( SplitLinePar(i-1)+::Precision::PConfusion(), | |
1686 | myGrid->VJointValues(), myVClosed ) ); | |
1687 | seg.DefineIVMax ( 1, GetPatchIndex ( SplitLinePar(i)-::Precision::PConfusion(), | |
1688 | myGrid->VJointValues(), myVClosed ) + 1 ); | |
1689 | } | |
1690 | ||
1691 | wires.Append ( seg ); | |
1692 | } | |
1693 | if ( parity % 2 ) { | |
1694 | myStatus |= ShapeExtend::EncodeStatus ( ShapeExtend_FAIL4 ); | |
1695 | #ifdef DEB | |
1696 | cout << "Error: ShapeFix_ComposeShell::SplitByLine: parity error" << endl; | |
1697 | #endif | |
1698 | } | |
1699 | ||
1700 | // Apply context to all wires to perform all recorded replacements/merging | |
1701 | for ( i=1; i <= wires.Length(); i++ ) { | |
1702 | for ( Standard_Integer j=1; j <= wires(i).NbEdges(); ) | |
1703 | j += ApplyContext ( wires(i), j, Context() ); | |
1704 | } | |
1705 | } | |
1706 | ||
1707 | ||
1708 | //======================================================================= | |
1709 | //function : SplitByGrid | |
1710 | //purpose : | |
1711 | //======================================================================= | |
1712 | ||
1713 | void ShapeFix_ComposeShell::SplitByGrid (ShapeFix_SequenceOfWireSegment &seqw) | |
1714 | { | |
1715 | // process splitting by U- anv V-seams (i.e. U=const and V=const curves) | |
1716 | // closed composite surface is processed as periodic | |
1717 | Standard_Real Uf,Ul,Vf,Vl; | |
1718 | BRepTools::UVBounds(myFace,Uf,Ul,Vf,Vl); | |
1719 | Standard_Real Umin,Umax,Vmin,Vmax; | |
1720 | myGrid->Bounds(Umin,Umax,Vmin,Vmax); | |
1721 | Standard_Real pprec = ::Precision::PConfusion(); | |
1722 | ||
1723 | // split by u lines | |
1724 | Standard_Integer i; // svv #1 | |
1725 | for ( i = ( myUClosed ? 1 : 2 ); i <= myGrid->NbUPatches(); i++ ) { | |
1726 | gp_Pnt2d pos ( myGrid->UJointValue(i), 0. ); // 0. - for infinite ranges: myGrid->VJointValue(1) ; | |
1727 | gp_Lin2d line ( pos, gp_Dir2d ( 0., 1. ) ); | |
1728 | if ( ! myClosedMode && myUClosed ) { | |
1729 | Standard_Real period = Umax - Umin; | |
1730 | Standard_Real X = pos.X(); | |
1731 | Standard_Real sh = ShapeAnalysis::AdjustToPeriod(X,Uf, Uf+period); | |
1732 | for( ; X+sh <= Ul+pprec; sh += period ) { | |
1733 | gp_Lin2d ln = line.Translated(gp_Vec2d(sh,0)); | |
1734 | Standard_Integer cutIndex = GetPatchIndex ( X+sh+pprec, myGrid->UJointValues(), myUClosed ); | |
1735 | SplitByLine ( seqw, ln, Standard_True, cutIndex ); | |
1736 | } | |
1737 | } | |
1738 | else | |
1739 | SplitByLine ( seqw, line, Standard_True, i ); | |
1740 | } | |
1741 | ||
1742 | // split by v lines | |
1743 | for ( i = ( myVClosed ? 1 : 2 ); i <= myGrid->NbVPatches(); i++ ) { | |
1744 | gp_Pnt2d pos ( 0., myGrid->VJointValue(i) ); | |
1745 | gp_Lin2d line ( pos, gp_Dir2d ( 1., 0. ) ); | |
1746 | if ( ! myClosedMode && myVClosed ) { | |
1747 | Standard_Real period = Vmax - Vmin; | |
1748 | Standard_Real Y = pos.Y(); | |
1749 | Standard_Real sh = ShapeAnalysis::AdjustToPeriod(Y,Vf, Vf+period); | |
1750 | for( ; Y+sh <= Vl+pprec; sh += period) { | |
1751 | gp_Lin2d ln = line.Translated(gp_Vec2d(0,sh)); | |
1752 | Standard_Integer cutIndex = GetPatchIndex ( Y+sh+pprec, myGrid->VJointValues(), myVClosed ); | |
1753 | SplitByLine ( seqw, ln, Standard_False, cutIndex ); | |
1754 | } | |
1755 | } | |
1756 | else | |
1757 | SplitByLine ( seqw, line, Standard_False, i ); | |
1758 | } | |
1759 | ||
1760 | // limit patch indices to be in range of grid (extended for periodic) | |
1761 | Standard_Integer iumin = GetPatchIndex ( Uf+pprec, myGrid->UJointValues(), myUClosed ); | |
1762 | Standard_Integer iumax = GetPatchIndex ( Ul-pprec, myGrid->UJointValues(), myUClosed ) + 1; | |
1763 | for ( i=1; i <= seqw.Length(); i++ ) { | |
1764 | ShapeFix_WireSegment &wire = seqw(i); | |
1765 | for ( Standard_Integer j=1; j <= wire.NbEdges(); j++ ) { | |
1766 | wire.DefineIUMin ( j, iumin ); | |
1767 | wire.DefineIUMax ( j, iumax ); | |
1768 | } | |
1769 | } | |
1770 | Standard_Integer ivmin = GetPatchIndex ( Vf+pprec, myGrid->VJointValues(), myVClosed ); | |
1771 | Standard_Integer ivmax = GetPatchIndex ( Vl-pprec, myGrid->VJointValues(), myVClosed ) + 1; | |
1772 | for ( i=1; i <= seqw.Length(); i++ ) { | |
1773 | ShapeFix_WireSegment &wire = seqw(i); | |
1774 | for ( Standard_Integer j=1; j <= wire.NbEdges(); j++ ) { | |
1775 | wire.DefineIVMin ( j, ivmin ); | |
1776 | wire.DefineIVMax ( j, ivmax ); | |
1777 | } | |
1778 | } | |
1779 | } | |
1780 | ||
1781 | ||
1782 | //======================================================================= | |
1783 | //function : BreakWires | |
1784 | //purpose : | |
1785 | //======================================================================= | |
1786 | ||
1787 | void ShapeFix_ComposeShell::BreakWires (ShapeFix_SequenceOfWireSegment &seqw) | |
1788 | { | |
1789 | ||
1790 | // split all the wires by vertices | |
1791 | TopTools_MapOfShape splitVertices; | |
1792 | ShapeAnalysis_Edge sae; | |
1793 | ||
1794 | // first collect splitting vertices | |
1795 | Standard_Integer i; // svv #1 | |
1796 | for ( i=1; i <= seqw.Length(); i++ ) { | |
1797 | TopAbs_Orientation ori_wire = seqw(i).Orientation(); | |
1798 | if ( ori_wire != TopAbs_EXTERNAL && | |
1799 | ori_wire != TopAbs_INTERNAL) continue; | |
1800 | ||
1801 | Handle(ShapeExtend_WireData) sbwd = seqw(i).WireData(); | |
1802 | for ( Standard_Integer j=1; j <= sbwd->NbEdges(); j++ ) { | |
1803 | TopoDS_Edge edge = sbwd->Edge ( j ); | |
1804 | TopAbs_Orientation ori_edge = (ori_wire == TopAbs_EXTERNAL ? ori_wire : edge.Orientation()); | |
1805 | if(ori_edge == TopAbs_EXTERNAL) { | |
1806 | splitVertices.Add ( sae.FirstVertex ( edge ) ); | |
1807 | splitVertices.Add ( sae.LastVertex ( edge ) ); | |
1808 | } | |
1809 | } | |
1810 | } | |
1811 | ||
1812 | // and then split each vire | |
1813 | // Here each wire is supposed to be connected (while probably not closed) | |
1814 | for ( i=1; i <= seqw.Length(); i++ ) { | |
1815 | TopAbs_Orientation ori = seqw(i).Orientation(); | |
1816 | ShapeFix_WireSegment wire = seqw(i); | |
1817 | if(wire.IsVertex()) | |
1818 | continue; | |
1819 | Handle(ShapeExtend_WireData) sbwd = wire.WireData(); | |
1820 | ||
1821 | // find first vertex for split | |
1822 | Standard_Integer j; // svv #1 | |
1823 | for ( j=1; j <= sbwd->NbEdges(); j++ ) { | |
1824 | TopoDS_Vertex V = sae.FirstVertex ( sbwd->Edge(j) ); | |
1825 | if ( splitVertices.Contains ( V ) ) break; | |
1826 | } | |
1827 | if ( j > sbwd->NbEdges() ) continue; // splitting not needed | |
1828 | ||
1829 | // if first split of closed edge is not its start, make permutation | |
1830 | Standard_Integer shift = 0; | |
1831 | if ( j >1 && ! myClosedMode && wire.IsClosed() ) { | |
1832 | TopoDS_Vertex V = sae.FirstVertex ( sbwd->Edge(1) ); | |
1833 | if ( ! splitVertices.Contains ( V ) ) | |
1834 | shift = j - 1; | |
1835 | // wire.SetLast ( j-1 ); | |
1836 | } | |
1837 | ||
1838 | // perform splitting | |
1839 | Standard_Integer nbnew = 0; | |
1840 | ShapeFix_WireSegment newwire; | |
1841 | TopAbs_Orientation curOri = ori; | |
1842 | for ( Standard_Integer ind=1; ind <= sbwd->NbEdges(); ind++ ) { | |
1843 | j = 1 + ( ind - 1 + shift ) % sbwd->NbEdges(); | |
1844 | TopoDS_Edge edge = sbwd->Edge(j); | |
1845 | TopoDS_Vertex V = sae.FirstVertex ( edge ); | |
1846 | if ( ind==1 || splitVertices.Contains ( V ) ) { | |
1847 | if ( newwire.NbEdges() ) { | |
1848 | newwire.Orientation ( curOri ); | |
1849 | // ShapeFix_WireSegment seg ( newwire, ori ); | |
1850 | seqw.InsertBefore ( i++, newwire ); | |
1851 | nbnew++; | |
1852 | } | |
1853 | newwire.Clear(); | |
1854 | curOri = ori; | |
1855 | } | |
1856 | Standard_Integer iumin, iumax, ivmin, ivmax; | |
1857 | wire.GetPatchIndex ( j, iumin, iumax, ivmin, ivmax ); | |
1858 | if(ori == TopAbs_INTERNAL && edge.Orientation() == TopAbs_EXTERNAL ) { | |
1859 | curOri = TopAbs_EXTERNAL; | |
1860 | edge.Orientation(TopAbs_FORWARD); | |
1861 | nbnew++; | |
1862 | } | |
1863 | ||
1864 | newwire.AddEdge ( 0, edge, iumin, iumax, ivmin, ivmax ); | |
1865 | } | |
1866 | if ( nbnew ) { | |
1867 | newwire.Orientation ( curOri ); | |
1868 | // ShapeFix_WireSegment seg ( newwire, ori ); | |
1869 | seqw.SetValue ( i, newwire ); | |
1870 | } | |
1871 | } | |
1872 | } | |
1873 | ||
1874 | ||
1875 | //======================================================================= | |
1876 | //function : IsShortSegment | |
1877 | //purpose : auxilary | |
1878 | //======================================================================= | |
1879 | // BUC60035 2053: check if wire segment is very short (in order not to skip it) | |
1880 | // 0 - long | |
1881 | // 1 - short even in 2d (to be taken always) | |
1882 | // -1 - short in 3d but not in 2d (to be checked after algo and atteching to | |
1883 | // another wire if alone) | |
1884 | static Standard_Integer IsShortSegment (const ShapeFix_WireSegment &seg, | |
1885 | const TopoDS_Face myFace, | |
1886 | const Handle(Geom_Surface)& myGrid, | |
1887 | const TopLoc_Location &myLoc, | |
1888 | const Standard_Real UResolution, | |
1889 | const Standard_Real VResolution) | |
1890 | { | |
1891 | TopoDS_Vertex Vf = seg.FirstVertex(); | |
1892 | if ( ! Vf.IsSame ( seg.LastVertex() ) ) return Standard_False; | |
1893 | ||
1894 | gp_Pnt pnt = BRep_Tool::Pnt(Vf); | |
1895 | Standard_Real tol = BRep_Tool::Tolerance(Vf); | |
1896 | Standard_Real tol2 = tol*tol; | |
1897 | ||
1898 | Standard_Integer code = 1; | |
1899 | ShapeAnalysis_Edge sae; | |
1900 | Handle(ShapeExtend_WireData) sbwd = seg.WireData(); | |
1901 | for ( Standard_Integer i=1; i <= sbwd->NbEdges(); i++ ) { | |
1902 | TopoDS_Edge edge = sbwd->Edge ( i ); | |
1903 | if ( ! Vf.IsSame ( sae.LastVertex ( edge ) ) ) return Standard_False; | |
1904 | Handle(Geom2d_Curve) c2d; | |
1905 | Standard_Real f, l; | |
1906 | if ( ! sae.PCurve ( edge, myFace, c2d, f, l ) ) continue; | |
1907 | ||
1908 | // check 2d | |
1909 | gp_Pnt2d endPnt = c2d->Value(l); | |
1910 | gp_Pnt2d midPnt = c2d->Value((f+l)/2); | |
1911 | if ( ! IsCoincided ( endPnt, midPnt, UResolution, VResolution, tol ) ) code = -1; | |
1912 | ||
1913 | // check 3d | |
1914 | gp_Pnt midPnt3d = myGrid->Value(midPnt.X(),midPnt.Y()); | |
1915 | if ( ! myLoc.IsIdentity() ) midPnt3d.Transform ( myLoc.Transformation() ); | |
1916 | if ( midPnt3d.SquareDistance(pnt) > tol2) return 0; | |
1917 | } | |
1918 | return code; | |
1919 | } | |
1920 | ||
1921 | ||
1922 | //======================================================================= | |
1923 | //function : IsSamePatch | |
1924 | //purpose : auxilary | |
1925 | //======================================================================= | |
1926 | static Standard_Boolean IsSamePatch (const ShapeFix_WireSegment wire, | |
1927 | const Standard_Integer NU, | |
1928 | const Standard_Integer NV, | |
1929 | Standard_Integer &iumin, | |
1930 | Standard_Integer &iumax, | |
1931 | Standard_Integer &ivmin, | |
1932 | Standard_Integer &ivmax, | |
1933 | const Standard_Boolean extend=Standard_False) | |
1934 | { | |
1935 | // get patch indices for current segment | |
1936 | Standard_Integer jumin, jumax, jvmin, jvmax; | |
1937 | wire.GetPatchIndex ( 1, jumin, jumax, jvmin, jvmax ); | |
1938 | ||
1939 | // shift to the same period | |
1940 | Standard_Integer du=0, dv=0; | |
1941 | if ( jumin - iumin > NU ) du =-( jumin - iumin ) / NU; | |
1942 | else if ( iumin - jumin > NU ) du = ( iumin - jumin ) / NU; | |
1943 | if ( jvmin - ivmin > NV ) dv =-( jvmin - ivmin ) / NV; | |
1944 | else if ( ivmin - jvmin > NV ) dv = ( ivmin - jvmin ) / NV; | |
1945 | if ( du ) { jumin += du * NU; jumax += du * NU; } | |
1946 | if ( dv ) { jvmin += dv * NV; jvmax += dv * NV; } | |
1947 | ||
1948 | // compute common (extended) indices | |
1949 | Standard_Integer iun = Min ( iumin, jumin ); | |
1950 | Standard_Integer iux = Max ( iumax, jumax ); | |
1951 | Standard_Integer ivn = Min ( ivmin, jvmin ); | |
1952 | Standard_Integer ivx = Max ( ivmax, jvmax ); | |
1953 | Standard_Boolean ok = ( iun == iux || iun+1 == iux ) && | |
1954 | ( ivn == ivx || ivn+1 == ivx ); | |
1955 | if ( ok && extend ) { iumin = iun; iumax = iux; ivmin = ivn; ivmax = ivx; } | |
1956 | return ok; | |
1957 | } | |
1958 | ||
1959 | ||
1960 | //======================================================================= | |
1961 | //function : CollectWires | |
1962 | //purpose : | |
1963 | //======================================================================= | |
1964 | ||
1965 | void ShapeFix_ComposeShell::CollectWires (ShapeFix_SequenceOfWireSegment &wires, | |
1966 | ShapeFix_SequenceOfWireSegment &seqw) | |
1967 | { | |
1968 | ||
1969 | ShapeAnalysis_Edge sae; | |
1970 | Standard_Integer i; // svv #1 | |
1971 | // Collect information on short closed segments | |
1972 | TColStd_Array1OfInteger shorts(1,seqw.Length()); | |
1973 | for ( i=1; i <= seqw.Length(); i++ ) { | |
1974 | if(seqw(i).IsVertex() || seqw(i).Orientation() == TopAbs_INTERNAL) { | |
1975 | wires.Append(seqw(i)); | |
1976 | seqw.Remove(i); | |
1977 | i--; | |
1978 | continue; | |
1979 | } | |
1980 | #ifdef DEB | |
1981 | for ( Standard_Integer k=1; ! myClosedMode && k <= seqw(i).NbEdges(); k++ ) | |
1982 | if ( ! seqw(i).CheckPatchIndex ( k ) ) {;} //break; | |
1983 | // cout << "Warning: ShapeFix_ComposeShell::CollectWires: Wrong patch indices" << endl; | |
1984 | #endif | |
1985 | Standard_Integer isshort = IsShortSegment ( seqw(i), myFace, myGrid, myLoc, | |
1986 | myUResolution, myVResolution ); | |
1987 | shorts.SetValue ( i, isshort ); | |
1988 | if ( isshort >0 && | |
1989 | ( seqw(i).Orientation() == TopAbs_EXTERNAL || | |
1990 | ( seqw(i).NbEdges() == 1 && //:abv 13.05.02: OCC320 - remove if degenerated | |
1991 | BRep_Tool::Degenerated ( seqw(i).Edge(1) ) ) ) ) { | |
1992 | #ifdef DEB | |
1993 | cout << "Info: ShapeFix_ComposeShell::CollectWires: Short segment ignored" << endl; | |
1994 | #endif | |
1995 | seqw(i).Orientation ( TopAbs_INTERNAL ); | |
1996 | } | |
1997 | } | |
1998 | ||
1999 | Handle(ShapeExtend_WireData) sbwd; | |
2000 | gp_Pnt2d endPnt, firstPnt; | |
2001 | gp_Vec2d endTan, firstTan; | |
2002 | TopoDS_Vertex firstV, endV; | |
2003 | TopoDS_Edge firstEdge, lastEdge; | |
2004 | Standard_Real tol = 0; | |
1d47d8d0 | 2005 | Standard_Integer iumin = 0, iumax = 0, ivmin = 0, ivmax = 0; |
7fd59977 | 2006 | Standard_Real dsu=0., dsv=0.; |
2007 | Standard_Boolean canBeClosed = Standard_False; | |
302f96fb | 2008 | for(;;) { |
7fd59977 | 2009 | Standard_Integer index = 0; |
2010 | Standard_Boolean misoriented = Standard_True, samepatch = Standard_False; | |
2011 | Standard_Boolean reverse = Standard_False, connected = Standard_False; | |
c6541a0c | 2012 | Standard_Real angle = -M_PI, mindist = RealLast(); |
7fd59977 | 2013 | Standard_Integer weigth = 0; |
2014 | Standard_Real shiftu=0., shiftv=0.; | |
2015 | ||
2016 | // find next segment to connect (or first if sbwd is NULL) | |
2017 | for ( i = 1; i <= seqw.Length(); i++ ) { | |
2018 | ShapeFix_WireSegment seg = seqw.Value(i); | |
2019 | if(seg.IsVertex()) | |
2020 | continue; | |
2021 | TopAbs_Orientation anOr = seg.Orientation(); | |
2022 | if ( anOr == TopAbs_INTERNAL ) continue; | |
2023 | ||
2024 | // for first segment, take any | |
2025 | if ( sbwd.IsNull() ) { | |
2026 | if ( shorts(i) >0 ) continue; | |
2027 | if ( anOr == TopAbs_EXTERNAL ) continue; | |
2028 | if ( anOr == TopAbs_FORWARD ) reverse = Standard_True; | |
2029 | index = i; | |
2030 | seg.GetPatchIndex ( 1, iumin, iumax, ivmin, ivmax ); | |
2031 | misoriented = Standard_False; | |
2032 | dsu = dsv = 0.; | |
2033 | break; | |
2034 | } | |
2035 | ||
2036 | // check whether current segment is on the same patch with previous | |
2037 | Standard_Integer sp = ( myClosedMode || // no indexation in closed mode | |
2038 | IsSamePatch ( seg, myGrid->NbUPatches(), myGrid->NbVPatches(), | |
2039 | iumin, iumax, ivmin, ivmax ) ); | |
2040 | ||
2041 | // not same patch has lowest priority | |
2042 | if ( ! sp && ( canBeClosed || ( index && samepatch ) ) ) continue; | |
2043 | ||
2044 | // try to connect, with the following priorities: | |
2045 | // The name of property Weigth: | |
2046 | // sharing vertex auto | |
2047 | // samepatch = 1 16 | |
2048 | // ! sameedge auto | |
2049 | // misorientation = 0 8 | |
2050 | // connected in 2d 4 | |
2051 | // distance 2 | |
2052 | // short auto | |
2053 | // angle ->> PI 1 | |
2054 | Handle(ShapeExtend_WireData) wire = seg.WireData(); | |
2055 | for ( Standard_Integer j=0; j <2; j++ ) { | |
2056 | if ( ! endV.IsSame ( j ? seg.LastVertex() : seg.FirstVertex() ) ) continue; | |
2057 | ||
2058 | // check for misorientation only if nothing better is found | |
2059 | Standard_Integer misor = ( anOr == ( j ? TopAbs_REVERSED : TopAbs_FORWARD ) ); | |
2060 | // if ( misor ) continue; // temporarily, to be improved | |
2061 | ||
2062 | // returning back by the same edge is lowest priority | |
2063 | if ( lastEdge.IsSame ( wire->Edge ( j ? wire->NbEdges() : 1 ) ) ) { | |
2064 | if ( ! index && ! canBeClosed ) { // || ( sp && ! samepatch ) ) { | |
2065 | index = i; | |
2066 | reverse = j; | |
2067 | connected = Standard_True; | |
2068 | misoriented = misor; | |
2069 | samepatch = sp; | |
2070 | weigth = ( sp ? 16 : 0 ) + ( connected ? 8 : 0 ) + (misor==0 ? 4 : 0); | |
2071 | dsu = dsv = 0.; | |
2072 | } | |
2073 | continue; | |
2074 | } | |
2075 | ||
2076 | // compute starting tangent | |
2077 | gp_Pnt2d lPnt; | |
2078 | gp_Vec2d lVec; | |
2079 | Standard_Integer k; | |
2080 | Standard_Real edgeTol = 0; | |
2081 | for ( k=1; k <= wire->NbEdges(); k++ ) { | |
2082 | TopoDS_Shape tmpE = wire->Edge(wire->NbEdges()-k+1).Reversed(); | |
2083 | TopoDS_Edge edge = ( j ? TopoDS::Edge ( tmpE ) : | |
2084 | wire->Edge(k) ); | |
2085 | edgeTol = BRep_Tool::Tolerance ( edge ); | |
2086 | //if ( sae.GetEndTangent2d ( edge, myFace, Standard_False, lPnt, lVec ) ) break; | |
2087 | if ( sae.GetEndTangent2d ( edge, myFace, Standard_False, lPnt, lVec, 1.e-3 ) ) break; | |
2088 | } | |
2089 | if ( k > wire->NbEdges() ) myStatus |= ShapeExtend::EncodeStatus ( ShapeExtend_FAIL2 ); | |
2090 | ||
2091 | if ( myClosedMode ) { | |
2092 | if ( myUClosed ) { | |
2093 | shiftu = ShapeAnalysis::AdjustByPeriod ( lPnt.X(), endPnt.X(), myUPeriod ); | |
2094 | lPnt.SetX ( lPnt.X() + shiftu ); | |
2095 | } | |
2096 | if ( myVClosed ) { | |
2097 | shiftv = ShapeAnalysis::AdjustByPeriod ( lPnt.Y(), endPnt.Y(), myVPeriod ); | |
2098 | lPnt.SetY ( lPnt.Y() + shiftv ); | |
2099 | } | |
2100 | } | |
2101 | ||
2102 | // short segment is to be taken with highest priority by angle | |
c6541a0c D |
2103 | Standard_Real ang = ( shorts(i) >0 ? M_PI : endTan.Angle ( lVec ) ); |
2104 | if ( myClosedMode && shorts(i) <=0 && M_PI-ang < ::Precision::Angular() ) | |
7fd59977 | 2105 | ang = 0.; // abv 21 Mar 00: trj3_s1-md-214.stp #2471: avoid going back |
2106 | // abv 05 Feb 02: face from Parasolid: use tolerance of edges for check | |
2107 | // for coincidence (instead of vertex tolerance) in order | |
2108 | // this check to be in agreement with check for position of wire segments | |
2109 | // thus avoiding bad effects on overlapping edges | |
2110 | Standard_Real ctol = Max ( edgeTol, BRep_Tool::Tolerance(lastEdge) ); | |
2111 | Standard_Boolean conn = IsCoincided ( endPnt, lPnt, myUResolution, | |
2112 | myVResolution, ctol ); | |
2113 | Standard_Real dist = endPnt.SquareDistance ( lPnt ); | |
2114 | ||
2115 | // check if case is better than last found | |
2116 | ||
2117 | Standard_Integer w1 = ( sp ? 16 : 0 ) + ( conn ? 4 : 0 ) + (misor==0 ? 8 : 0); | |
2118 | Standard_Integer tail1 = ( !conn && (dist < mindist) ? 2 : 0) + (ang > angle ? 1 : 0); | |
2119 | Standard_Integer tail2 = ( !connected &&(dist > mindist) ? 2 : 0) + (ang < angle ? 1 : 0); | |
2120 | if(w1+tail1 <= weigth+tail2) | |
2121 | continue; | |
2122 | ||
2123 | index = i; | |
2124 | reverse = j; | |
2125 | angle = ang; | |
2126 | mindist = dist; | |
2127 | connected = conn; | |
2128 | misoriented = misor; | |
2129 | samepatch = sp; | |
2130 | weigth = w1; | |
2131 | dsu = shiftu; | |
2132 | dsv = shiftv; | |
2133 | } | |
2134 | } | |
2135 | ||
2136 | // if next segment found, connect it | |
2137 | if ( index ) { | |
2138 | if(misoriented) | |
2139 | myInvertEdgeStatus = Standard_True; | |
2140 | ShapeFix_WireSegment seg = seqw.Value(index); | |
2141 | if ( sbwd.IsNull() ) sbwd = new ShapeExtend_WireData; | |
2142 | else if ( samepatch ) { // extend patch indices | |
2143 | IsSamePatch ( seg, myGrid->NbUPatches(), myGrid->NbVPatches(), | |
2144 | iumin, iumax, ivmin, ivmax, Standard_True ); | |
2145 | } | |
2146 | // TopAbs_Orientation or = seg.Orientation(); | |
2147 | if ( ! reverse ) sbwd->Add ( seg.WireData() ); | |
2148 | else { | |
2149 | Handle(ShapeExtend_WireData) wire = new ShapeExtend_WireData; | |
2150 | wire->ManifoldMode() = Standard_False; | |
2151 | wire->Add ( seg.WireData() ); | |
2152 | wire->Reverse ( myFace ); | |
2153 | sbwd->Add ( wire ); | |
2154 | } | |
2155 | if ( seg.Orientation() == TopAbs_EXTERNAL ) | |
2156 | seg.Orientation ( reverse ? TopAbs_REVERSED : TopAbs_FORWARD ); | |
2157 | else seg.Orientation ( TopAbs_INTERNAL ); | |
2158 | seqw.SetValue ( index, seg ); | |
2159 | } | |
2160 | else if ( sbwd.IsNull() ) break; // stop when no free segments available | |
2161 | // for first segment, remember start point | |
2162 | if ( endV.IsNull() ) { | |
2163 | firstEdge = sbwd->Edge(1); | |
2164 | firstV = sae.FirstVertex ( firstEdge ); | |
2165 | //sae.GetEndTangent2d ( firstEdge, myFace, Standard_False, firstPnt, firstTan ); | |
2166 | sae.GetEndTangent2d ( firstEdge, myFace, Standard_False, firstPnt, firstTan, 1.e-3 ); | |
2167 | } | |
2168 | ||
2169 | // update last edge and vertex (only for not short segments) | |
2170 | Standard_Boolean doupdate = ( index && ( shorts(index) <=0 || endV.IsNull() ) ); | |
2171 | if ( doupdate ) { | |
2172 | lastEdge = sbwd->Edge ( sbwd->NbEdges() ); | |
2173 | endV = sae.LastVertex ( lastEdge ); | |
2174 | tol = BRep_Tool::Tolerance ( endV ); | |
2175 | // BUC60035 2053: iteration on edges is required | |
2176 | Standard_Integer k; // svv #1 | |
2177 | for ( k=sbwd->NbEdges(); k >=1; k-- ) | |
2178 | //if ( sae.GetEndTangent2d ( sbwd->Edge ( k ), myFace, Standard_True, endPnt, endTan ) ) | |
2179 | if ( sae.GetEndTangent2d ( sbwd->Edge ( k ), myFace, Standard_True, endPnt, endTan, 1.e-3 ) ) | |
2180 | break; | |
2181 | if ( k <1 ) myStatus |= ShapeExtend::EncodeStatus ( ShapeExtend_FAIL2 ); | |
2182 | if ( myUClosed ) endPnt.SetX ( endPnt.X() + dsu ); | |
2183 | if ( myVClosed ) endPnt.SetY ( endPnt.Y() + dsv ); | |
2184 | } | |
2185 | ||
2186 | // if closed or no next segment found, add to wires | |
2187 | canBeClosed = endV.IsSame ( firstV ); | |
2188 | if ( ! index || ( canBeClosed && | |
2189 | ! lastEdge.IsSame ( firstEdge ) && // cylinder (seam) | |
2190 | IsCoincided ( endPnt, firstPnt, myUResolution, myVResolution, 2.* tol ) ) ) { | |
2191 | if ( ! endV.IsSame ( sae.FirstVertex ( firstEdge ) ) ) { | |
2192 | myStatus |= ShapeExtend::EncodeStatus ( ShapeExtend_FAIL5 ); | |
2193 | #ifdef DEB | |
2194 | cout << "Warning: ShapeFix_ComposeShell::CollectWires: can't close wire" << endl; | |
2195 | #endif | |
2196 | } | |
2197 | ShapeFix_WireSegment s ( sbwd, TopAbs_FORWARD ); | |
2198 | s.DefineIUMin(1,iumin); | |
2199 | s.DefineIUMax(1,iumax); | |
2200 | s.DefineIVMin(1,ivmin); | |
2201 | s.DefineIVMax(1,ivmax); | |
2202 | wires.Append ( s ); | |
2203 | sbwd.Nullify(); | |
2204 | endV.Nullify(); | |
2205 | canBeClosed = Standard_False; | |
2206 | } | |
2207 | } | |
2208 | ||
2209 | // Check if some wires are short in 3d (lie entirely inside one vertex), | |
2210 | // and if yes try to merge them with others | |
2211 | //pdn The short seqments are stil plased in "in" sequence. | |
2212 | ||
2213 | for ( i=1; i <= seqw.Length(); i++ ) { | |
2214 | if ( shorts(i) != 1 || seqw(i).IsVertex() || seqw(i).Orientation() == TopAbs_INTERNAL || | |
2215 | seqw(i).Orientation() == TopAbs_EXTERNAL ) continue; | |
2216 | ||
2217 | // find any other wire containing the same vertex | |
2218 | Handle(ShapeExtend_WireData) wd = seqw(i).WireData(); | |
2219 | TopoDS_Vertex V = seqw(i).FirstVertex(); | |
2220 | Standard_Integer minj=0, mink=0; | |
2221 | gp_Pnt2d p2d; | |
2222 | gp_Vec2d vec; | |
2223 | Standard_Real mindist=0; | |
2224 | Standard_Boolean samepatch = Standard_False; | |
2225 | // Standard_Integer iumin, iumax, ivmin, ivmax; | |
2226 | seqw(i).GetPatchIndex ( 1, iumin, iumax, ivmin, ivmax ); | |
2227 | sae.GetEndTangent2d ( wd->Edge(1), myFace, Standard_False, p2d, vec ); | |
2228 | for ( Standard_Integer j=1; j <= wires.Length(); j++ ) { | |
2229 | // if ( j == i ) continue; | |
2230 | // Handle(ShapeExtend_WireData) | |
2231 | sbwd = wires(j).WireData(); | |
2232 | for ( Standard_Integer k=1; k <= sbwd->NbEdges(); k++ ) { | |
2233 | if ( !V.IsSame ( sae.FirstVertex ( sbwd->Edge(k) ) ) ) continue; //pdn I suppose that short segment should be inserted into the SAME vertex. | |
2234 | ||
2235 | Standard_Integer sp = IsSamePatch ( wires(j), myGrid->NbUPatches(), myGrid->NbVPatches(), | |
2236 | iumin, iumax, ivmin, ivmax ); | |
2237 | if ( samepatch && !sp) continue; | |
2238 | gp_Pnt2d pp; | |
2239 | sae.GetEndTangent2d ( sbwd->Edge(k), myFace, Standard_False, pp, vec ); | |
2240 | Standard_Real dist = pp.SquareDistance ( p2d ); | |
2241 | if ( sp && ! samepatch ) { minj = j; mink = k; mindist = dist;samepatch=sp;} | |
2242 | else | |
2243 | if ( ! minj || mindist > dist ) { minj = j; mink = k; mindist = dist;samepatch=sp; } | |
2244 | } | |
2245 | } | |
2246 | if ( ! minj ) { | |
2247 | //pdn add into resulting sequence! | |
2248 | ShapeFix_WireSegment s ( wd, TopAbs_FORWARD ); | |
2249 | wires.Append ( s ); | |
2250 | #ifdef DEB | |
2251 | cout <<"Warning: Short segment processed as separate wire"<<endl; | |
2252 | #endif | |
2253 | continue; | |
2254 | } | |
2255 | ||
2256 | // and if found, merge | |
2257 | // Handle(ShapeExtend_WireData) | |
2258 | sbwd = wires(minj).WireData(); | |
2259 | for ( Standard_Integer n=1; n <= wd->NbEdges(); n++ ) | |
2260 | sbwd->Add ( wd->Edge(n), mink++ ); | |
2261 | ||
2262 | // wires.Remove ( i ); | |
2263 | // i--; | |
2264 | } | |
2265 | ||
2266 | } | |
2267 | ||
2268 | //======================================================================= | |
2269 | //function : DispatchWires | |
2270 | //purpose : | |
2271 | //======================================================================= | |
2272 | ||
2273 | static gp_Pnt2d GetMiddlePoint (const ShapeFix_WireSegment wire, | |
2274 | const TopoDS_Face face) | |
2275 | { | |
2276 | if(wire.IsVertex()) { | |
2277 | TopoDS_Vertex aV = wire.GetVertex(); | |
2278 | gp_Pnt aP3D = BRep_Tool::Pnt(aV ); | |
2279 | Handle(Geom_Surface) surf = BRep_Tool::Surface(face); | |
2280 | Handle(ShapeAnalysis_Surface) aSurfTool = new ShapeAnalysis_Surface(surf); | |
2281 | return aSurfTool->ValueOfUV(aP3D,Precision::Confusion()); | |
2282 | } | |
2283 | Bnd_Box2d box; | |
2284 | ShapeAnalysis_Edge sae; | |
2285 | ShapeAnalysis_Curve sac; | |
2286 | Handle(ShapeExtend_WireData) wd = wire.WireData(); | |
2287 | for(Standard_Integer i = 1; i <= wd->NbEdges(); i++) { | |
2288 | TopoDS_Edge E = wd->Edge (i); | |
2289 | Standard_Real cf,cl; | |
2290 | Handle(Geom2d_Curve) c2d; | |
2291 | if(sae.PCurve (E,face,c2d,cf,cl,Standard_False)) { | |
2292 | sac.FillBndBox ( c2d, cf, cl, 3, Standard_False, box ); | |
2293 | // box.Add(c2d->Value(cf)); | |
2294 | // box.Add(c2d->Value(cl)); | |
2295 | // box.Add(c2d->Value((cl+cf)/2.)); | |
2296 | } | |
2297 | } | |
2298 | if ( box.IsVoid() ) return gp_Pnt2d(0.,0.); | |
2299 | Standard_Real aXmin, aYmin, aXmax, aYmax; | |
2300 | box.Get(aXmin, aYmin, aXmax, aYmax); | |
2301 | return gp_Pnt2d ( 0.5 * ( aXmax + aXmin ), 0.5 * ( aYmax + aYmin ) ); | |
2302 | } | |
2303 | ||
2304 | //======================================================================= | |
2305 | //function : MakeFacesOnPatch | |
2306 | //purpose : | |
2307 | //======================================================================= | |
2308 | ||
2309 | void ShapeFix_ComposeShell::MakeFacesOnPatch (TopTools_SequenceOfShape &faces, | |
2310 | const Handle(Geom_Surface)& surf, | |
2311 | TopTools_SequenceOfShape &loops) const | |
2312 | { | |
2313 | BRep_Builder B; | |
2314 | ||
2315 | // Case of single loop: just add it to face | |
2316 | if ( loops.Length() == 1 ) { | |
2317 | TopoDS_Face newFace; | |
2318 | B.MakeFace ( newFace, surf, myLoc, ::Precision::Confusion() ); | |
2319 | TopoDS_Shape aSH = loops.Value(1); | |
2320 | if( aSH.ShapeType() != TopAbs_WIRE) | |
2321 | return; | |
2322 | TopoDS_Wire wire = TopoDS::Wire ( loops.Value(1) ); | |
2323 | ||
2324 | B.Add ( newFace, wire ); | |
2325 | if(myInvertEdgeStatus) { | |
2326 | Handle(ShapeFix_Face) sff = new ShapeFix_Face(newFace); | |
2327 | sff->FixAddNaturalBoundMode() = Standard_False; | |
2328 | TopTools_DataMapOfShapeListOfShape MapWires; | |
2329 | MapWires.Clear(); | |
2330 | sff->FixOrientation(MapWires); | |
2331 | newFace = sff->Face(); | |
2332 | } | |
2333 | ||
2334 | faces.Append ( newFace ); | |
2335 | return; | |
2336 | } | |
2337 | ||
2338 | // For several loops, first find roots | |
2339 | // make pseudo-face, | |
2340 | TopoDS_Face pf; | |
2341 | B.MakeFace ( pf, surf, myLoc, ::Precision::Confusion() ); | |
2342 | Handle(Geom_Surface) atSurf = BRep_Tool::Surface(pf); | |
2343 | ||
2344 | Handle(ShapeAnalysis_Surface) aSurfTool = new ShapeAnalysis_Surface(atSurf); | |
2345 | TopTools_SequenceOfShape roots; | |
2346 | Standard_Integer i; // svv #1 | |
2347 | for ( i = 1; i <= loops.Length(); i++ ) { | |
2348 | gp_Pnt2d unp; | |
2349 | TopoDS_Wire wr; | |
2350 | TopoDS_Shape aShape = loops(i); | |
2351 | if(aShape.ShapeType() != TopAbs_WIRE || | |
2352 | (aShape.Orientation() != TopAbs_FORWARD && aShape.Orientation() != TopAbs_REVERSED)) | |
2353 | continue; | |
2354 | ||
2355 | wr = TopoDS::Wire ( loops(i) ); | |
2356 | TopoDS_Iterator ew (wr); | |
2357 | if ( ! ew.More() ) continue; | |
2358 | ||
2359 | TopoDS_Edge ed = TopoDS::Edge ( ew.Value() ); | |
2360 | while(ed.Orientation() != TopAbs_FORWARD && | |
2361 | ed.Orientation() != TopAbs_REVERSED ) { | |
2362 | ew.Next(); | |
2363 | if(ew.More()) | |
2364 | ed = TopoDS::Edge ( ew.Value() ); | |
2365 | else | |
2366 | break; | |
2367 | } | |
2368 | if ( ! ew.More() ) continue; | |
2369 | Standard_Real cf, cl; | |
2370 | Handle(Geom2d_Curve) cw = BRep_Tool::CurveOnSurface ( ed, pf, cf, cl ); | |
2371 | if ( cw.IsNull() ) continue; | |
2372 | unp = cw->Value ( 0.5 * ( cf + cl ) ); | |
2373 | ||
2374 | Standard_Integer j; // svv #1 | |
2375 | for ( j = 1; j <= loops.Length(); j++ ) { | |
2376 | if ( i == j ) continue; | |
2377 | TopoDS_Shape aShape2 = loops(j); | |
2378 | if(aShape2.ShapeType() != TopAbs_WIRE || | |
2379 | (aShape2.Orientation() != TopAbs_FORWARD && | |
2380 | aShape2.Orientation() != TopAbs_REVERSED)) | |
2381 | continue; | |
2382 | TopoDS_Wire w1 = TopoDS::Wire (aShape2); | |
2383 | TopoDS_Wire awtmp; | |
2384 | B.MakeWire(awtmp); | |
2385 | awtmp.Orientation(TopAbs_FORWARD); | |
2386 | TopoDS_Iterator aIt(w1); | |
2387 | Standard_Integer nbe =0; | |
2388 | for( ; aIt.More() ; aIt.Next()) { | |
2389 | if(aIt.Value().Orientation() == TopAbs_FORWARD || | |
2390 | aIt.Value().Orientation() == TopAbs_REVERSED) { | |
2391 | B.Add(awtmp,aIt.Value()); | |
2392 | nbe++; | |
2393 | } | |
2394 | ||
2395 | } | |
2396 | if(!nbe) | |
2397 | continue; | |
2398 | TopoDS_Face fc; | |
2399 | B.MakeFace ( fc, surf, myLoc, ::Precision::Confusion() ); | |
2400 | B.Add ( fc, awtmp ); | |
2401 | BRepTopAdaptor_FClass2d clas ( fc, ::Precision::PConfusion() ); | |
2402 | TopAbs_State stPoint = clas.Perform (unp,Standard_False); | |
2403 | if(stPoint == TopAbs_ON || stPoint == TopAbs_UNKNOWN) { | |
2404 | ||
2405 | TopoDS_Edge ed = TopoDS::Edge ( ew.Value() ); | |
2406 | Standard_Real cf, cl; | |
2407 | Handle(Geom2d_Curve) cw = BRep_Tool::CurveOnSurface ( ed, pf, cf, cl ); | |
2408 | // handle tangential case (ON) | |
2409 | while ( stPoint == TopAbs_ON || stPoint == TopAbs_UNKNOWN ) { | |
2410 | stPoint = clas.Perform ( cw->Value(cl), Standard_False ); | |
2411 | if ( ! ew.More() ) break; | |
2412 | ew.Next(); | |
2413 | if ( ! ew.More() ) break; | |
2414 | TopoDS_Edge edge = TopoDS::Edge ( ew.Value() ); | |
2415 | if(edge.Orientation() !=TopAbs_FORWARD && | |
2416 | edge.Orientation() !=TopAbs_REVERSED) | |
2417 | continue; | |
2418 | Handle(Geom2d_Curve) c2d = BRep_Tool::CurveOnSurface ( edge, pf, cf, cl ); | |
2419 | if ( ! c2d.IsNull() ) cw = c2d; | |
2420 | } | |
2421 | } | |
2422 | TopAbs_State stInfin = clas.PerformInfinitePoint(); | |
2423 | if ( stPoint != stInfin ) break; | |
2424 | } | |
2425 | if ( j > loops.Length()) { | |
2426 | roots.Append ( wr ); | |
2427 | // loops.Remove ( i-- ); | |
2428 | } | |
2429 | } | |
2430 | ||
2431 | // And remove them from the list of loops | |
2432 | for ( i = 1; i <= loops.Length(); i++ ) | |
2433 | for ( Standard_Integer j = 1; j <= roots.Length(); j++ ) | |
2434 | if ( loops(i).IsSame ( roots(j) ) ) { loops.Remove(i--); break; } | |
2435 | ||
2436 | // check for lost wires, and if they are, make them roots | |
2437 | if ( roots.Length() <=0 && loops.Length() >0 ) { | |
2438 | #ifdef DEB | |
2439 | cout << "Error: ShapeFix_ComposeShell::MakeFacesOnPatch: can't dispatch wires" << endl; | |
2440 | #endif | |
2441 | for ( Standard_Integer j=1; j <= loops.Length(); j++ ) { | |
2442 | roots.Append ( loops(j) ); | |
2443 | } | |
2444 | loops.Clear(); | |
2445 | } | |
2446 | ||
2447 | // Then iterate on loops | |
2448 | for ( i=1; i <= roots.Length(); i++ ) { | |
2449 | Standard_Boolean reverse = Standard_False; | |
2450 | TopoDS_Wire wire = TopoDS::Wire ( roots(i) ); | |
2451 | TopoDS_Face fc; | |
2452 | B.MakeFace ( fc, surf, myLoc, ::Precision::Confusion() ); | |
2453 | B.Add ( fc, wire ); | |
2454 | BRepTopAdaptor_FClass2d clas ( fc, ::Precision::PConfusion() ); | |
2455 | if ( clas.PerformInfinitePoint() == TopAbs_IN ) { | |
2456 | reverse = Standard_True; | |
2457 | #ifdef DEB | |
2458 | cout << "Warning: ShapeFix_ComposeShell::MakeFacesOnPatch: badly oriented wire" << endl; | |
2459 | #endif | |
2460 | } | |
2461 | ||
2462 | // find all holes for that loop | |
2463 | TopTools_SequenceOfShape holes; // holes in holes not supported | |
2464 | Standard_Integer j; // svv #1 | |
2465 | for ( j=1; j <= loops.Length(); j++ ) { | |
2466 | gp_Pnt2d unp; | |
2467 | if(loops(j).ShapeType() == TopAbs_WIRE) { | |
2468 | TopoDS_Wire bw = TopoDS::Wire ( loops(j) ); | |
2469 | TopoDS_Iterator ew ( bw ); | |
2470 | if ( ! ew.More() ) continue; | |
2471 | TopoDS_Edge ed = TopoDS::Edge ( ew.Value() ); | |
2472 | Standard_Real cf, cl; | |
2473 | Handle(Geom2d_Curve) cw = BRep_Tool::CurveOnSurface ( ed, pf, cf, cl ); | |
2474 | if ( cw.IsNull() ) continue; | |
2475 | unp = cw->Value ( 0.5 * ( cf + cl ) ); | |
2476 | } | |
2477 | else if(loops(j).ShapeType() == TopAbs_VERTEX) { | |
2478 | TopoDS_Vertex aV = TopoDS::Vertex(loops(j)); | |
2479 | gp_Pnt aP = BRep_Tool::Pnt(aV); | |
2480 | unp = aSurfTool->ValueOfUV(aP,Precision::Confusion()); | |
2481 | } | |
2482 | else | |
2483 | continue; | |
2484 | TopAbs_State state = clas.Perform (unp,Standard_False); | |
2485 | if ( (Standard_Boolean) ( state == TopAbs_OUT ) == reverse ) { | |
2486 | holes.Append ( loops(j) ); | |
2487 | loops.Remove ( j-- ); | |
2488 | } | |
2489 | } | |
2490 | ||
2491 | // and add them to new face (no orienting is done) | |
2492 | TopoDS_Face newFace; | |
2493 | B.MakeFace ( newFace, surf, myLoc, ::Precision::Confusion() ); | |
2494 | B.Add ( newFace, wire ); | |
2495 | for ( j=1; j <= holes.Length(); j++ ) { | |
2496 | TopoDS_Shape aSh = holes(j); | |
2497 | if(aSh.ShapeType() == TopAbs_VERTEX) { | |
2498 | TopoDS_Vertex aNewV = ShapeAnalysis_TransferParametersProj::CopyNMVertex(TopoDS::Vertex(aSh), newFace,myFace); | |
2499 | Context()->Replace(aSh,aNewV); | |
2500 | B.Add ( newFace,aNewV); | |
2501 | } | |
2502 | else | |
2503 | B.Add ( newFace, holes(j) ); | |
2504 | } | |
2505 | faces.Append ( newFace ); | |
2506 | ||
2507 | // check for lost wires, and if they are, make them roots | |
2508 | if ( i == roots.Length() && loops.Length() >0 ) { | |
2509 | #ifdef DEB | |
2510 | cout << "Error: ShapeFix_ComposeShell::MakeFacesOnPatch: can't dispatch wires" << endl; | |
2511 | #endif | |
2512 | for ( j=1; j <= loops.Length(); j++ ) { | |
2513 | TopoDS_Shape aSh = loops(j); | |
2514 | if(aSh.ShapeType() == TopAbs_WIRE && (aSh.Orientation() == TopAbs_FORWARD || | |
2515 | aSh.Orientation() == TopAbs_REVERSED)) | |
2516 | roots.Append ( loops(j) ); | |
2517 | } | |
2518 | loops.Clear(); | |
2519 | } | |
2520 | } | |
2521 | } | |
2522 | ||
2523 | //======================================================================= | |
2524 | //function : DispatchWires | |
2525 | //purpose : | |
2526 | //======================================================================= | |
2527 | ||
2528 | void ShapeFix_ComposeShell::DispatchWires (TopTools_SequenceOfShape &faces, | |
2529 | ShapeFix_SequenceOfWireSegment& wires) const | |
2530 | { | |
2531 | BRep_Builder B; | |
2532 | ||
2533 | // in closed mode, apply FixShifted to all wires before dispatching them | |
2534 | if ( myClosedMode ) { | |
2535 | ShapeFix_Wire sfw; | |
2536 | sfw.SetFace ( myFace ); | |
2537 | sfw.SetPrecision ( Precision() ); | |
2538 | ||
2539 | // pdn: shift pcurves in the seam to make OK shape w/o fixshifted | |
2540 | Standard_Integer i; | |
2541 | for ( i=1; i <= wires.Length(); i++ ) { | |
2542 | if(wires(i).IsVertex()) | |
2543 | continue; | |
2544 | Handle(ShapeExtend_WireData) sbwd = wires(i).WireData(); | |
2545 | ||
2546 | for(Standard_Integer jL=1; jL <= sbwd->NbEdges(); jL++ ) { | |
2547 | TopoDS_Edge E = sbwd->Edge(jL); | |
2548 | if ( E.Orientation() == TopAbs_REVERSED && BRep_Tool::IsClosed(E,myFace) ) { | |
2549 | Standard_Real f1,l1, f2, l2; | |
2550 | Handle(Geom2d_Curve) c21 = BRep_Tool::CurveOnSurface(E,myFace,f1,l1); | |
2551 | TopoDS_Shape dummy = E.Reversed(); | |
2552 | Handle(Geom2d_Curve) c22 = BRep_Tool::CurveOnSurface(TopoDS::Edge(dummy),myFace,f2,l2); | |
2553 | Standard_Real dPreci = ::Precision::PConfusion()*Precision::PConfusion(); | |
2554 | gp_Pnt2d pf1 = c21->Value(f1); | |
2555 | gp_Pnt2d pl1 = c21->Value(l1); | |
2556 | gp_Pnt2d pf2 = c22->Value(f2); | |
2557 | gp_Pnt2d pl2 = c22->Value(l2); | |
2558 | if ( c21 == c22 || pf1.SquareDistance(pf2) < dPreci || | |
2559 | pl1.SquareDistance(pl2) < dPreci ) { | |
2560 | gp_Vec2d shift(0.,0.); | |
2561 | if ( myUClosed && Abs ( pf2.X() - pl2.X() ) < ::Precision::PConfusion() ) | |
2562 | shift.SetX(myUPeriod); | |
2563 | if ( myVClosed && Abs ( pf2.Y() - pl2.Y() ) < ::Precision::PConfusion() ) | |
2564 | shift.SetY(myVPeriod); | |
2565 | c22->Translate(shift); | |
2566 | } | |
2567 | } | |
2568 | } | |
2569 | } | |
2570 | ||
2571 | for ( i=1; i <= wires.Length(); i++ ) { | |
2572 | if(wires(i).IsVertex()) | |
2573 | continue; | |
2574 | Handle(ShapeExtend_WireData) sbwd = wires(i).WireData(); | |
2575 | ||
2576 | //: abv 30.08.01: torHalf2.sat: if wire contains single degenerated | |
2577 | // edge, skip that wire | |
2578 | if ( sbwd->NbEdges() <=0 || | |
2579 | ( sbwd->NbEdges() ==1 && BRep_Tool::Degenerated(sbwd->Edge(1)) ) ) { | |
2580 | wires.Remove(i--); | |
2581 | continue; | |
2582 | } | |
2583 | ||
2584 | sfw.Load ( sbwd ); | |
2585 | sfw.FixShifted(); | |
2586 | ||
2587 | // force recomputation of degenerated edges (clear pcurves) | |
2588 | ShapeBuild_Edge sbe; | |
2589 | for (Standard_Integer jL=1; jL <= sbwd->NbEdges(); jL++ ) { | |
2590 | if ( BRep_Tool::Degenerated(sbwd->Edge(jL)) ) | |
2591 | sbe.RemovePCurve(sbwd->Edge(jL),myFace); | |
2592 | // sfw.FixDegenerated(jL); | |
2593 | } | |
2594 | sfw.FixDegenerated(); | |
2595 | } | |
2596 | } | |
2597 | ||
2598 | // Compute center points for wires | |
2599 | TColgp_SequenceOfPnt2d mPnts; | |
2600 | Standard_Integer nb = wires.Length(); | |
2601 | ||
2602 | // pdn protection on empty sequence | |
2603 | if(nb == 0) | |
2604 | return; | |
2605 | ||
2606 | Standard_Integer i; //svv #1 | |
2607 | for ( i = 1; i <= nb; i++ ) | |
2608 | mPnts.Append ( GetMiddlePoint ( wires(i), myFace ) ); | |
2609 | ||
2610 | // Put each wire on its own surface patch (by reassigning pcurves) | |
2611 | // and build 3d curve if necessary | |
2612 | ShapeBuild_ReShape rs; | |
2613 | ShapeBuild_Edge sbe; | |
2614 | ShapeAnalysis_Edge sae; | |
2615 | Handle(ShapeFix_Edge) sfe = new ShapeFix_Edge; | |
2616 | ||
2617 | Standard_Real U1,U2,V1,V2; | |
2618 | myGrid->Bounds(U1,U2,V1,V2); | |
2619 | for ( i = 1; i <= nb; i++ ) { | |
2620 | ||
2621 | gp_Pnt2d pnt = mPnts(i); | |
2622 | Standard_Real ush =0., vsh=0.; | |
2623 | if(myUClosed) { | |
2624 | ush = ShapeAnalysis::AdjustToPeriod(pnt.X(),U1,U2); | |
2625 | pnt.SetX(pnt.X()+ush); | |
2626 | } | |
2627 | if(myVClosed) { | |
2628 | vsh = ShapeAnalysis::AdjustToPeriod(pnt.Y(),V1,V2); | |
2629 | pnt.SetY(pnt.Y()+vsh); | |
2630 | } | |
2631 | mPnts(i) = pnt; | |
2632 | Standard_Integer indU = myGrid->LocateUParameter ( pnt.X() ); | |
2633 | Standard_Integer indV = myGrid->LocateVParameter ( pnt.Y() ); | |
2634 | ||
2635 | // compute parametric transformation | |
2636 | gp_Trsf2d T; | |
2637 | Standard_Real uFact=1.; | |
2638 | Standard_Boolean needT = myGrid->GlobalToLocalTransformation ( indU, indV, uFact, T ); | |
2639 | if ( ush != 0. || vsh != 0. ) { | |
2640 | gp_Trsf2d Sh; | |
2641 | Sh.SetTranslation ( gp_Vec2d ( ush, vsh ) ); | |
2642 | T.Multiply ( Sh ); | |
2643 | needT = Standard_True; | |
2644 | } | |
2645 | if(wires(i).IsVertex()) | |
2646 | continue; | |
2647 | Handle(Geom_Surface) surf = myGrid->Patch ( indU, indV ); | |
2648 | TopoDS_Face face; | |
2649 | B.MakeFace ( face, surf, myLoc, ::Precision::Confusion() ); | |
2650 | Handle(ShapeExtend_WireData) sewd = wires(i).WireData(); | |
2651 | for ( Standard_Integer j = 1; j <= sewd->NbEdges(); j++ ) { | |
2652 | // Standard_Integer nsplit = ApplyContext ( sewd, j, context ); | |
2653 | // if ( nsplit <1 ) { j--; continue; } | |
2654 | ||
2655 | TopoDS_Edge edge = sewd->Edge(j); | |
2656 | ||
2657 | // !! Accurately copy pcurves for SEAMS and SEAM-like edges !! | |
2658 | ||
2659 | // if edge is already copied, don`t copy any more | |
2660 | TopoDS_Edge newEdge; | |
2661 | TopoDS_Edge anInitEdge = edge; | |
2662 | Standard_Boolean ismanifold = (edge.Orientation() == TopAbs_FORWARD || | |
2663 | edge.Orientation() == TopAbs_REVERSED); | |
2664 | if ( rs.IsRecorded ( edge ) ) { | |
2665 | //smh#8 | |
2666 | TopoDS_Shape tmpNE = rs.Value(edge); | |
2667 | newEdge = TopoDS::Edge ( tmpNE ); | |
2668 | } | |
2669 | else { | |
2670 | ||
2671 | if(!ismanifold) | |
2672 | anInitEdge.Orientation(TopAbs_FORWARD); | |
2673 | ||
2674 | newEdge = sbe.Copy ( anInitEdge, Standard_False ); | |
2675 | if(!ismanifold) | |
2676 | newEdge.Orientation(edge.Orientation()); | |
2677 | rs.Replace ( edge, newEdge ); | |
2678 | Context()->Replace ( edge, newEdge ); | |
2679 | } | |
2680 | ||
2681 | sbe.ReassignPCurve ( newEdge, myFace, face ); | |
2682 | ||
2683 | // transform pcurve to parametric space of patch | |
2684 | if ( needT ) { | |
2685 | Standard_Real f, l; | |
2686 | Handle(Geom2d_Curve) c2d; | |
2687 | if ( sae.PCurve ( newEdge, face, c2d, f, l, Standard_False ) ) { | |
2688 | Standard_Real newf = f, newl = l; | |
2689 | Handle(Geom2d_Curve) c2dnew = sbe.TransformPCurve ( c2d, T, uFact, newf, newl ); | |
2690 | if ( BRep_Tool::IsClosed ( newEdge, face ) ) { | |
2691 | Standard_Real cf, cl; | |
2692 | Handle(Geom2d_Curve) c2d2; | |
2693 | //smh#8 | |
2694 | TopoDS_Shape tmpE = newEdge.Reversed(); | |
2695 | TopoDS_Edge e2 = TopoDS::Edge (tmpE ); | |
2696 | if ( sae.PCurve ( e2, face, c2d2, cf, cl, Standard_False ) ) { | |
2697 | if ( newEdge.Orientation() == TopAbs_FORWARD ) | |
2698 | B.UpdateEdge ( newEdge, c2dnew, c2d2, face, 0. ); | |
2699 | else B.UpdateEdge ( newEdge, c2d2, c2dnew, face, 0. ); | |
2700 | } | |
2701 | else B.UpdateEdge ( newEdge, c2dnew, face, 0. ); | |
2702 | } | |
2703 | else B.UpdateEdge ( newEdge, c2dnew, face, 0. ); | |
2704 | B.Range ( newEdge, face, newf, newl ); | |
2705 | if ( (newf != f || newl != l) && !BRep_Tool::Degenerated(newEdge) ) | |
2706 | B.SameRange ( newEdge, Standard_False ); | |
2707 | } | |
2708 | } | |
2709 | ||
2710 | if(!BRep_Tool::SameRange(newEdge)) { | |
2711 | TopoDS_Edge etmp; | |
2712 | if(!ismanifold) { | |
2713 | TopoDS_Edge afe = TopoDS::Edge(newEdge.Oriented(TopAbs_FORWARD)); | |
2714 | etmp = sbe.Copy (afe , Standard_False ); | |
2715 | } | |
2716 | else | |
2717 | etmp = sbe.Copy ( newEdge, Standard_False ); | |
2718 | sfe->FixAddCurve3d ( etmp ); | |
2719 | Standard_Real cf, cl; | |
2720 | Handle(Geom_Curve) c3d; | |
2721 | if(sae.Curve3d(etmp,c3d,cf,cl,Standard_False)) { | |
2722 | B.UpdateEdge ( newEdge, c3d, 0. ); | |
2723 | sbe.SetRange3d ( newEdge, cf, cl ); | |
2724 | } | |
2725 | } | |
2726 | else | |
2727 | sfe->FixAddCurve3d ( newEdge ); | |
2728 | sewd->Set ( newEdge, j ); | |
2729 | } | |
2730 | } | |
2731 | ||
2732 | // Collect wires in packets lying on same surface and dispatch them | |
2733 | TColStd_Array1OfBoolean used ( 1, nb ); | |
2734 | used.Init ( Standard_False ); | |
302f96fb | 2735 | for(;;) { |
7fd59977 | 2736 | TopTools_SequenceOfShape loops; |
2737 | ||
2738 | Handle(Geom_Surface) Surf; | |
2739 | for ( i = 1; i <= nb; i++ ) { | |
2740 | if ( used(i) ) continue; | |
2741 | Handle(Geom_Surface) S = myGrid->Patch ( mPnts(i) ); | |
2742 | if ( Surf.IsNull() ) Surf = S; | |
2743 | else if ( S != Surf ) continue; | |
2744 | used(i) = Standard_True; | |
2745 | ShapeFix_WireSegment aSeg = wires(i); | |
2746 | if(aSeg.IsVertex()) { | |
2747 | TopoDS_Vertex aVert = aSeg.GetVertex(); | |
2748 | if(aVert.Orientation() == TopAbs_INTERNAL) | |
2749 | loops.Append(wires(i).GetVertex()); | |
2750 | } | |
2751 | else { | |
2752 | Handle(ShapeExtend_WireData) aWD = aSeg.WireData(); | |
2753 | if(!aWD.IsNull()) | |
2754 | loops.Append ( aWD->Wire() ); | |
2755 | } | |
2756 | } | |
2757 | if ( Surf.IsNull() ) break; | |
2758 | ||
2759 | MakeFacesOnPatch ( faces, Surf, loops ); | |
2760 | } | |
2761 | } | |
2762 | ||
2763 | //====================================================================== | |
2764 | //function : SetTransferParamTool | |
2765 | //purpose : | |
2766 | //======================================================================= | |
2767 | ||
2768 | void ShapeFix_ComposeShell::SetTransferParamTool(const Handle(ShapeAnalysis_TransferParameters)& TransferParam) | |
2769 | { | |
2770 | myTransferParamTool = TransferParam; | |
2771 | } | |
2772 | ||
2773 | //======================================================================= | |
2774 | //function : GetTransferParamTool | |
2775 | //purpose : | |
2776 | //======================================================================= | |
2777 | ||
2778 | Handle(ShapeAnalysis_TransferParameters) ShapeFix_ComposeShell::GetTransferParamTool() const | |
2779 | { | |
2780 | return myTransferParamTool; | |
2781 | } | |
2782 | ||
2783 | //======================================================================= | |
2784 | //function : ClosedMode | |
2785 | //purpose : | |
2786 | //======================================================================= | |
2787 | ||
2788 | Standard_Boolean &ShapeFix_ComposeShell::ClosedMode() | |
2789 | { | |
2790 | return myClosedMode; | |
2791 | } |