973c2be1 |
1 | // Copyright (c) 1999-2014 OPEN CASCADE SAS |
b311480e |
2 | // |
973c2be1 |
3 | // This file is part of Open CASCADE Technology software library. |
b311480e |
4 | // |
d5f74e42 |
5 | // This library is free software; you can redistribute it and/or modify it under |
6 | // the terms of the GNU Lesser General Public License version 2.1 as published |
973c2be1 |
7 | // by the Free Software Foundation, with special exception defined in the file |
8 | // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT |
9 | // distribution for complete text of the license and disclaimer of any warranty. |
b311480e |
10 | // |
973c2be1 |
11 | // Alternatively, this file may be used under the terms of Open CASCADE |
12 | // commercial license or contractual agreement. |
b311480e |
13 | |
7fd59977 |
14 | |
42cf5bc1 |
15 | #include <Interface_Check.hxx> |
7fd59977 |
16 | #include <Interface_EntityIterator.hxx> |
42cf5bc1 |
17 | #include <Interface_ShareTool.hxx> |
18 | #include <Precision.hxx> |
19 | #include <RWStepShape_RWEdgeCurve.hxx> |
20 | #include <StepData_StepReaderData.hxx> |
21 | #include <StepData_StepWriter.hxx> |
22 | #include <StepGeom_CartesianPoint.hxx> |
23 | #include <StepGeom_Curve.hxx> |
7fd59977 |
24 | #include <StepShape_EdgeCurve.hxx> |
25 | #include <StepShape_EdgeLoop.hxx> |
42cf5bc1 |
26 | #include <StepShape_FaceBound.hxx> |
27 | #include <StepShape_OrientedEdge.hxx> |
28 | #include <StepShape_Vertex.hxx> |
29 | #include <StepShape_VertexPoint.hxx> |
7fd59977 |
30 | |
31 | RWStepShape_RWEdgeCurve::RWStepShape_RWEdgeCurve () {} |
32 | |
33 | void RWStepShape_RWEdgeCurve::ReadStep |
34 | (const Handle(StepData_StepReaderData)& data, |
35 | const Standard_Integer num, |
36 | Handle(Interface_Check)& ach, |
37 | const Handle(StepShape_EdgeCurve)& ent) const |
38 | { |
39 | |
40 | |
41 | // --- Number of Parameter Control --- |
42 | |
43 | if (!data->CheckNbParams(num,5,ach,"edge_curve")) return; |
44 | |
45 | // --- inherited field : name --- |
46 | |
47 | Handle(TCollection_HAsciiString) aName; |
48 | data->ReadString (num,1,"name",ach,aName); |
49 | |
50 | // --- inherited field : edgeStart --- |
51 | |
52 | Handle(StepShape_Vertex) aEdgeStart; |
53 | data->ReadEntity(num, 2,"edge_start", ach, STANDARD_TYPE(StepShape_Vertex), aEdgeStart); |
54 | |
55 | // --- inherited field : edgeEnd --- |
56 | |
57 | Handle(StepShape_Vertex) aEdgeEnd; |
58 | data->ReadEntity(num, 3,"edge_end", ach, STANDARD_TYPE(StepShape_Vertex), aEdgeEnd); |
59 | |
60 | // --- own field : edgeGeometry --- |
61 | |
62 | Handle(StepGeom_Curve) aEdgeGeometry; |
63 | data->ReadEntity(num, 4,"edge_geometry", ach, STANDARD_TYPE(StepGeom_Curve), aEdgeGeometry); |
64 | |
65 | // --- own field : sameSense --- |
66 | |
67 | Standard_Boolean aSameSense; |
68 | data->ReadBoolean (num,5,"same_sense",ach,aSameSense); |
69 | |
70 | //--- Initialisation of the read entity --- |
71 | |
72 | |
73 | ent->Init(aName, aEdgeStart, aEdgeEnd, aEdgeGeometry, aSameSense); |
74 | } |
75 | |
76 | |
77 | void RWStepShape_RWEdgeCurve::WriteStep |
78 | (StepData_StepWriter& SW, |
79 | const Handle(StepShape_EdgeCurve)& ent) const |
80 | { |
81 | |
82 | // --- inherited field name --- |
83 | |
84 | SW.Send(ent->Name()); |
85 | |
86 | // --- inherited field edgeStart --- |
87 | |
88 | SW.Send(ent->EdgeStart()); |
89 | |
90 | // --- inherited field edgeEnd --- |
91 | |
92 | SW.Send(ent->EdgeEnd()); |
93 | |
94 | // --- own field : edgeGeometry --- |
95 | |
96 | SW.Send(ent->EdgeGeometry()); |
97 | |
98 | // --- own field : sameSense --- |
99 | |
100 | SW.SendBoolean(ent->SameSense()); |
101 | } |
102 | |
103 | |
104 | void RWStepShape_RWEdgeCurve::Share(const Handle(StepShape_EdgeCurve)& ent, Interface_EntityIterator& iter) const |
105 | { |
106 | |
107 | iter.GetOneItem(ent->EdgeStart()); |
108 | |
109 | |
110 | iter.GetOneItem(ent->EdgeEnd()); |
111 | |
112 | |
113 | iter.GetOneItem(ent->EdgeGeometry()); |
114 | } |
115 | |
116 | |
117 | |
118 | void RWStepShape_RWEdgeCurve::Check |
119 | (const Handle(StepShape_EdgeCurve)& ent, |
120 | const Interface_ShareTool& aShto, |
121 | Handle(Interface_Check)& ach) const |
122 | { |
04232180 |
123 | // std::cout << "------ calling CheckEdgeCurve ------" << std::endl; |
7fd59977 |
124 | |
125 | Handle(StepShape_OrientedEdge) theOE1, theOE2; |
126 | Handle(StepShape_FaceBound) theFOB1, theFOB2; |
127 | //Handle(StepShape_FaceSurface) theFS1, theFS2; |
128 | |
129 | Standard_Boolean theOEOri1 = Standard_True; |
130 | Standard_Boolean theOEOri2 = Standard_True; |
131 | Standard_Boolean theFBOri1 = Standard_True; |
132 | Standard_Boolean theFBOri2 = Standard_True; |
133 | //Standard_Boolean theFSOri1 = Standard_True; |
134 | //Standard_Boolean theFSOri2 = Standard_True; |
135 | Standard_Boolean Cumulated1, Cumulated2; |
136 | |
137 | // 1- First Vertex != LastVertex but First VertexPoint == Last VertexPoint |
138 | // Remark : time comsuming process but useful ! |
139 | // If this append, we can drop one of the two vertices and replace it |
140 | // everywhere it is referenced. Side effect : tolerance problem !!! |
141 | |
142 | Handle(StepShape_VertexPoint) StartVertex = |
143 | Handle(StepShape_VertexPoint)::DownCast(ent->EdgeStart()); |
144 | Handle(StepShape_VertexPoint) EndVertex = |
145 | Handle(StepShape_VertexPoint)::DownCast(ent->EdgeEnd()); |
146 | |
147 | if (StartVertex != EndVertex) { |
148 | |
149 | Handle(StepGeom_CartesianPoint) StartPoint = |
150 | Handle(StepGeom_CartesianPoint)::DownCast(StartVertex->VertexGeometry()); |
151 | Handle(StepGeom_CartesianPoint) EndPoint = |
152 | Handle(StepGeom_CartesianPoint)::DownCast(EndVertex->VertexGeometry()); |
153 | |
154 | // it can also be a degenerated pcurve |
155 | |
156 | if (!StartPoint.IsNull() && !EndPoint.IsNull()) { |
157 | Standard_Real Dist = Sqrt |
158 | ((StartPoint->CoordinatesValue(1) - EndPoint->CoordinatesValue(1)) * |
159 | (StartPoint->CoordinatesValue(1) - EndPoint->CoordinatesValue(1)) + |
160 | (StartPoint->CoordinatesValue(2) - EndPoint->CoordinatesValue(2)) * |
161 | (StartPoint->CoordinatesValue(2) - EndPoint->CoordinatesValue(2)) + |
162 | (StartPoint->CoordinatesValue(3) - EndPoint->CoordinatesValue(3)) * |
163 | (StartPoint->CoordinatesValue(3) - EndPoint->CoordinatesValue(3))); |
164 | if (Dist < Precision::Confusion() ) { |
165 | ach->AddWarning("Two instances of Vertex have equal (within uncertainty) coordinates"); |
166 | } |
167 | } |
168 | } |
169 | |
170 | // 2- Two-Manifold Topology |
171 | |
172 | Standard_Boolean sharEC = aShto.IsShared(ent); |
173 | Standard_Integer nbRef; |
174 | if(!sharEC){ |
175 | ach->AddFail("ERROR: EdgeCurve not referenced"); |
176 | } |
177 | else { |
178 | Interface_EntityIterator myShRef = aShto.Sharings(ent); |
179 | myShRef.SelectType (STANDARD_TYPE(StepShape_OrientedEdge),Standard_True); |
180 | nbRef = myShRef.NbEntities(); |
181 | if (nbRef ==2) { |
182 | theOE1 = Handle(StepShape_OrientedEdge)::DownCast(myShRef.Value()); |
183 | theOEOri1 = theOE1->Orientation(); |
184 | myShRef.Next(); |
185 | theOE2 = Handle(StepShape_OrientedEdge)::DownCast(myShRef.Value()); |
186 | theOEOri2 = theOE2->Orientation(); |
187 | |
188 | // get the FaceBound orientation for theOE1 |
189 | |
190 | Standard_Boolean sharOE1 = aShto.IsShared(theOE1); |
191 | if(!sharOE1){ |
0797d9d3 |
192 | #ifdef OCCT_DEBUG |
04232180 |
193 | std::cout << "OrientedEdge1 not shared" <<std::endl; |
7fd59977 |
194 | #endif |
195 | } |
196 | else { |
197 | myShRef = aShto.Sharings(theOE1); |
198 | myShRef.SelectType (STANDARD_TYPE(StepShape_EdgeLoop),Standard_True); |
199 | nbRef = myShRef.NbEntities(); |
200 | if (nbRef == 1) { |
201 | myShRef.Start(); |
202 | Handle(StepShape_EdgeLoop) theEL1 = |
203 | Handle(StepShape_EdgeLoop)::DownCast(myShRef.Value()); |
204 | Standard_Boolean sharEL1 = aShto.IsShared(theEL1); |
205 | if(!sharEL1) { |
0797d9d3 |
206 | #ifdef OCCT_DEBUG |
04232180 |
207 | std::cout << "EdgeLoop1 not shared" <<std::endl; |
7fd59977 |
208 | #endif |
209 | } |
210 | else { |
211 | myShRef = aShto.Sharings(theEL1); |
212 | myShRef.SelectType (STANDARD_TYPE(StepShape_FaceBound),Standard_True); |
0797d9d3 |
213 | #ifdef OCCT_DEBUG |
7fd59977 |
214 | nbRef = |
215 | #endif |
216 | myShRef.NbEntities(); |
217 | myShRef.Start(); |
218 | theFOB1 = Handle(StepShape_FaceBound)::DownCast(myShRef.Value()); |
219 | if (!theFOB1.IsNull()) { |
220 | theFBOri1 = theFOB1->Orientation(); |
221 | } |
222 | else { |
0797d9d3 |
223 | #ifdef OCCT_DEBUG |
04232180 |
224 | std::cout << "EdgeLoop not referenced by FaceBound" << std::endl; |
7fd59977 |
225 | #endif |
226 | } |
227 | } |
228 | } |
229 | else { |
230 | if (nbRef == 0) { |
0797d9d3 |
231 | #ifdef OCCT_DEBUG |
04232180 |
232 | std::cout << "OrientedEdge not referenced" << std::endl; |
7fd59977 |
233 | #endif |
234 | } |
235 | else { |
236 | if (aShto.NbTypedSharings(theOE1, |
237 | STANDARD_TYPE(StepShape_EdgeLoop)) > 1) { |
0797d9d3 |
238 | #ifdef OCCT_DEBUG |
04232180 |
239 | std::cout << "OrientedEdge referenced more than once" << std::endl; |
7fd59977 |
240 | #endif |
241 | } |
242 | } |
243 | } |
244 | } |
245 | |
246 | // get the FaceBound orientation for theOE2 |
247 | |
248 | Standard_Boolean sharOE2 = aShto.IsShared(theOE2); |
249 | if(!sharOE2){ |
0797d9d3 |
250 | #ifdef OCCT_DEBUG |
04232180 |
251 | std::cout << "OrientedEdge2 not shared" <<std::endl; |
7fd59977 |
252 | #endif |
253 | } |
254 | else { |
255 | myShRef = aShto.Sharings(theOE2); |
0797d9d3 |
256 | #ifdef OCCT_DEBUG |
7fd59977 |
257 | // Standard_Integer nbRef = |
258 | #endif |
259 | // unused myShRef.NbEntities(); |
260 | myShRef.Start(); |
261 | Handle(StepShape_EdgeLoop) theEL2 = |
262 | Handle(StepShape_EdgeLoop)::DownCast(myShRef.Value()); |
263 | Standard_Boolean sharEL2 = aShto.IsShared(theEL2); |
264 | if(!sharEL2){ |
0797d9d3 |
265 | #ifdef OCCT_DEBUG |
04232180 |
266 | std::cout << "EdgeLoop2 not shared" <<std::endl; |
7fd59977 |
267 | #endif |
268 | } |
269 | else { |
270 | myShRef = aShto.Sharings(theEL2); |
271 | // unused Standard_Integer nbRef = myShRef.NbEntities(); |
272 | myShRef.Start(); |
273 | theFOB2 = Handle(StepShape_FaceBound)::DownCast(myShRef.Value()); |
274 | if (!theFOB2.IsNull()) { |
275 | theFBOri2 = theFOB2->Orientation(); |
276 | } |
277 | else { |
0797d9d3 |
278 | #ifdef OCCT_DEBUG |
04232180 |
279 | std::cout << "EdgeLoop not referenced by FaceBound" << std::endl; |
7fd59977 |
280 | #endif |
281 | } |
282 | } |
283 | } |
284 | |
285 | // "cumulate" the FaceBound and the OrientedEdge orientation |
286 | |
287 | Cumulated1 = theFBOri1 ^ theOEOri1; |
288 | Cumulated2 = theFBOri2 ^ theOEOri2; |
289 | |
290 | // the orientation of the OrientedEdges must be opposite |
291 | |
292 | if (Cumulated1 == Cumulated2) { |
293 | ach->AddFail("ERROR: non 2-manifold topology"); |
294 | } |
295 | } |
296 | } |
297 | } |
298 | |