b311480e |
1 | // Created by: CKY / Contract Toubro-Larsen |
2 | // Copyright (c) 1993-1999 Matra Datavision |
973c2be1 |
3 | // Copyright (c) 1999-2014 OPEN CASCADE SAS |
b311480e |
4 | // |
973c2be1 |
5 | // This file is part of Open CASCADE Technology software library. |
7fd59977 |
6 | // |
d5f74e42 |
7 | // This library is free software; you can redistribute it and/or modify it under |
8 | // the terms of the GNU Lesser General Public License version 2.1 as published |
973c2be1 |
9 | // by the Free Software Foundation, with special exception defined in the file |
10 | // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT |
11 | // distribution for complete text of the license and disclaimer of any warranty. |
7fd59977 |
12 | // |
973c2be1 |
13 | // Alternatively, this file may be used under the terms of Open CASCADE |
14 | // commercial license or contractual agreement. |
b311480e |
15 | |
16 | //-------------------------------------------------------------------- |
7fd59977 |
17 | //-------------------------------------------------------------------- |
18 | |
42cf5bc1 |
19 | #include <IGESData_DirChecker.hxx> |
7fd59977 |
20 | #include <IGESData_Dump.hxx> |
42cf5bc1 |
21 | #include <IGESData_IGESDumper.hxx> |
22 | #include <IGESData_IGESReaderData.hxx> |
23 | #include <IGESData_IGESWriter.hxx> |
24 | #include <IGESData_ParamCursor.hxx> |
25 | #include <IGESData_ParamReader.hxx> |
26 | #include <IGESGeom_SplineCurve.hxx> |
27 | #include <IGESGeom_ToolSplineCurve.hxx> |
28 | #include <Interface_Check.hxx> |
29 | #include <Interface_CopyTool.hxx> |
30 | #include <Interface_EntityIterator.hxx> |
7fd59977 |
31 | #include <Interface_Macros.hxx> |
42cf5bc1 |
32 | #include <Interface_ShareTool.hxx> |
7fd59977 |
33 | #include <Message_Msg.hxx> |
42cf5bc1 |
34 | #include <Standard_DomainError.hxx> |
35 | #include <TColStd_HArray1OfReal.hxx> |
36 | #include <TColStd_HArray2OfReal.hxx> |
7fd59977 |
37 | |
42cf5bc1 |
38 | #include <stdio.h> |
39 | // MGE 29/07/98 |
7fd59977 |
40 | IGESGeom_ToolSplineCurve::IGESGeom_ToolSplineCurve () { } |
41 | |
42 | |
43 | void IGESGeom_ToolSplineCurve::ReadOwnParams |
44 | (const Handle(IGESGeom_SplineCurve)& ent, |
45 | const Handle(IGESData_IGESReaderData)& /* IR */, IGESData_ParamReader& PR) const |
46 | { |
47 | // MGE 29/07/98 |
48 | // Building of messages |
49 | |
50 | //Standard_Boolean st; //szv#4:S4163:12Mar99 not needed |
51 | Standard_Integer nbSegments; |
8c2d3314 |
52 | Standard_Integer aType, aDegree, nbDimensions; |
7fd59977 |
53 | Handle(TColStd_HArray1OfReal) allBreakPoints; |
54 | Handle(TColStd_HArray2OfReal) allXPolynomials; |
55 | Handle(TColStd_HArray2OfReal) allYPolynomials; |
56 | Handle(TColStd_HArray2OfReal) allZPolynomials; |
57 | Handle(TColStd_HArray1OfReal) allXvalues = new TColStd_HArray1OfReal(1, 4); |
58 | Handle(TColStd_HArray1OfReal) allYvalues = new TColStd_HArray1OfReal(1, 4); |
59 | Handle(TColStd_HArray1OfReal) allZvalues = new TColStd_HArray1OfReal(1, 4); |
60 | |
61 | //szv#4:S4163:12Mar99 `st=` not needed |
62 | if (!PR.ReadInteger(PR.Current(), aType)){ |
63 | Message_Msg Msg91("XSTEP_91"); |
64 | PR.SendFail(Msg91); |
65 | } |
66 | if (!PR.ReadInteger(PR.Current(), aDegree)){ |
67 | Message_Msg Msg92("XSTEP_92"); |
68 | PR.SendFail(Msg92); |
69 | } |
70 | if (!PR.ReadInteger(PR.Current(), nbDimensions)){ |
71 | Message_Msg Msg93("XSTEP_93"); |
72 | PR.SendFail(Msg93); |
73 | } |
74 | //st = PR.ReadInteger(PR.Current(), Msg94, nbSegments); //szv#4:S4163:12Mar99 moved in if |
75 | |
76 | /* |
77 | st = PR.ReadInteger(PR.Current(), "Spline Type", aType); |
78 | st = PR.ReadInteger(PR.Current(), "Degree Continuity", aDegree); |
79 | st = PR.ReadInteger(PR.Current(), "Number Of Dimensions", nbDimensions); |
80 | st = PR.ReadInteger(PR.Current(), "Number Of Segments", nbSegments); |
81 | */ |
82 | if (PR.ReadInteger(PR.Current(), nbSegments)) { |
83 | if (nbSegments <= 0){ |
84 | Message_Msg Msg94("XSTEP_94"); |
85 | PR.SendFail(Msg94); |
86 | } |
87 | else { |
88 | allXPolynomials = new TColStd_HArray2OfReal (1, nbSegments, 1, 4); |
89 | allYPolynomials = new TColStd_HArray2OfReal (1, nbSegments, 1, 4); |
90 | allZPolynomials = new TColStd_HArray2OfReal (1, nbSegments, 1, 4); |
91 | allBreakPoints = new TColStd_HArray1OfReal (1, (nbSegments + 1)); |
92 | } |
93 | Message_Msg Msg95("XSTEP_95"); |
94 | PR.ReadReals(PR.CurrentList(nbSegments + 1), Msg95, allBreakPoints); //szv#4:S4163:12Mar99 `st=` not needed |
95 | /* |
96 | st = PR.ReadReals(PR.CurrentList(nbSegments + 1), "Break Points", |
97 | allBreakPoints); |
98 | */ |
99 | } |
100 | else{ |
101 | Message_Msg Msg94("XSTEP_94"); |
102 | PR.SendFail(Msg94); |
103 | } |
104 | |
105 | Handle(TColStd_HArray1OfReal) temp; |
106 | temp = new TColStd_HArray1OfReal(1,4); |
107 | |
108 | if (! allXPolynomials.IsNull()) { |
109 | Standard_Integer I; |
110 | for (I = 1; I <= nbSegments; I++) |
111 | { |
112 | //st = PR.ReadReals(PR.CurrentList(4),"X-Coordinate Polynomial",temp); //szv#4:S4163:12Mar99 moved in if |
113 | if (PR.ReadReals(PR.CurrentList(4),"X-Coordinate Polynomial",temp)) { |
114 | Standard_Integer J; |
115 | for (J = 1; J <= 4; J++) |
116 | allXPolynomials->SetValue(I, J, temp->Value(J)); |
117 | } |
118 | |
119 | //st = PR.ReadReals(PR.CurrentList(4),"Y-Coordinate Polynomial",temp); //szv#4:S4163:12Mar99 moved in if |
120 | if (PR.ReadReals(PR.CurrentList(4),"Y-Coordinate Polynomial",temp)) { |
121 | Standard_Integer J; |
122 | for (J = 1; J <= 4; J++) |
123 | allYPolynomials->SetValue(I, J, temp->Value(J)); |
124 | } |
125 | |
126 | //st = PR.ReadReals(PR.CurrentList(4),"Z-Coordinate Polynomial",temp); //szv#4:S4163:12Mar99 moved in if |
127 | if (PR.ReadReals(PR.CurrentList(4),"Z-Coordinate Polynomial",temp)) { |
128 | Standard_Integer J; |
129 | for (J = 1; J <= 4; J++) |
130 | allZPolynomials->SetValue(I, J, temp->Value(J)); |
131 | } |
132 | } |
133 | } |
134 | |
135 | //st = PR.ReadReals(PR.CurrentList(4), "TerminatePoint X-Values", temp); //szv#4:S4163:12Mar99 moved in if |
136 | if (PR.ReadReals(PR.CurrentList(4), "TerminatePoint X-Values", temp)) { |
137 | Standard_Integer J; |
138 | for (J = 1; J <= 4; J++) |
139 | allXvalues->SetValue(J, temp->Value(J)); |
140 | } |
141 | |
142 | //st = PR.ReadReals(PR.CurrentList(4), "TerminatePoint Y-Values", temp); //szv#4:S4163:12Mar99 moved in if |
143 | if (PR.ReadReals(PR.CurrentList(4), "TerminatePoint Y-Values", temp)) { |
144 | Standard_Integer J; |
145 | for (J = 1; J <= 4; J++) |
146 | allYvalues->SetValue(J, temp->Value(J)); |
147 | } |
148 | |
149 | //st = PR.ReadReals(PR.CurrentList(4), "TerminatePoint Z-Values", temp); //szv#4:S4163:12Mar99 moved in if |
150 | if (PR.ReadReals(PR.CurrentList(4), "TerminatePoint Z-Values", temp)) { |
151 | Standard_Integer J; |
152 | for (J = 1; J <= 4; J++) |
153 | allZvalues->SetValue(J, temp->Value(J)); |
154 | } |
155 | |
156 | //sln 28.09.2001, BUC61004, If the condition is true function ent->Init is not called in order to avoid exception |
157 | if(allBreakPoints.IsNull() || allXPolynomials.IsNull() || allYPolynomials.IsNull() || allZPolynomials.IsNull()) |
158 | return; |
159 | else |
160 | { |
161 | DirChecker(ent).CheckTypeAndForm(PR.CCheck(),ent); |
162 | ent->Init |
163 | (aType, aDegree, nbDimensions, allBreakPoints, |
164 | allXPolynomials, allYPolynomials, allZPolynomials, |
165 | allXvalues, allYvalues, allZvalues); |
166 | } |
167 | } |
168 | |
169 | void IGESGeom_ToolSplineCurve::WriteOwnParams |
170 | (const Handle(IGESGeom_SplineCurve)& ent, IGESData_IGESWriter& IW) const |
171 | { |
172 | IW.Send(ent->SplineType()); |
173 | IW.Send(ent->Degree()); |
174 | IW.Send(ent->NbDimensions()); |
175 | Standard_Integer nbSegments = ent->NbSegments(); |
176 | IW.Send(nbSegments); |
177 | |
178 | Standard_Integer I; |
179 | for (I = 1; I <= nbSegments + 1; I++) |
180 | IW.Send(ent->BreakPoint(I)); |
181 | Standard_Real AX,BX,CX,DX, AY,BY,CY,DY, AZ,BZ,CZ,DZ; |
182 | for (I = 1; I <= nbSegments; I++) { |
183 | //no need to declare (hides the same name in an outer scope) |
184 | // Standard_Real AX,BX,CX,DX, AY,BY,CY,DY, AZ,BZ,CZ,DZ; |
185 | ent->XCoordPolynomial(I,AX,BX,CX,DX); |
186 | ent->YCoordPolynomial(I,AY,BY,CY,DY); |
187 | ent->ZCoordPolynomial(I,AZ,BZ,CZ,DZ); |
188 | IW.Send(AX); IW.Send(BX); IW.Send(CX); IW.Send(DX); |
189 | IW.Send(AY); IW.Send(BY); IW.Send(CY); IW.Send(DY); |
190 | IW.Send(AZ); IW.Send(BZ); IW.Send(CZ); IW.Send(DZ); |
191 | } |
192 | ent->XValues(AX,BX,CX,DX); |
193 | ent->YValues(AY,BY,CY,DY); |
194 | ent->ZValues(AZ,BZ,CZ,DZ); |
195 | IW.Send(AX); IW.Send(BX); IW.Send(CX); IW.Send(DX); |
196 | IW.Send(AY); IW.Send(BY); IW.Send(CY); IW.Send(DY); |
197 | IW.Send(AZ); IW.Send(BZ); IW.Send(CZ); IW.Send(DZ); |
198 | } |
199 | |
200 | void IGESGeom_ToolSplineCurve::OwnShared |
201 | (const Handle(IGESGeom_SplineCurve)& /* ent */, Interface_EntityIterator& /* iter */) const |
202 | { |
203 | } |
204 | |
205 | void IGESGeom_ToolSplineCurve::OwnCopy |
206 | (const Handle(IGESGeom_SplineCurve)& another, |
207 | const Handle(IGESGeom_SplineCurve)& ent, Interface_CopyTool& /* TC */) const |
208 | { |
209 | Standard_Integer I; |
210 | Standard_Real A, B, C, D; |
211 | Standard_Integer aType = another->SplineType(); |
212 | Standard_Integer aDegree = another->Degree(); |
213 | Standard_Integer nbDimensions = another->NbDimensions(); |
214 | Standard_Integer nbSegments = another->NbSegments(); |
215 | |
216 | Handle(TColStd_HArray1OfReal) allBreakPoints = |
217 | new TColStd_HArray1OfReal(1, nbSegments+1); |
218 | for (I = 1; I <= (nbSegments + 1); I++) |
219 | allBreakPoints->SetValue(I, another->BreakPoint(I)); |
220 | |
221 | Handle(TColStd_HArray2OfReal) allXPolynomials = |
222 | new TColStd_HArray2OfReal(1, nbSegments, 1, 4); |
223 | Handle(TColStd_HArray2OfReal) allYPolynomials = |
224 | new TColStd_HArray2OfReal(1, nbSegments, 1, 4); |
225 | Handle(TColStd_HArray2OfReal) allZPolynomials = |
226 | new TColStd_HArray2OfReal(1, nbSegments, 1, 4); |
227 | |
228 | for (I = 1; I <= nbSegments; I++) { |
229 | another->XCoordPolynomial(I, A, B, C, D); |
230 | allXPolynomials->SetValue(I, 1, A); |
231 | allXPolynomials->SetValue(I, 2, B); |
232 | allXPolynomials->SetValue(I, 3, C); |
233 | allXPolynomials->SetValue(I, 4, D); |
234 | |
235 | another->YCoordPolynomial(I, A, B, C, D); |
236 | allYPolynomials->SetValue(I, 1, A); |
237 | allYPolynomials->SetValue(I, 2, B); |
238 | allYPolynomials->SetValue(I, 3, C); |
239 | allYPolynomials->SetValue(I, 4, D); |
240 | |
241 | another->ZCoordPolynomial(I, A, B, C, D); |
242 | allZPolynomials->SetValue(I, 1, A); |
243 | allZPolynomials->SetValue(I, 2, B); |
244 | allZPolynomials->SetValue(I, 3, C); |
245 | allZPolynomials->SetValue(I, 4, D); |
246 | } |
247 | |
248 | Handle(TColStd_HArray1OfReal) allXvalues = |
249 | new TColStd_HArray1OfReal(1, 4); |
250 | Handle(TColStd_HArray1OfReal) allYvalues = |
251 | new TColStd_HArray1OfReal(1, 4); |
252 | Handle(TColStd_HArray1OfReal) allZvalues = |
253 | new TColStd_HArray1OfReal(1, 4); |
254 | |
255 | another->XValues(A, B, C, D); |
256 | allXvalues->SetValue(1, A); |
257 | allXvalues->SetValue(2, B); |
258 | allXvalues->SetValue(3, C); |
259 | allXvalues->SetValue(4, D); |
260 | |
261 | another->YValues(A, B, C, D); |
262 | allYvalues->SetValue(1, A); |
263 | allYvalues->SetValue(2, B); |
264 | allYvalues->SetValue(3, C); |
265 | allYvalues->SetValue(4, D); |
266 | |
267 | another->ZValues(A, B, C, D); |
268 | allZvalues->SetValue(1, A); |
269 | allZvalues->SetValue(2, B); |
270 | allZvalues->SetValue(3, C); |
271 | allZvalues->SetValue(4, D); |
272 | |
273 | ent->Init(aType, aDegree, nbDimensions, allBreakPoints, |
274 | allXPolynomials, allYPolynomials, allZPolynomials, |
275 | allXvalues, allYvalues, allZvalues); |
276 | } |
277 | |
278 | |
279 | IGESData_DirChecker IGESGeom_ToolSplineCurve::DirChecker |
280 | (const Handle(IGESGeom_SplineCurve)& /* ent */ ) const |
281 | { |
282 | IGESData_DirChecker DC(112, 0); |
283 | DC.Structure(IGESData_DefVoid); |
284 | DC.LineFont(IGESData_DefAny); |
285 | // DC.LineWeight(IGESData_DefValue); |
286 | DC.Color(IGESData_DefAny); |
287 | DC.HierarchyStatusIgnored(); |
288 | |
289 | return DC; |
290 | } |
291 | |
292 | void IGESGeom_ToolSplineCurve::OwnCheck |
293 | (const Handle(IGESGeom_SplineCurve)& ent, |
294 | const Interface_ShareTool& , Handle(Interface_Check)& ach) const |
295 | { |
296 | // MGE 29/07/98 |
297 | // Building of messages |
298 | |
299 | if (ent->SplineType() < 1 || ent->SplineType() > 6){ |
300 | Message_Msg Msg91("XSTEP_91"); |
301 | ach->SendFail(Msg91); |
302 | } |
303 | if (ent->NbDimensions() == 2) { |
304 | Standard_Integer nbSegments = ent->NbSegments(); |
305 | Standard_Real AZ,BZ,CZ,DZ; |
306 | Message_Msg Msg96("XSTEP_96"); |
307 | for (Standard_Integer I = 1; I <= nbSegments; I ++) { |
308 | ent->ZCoordPolynomial(I,AZ,BZ,CZ,DZ); |
309 | if (BZ != 0 || CZ != 0 || DZ != 0) { |
310 | ach->SendFail(Msg96); |
311 | } |
312 | } |
313 | } |
314 | else if (ent->NbDimensions() != 3){ |
315 | Message_Msg Msg93("XSTEP_93"); |
316 | ach->SendFail(Msg93); |
317 | } |
318 | } |
319 | |
320 | void IGESGeom_ToolSplineCurve::OwnDump |
321 | (const Handle(IGESGeom_SplineCurve)& ent, const IGESData_IGESDumper& /* dumper */, |
0ebe5b0a |
322 | Standard_OStream& S, const Standard_Integer level) const |
7fd59977 |
323 | { |
0ebe5b0a |
324 | S << "IGESGeom_SplineCurve\n"; |
7fd59977 |
325 | |
326 | Standard_Integer nbSegments = ent->NbSegments(); |
327 | S << "Spline Type : " << ent->SplineType() << " "; |
328 | switch (ent->SplineType()) |
329 | { |
330 | case 1 : S << "(Linear)"; break; |
331 | case 2 : S << "(Quadratic)"; break; |
332 | case 3 : S << "(Cubic)"; break; |
333 | case 4 : S << "(Wilson-Fowler)"; break; |
334 | case 5 : S << "(Modified Wison-Fowler)"; break; |
335 | case 6 : S << "(B-Spline)"; break; |
336 | default : S << "(Invalid value)"; break; |
337 | } |
0ebe5b0a |
338 | S << "\n" |
339 | << "Degree Of Continuity : " << ent->Degree() << "\n" |
340 | << "Number Of Dimensions : " << ent->NbDimensions() << "\n" |
341 | << "Number Of Segments : " << ent->NbSegments() << "\n" |
342 | << "Segment Break Points : "; |
343 | IGESData_DumpVals(S,level,1, nbSegments+1,ent->BreakPoint); |
7fd59977 |
344 | if (level <= 4) { |
0ebe5b0a |
345 | S << " [ also ask level > 4 for X-Y-Z Polynomials ]" << std::endl; |
7fd59977 |
346 | return; |
347 | } |
0ebe5b0a |
348 | S << " -- Polynomial Values --\n"; |
7fd59977 |
349 | Standard_Real AX,BX,CX,DX, AY,BY,CY,DY, AZ,BZ,CZ,DZ; |
350 | for (Standard_Integer I = 1; I <= nbSegments; I++) { |
351 | //no need to declare (hides the same name in an outer scope) |
352 | // Standard_Real AX,BX,CX,DX, AY,BY,CY,DY, AZ,BZ,CZ,DZ; |
353 | ent->XCoordPolynomial(I,AX,BX,CX,DX); |
354 | ent->YCoordPolynomial(I,AY,BY,CY,DY); |
355 | ent->ZCoordPolynomial(I,AZ,BZ,CZ,DZ); |
0ebe5b0a |
356 | S << "Segment "<<I<<" : X Y Z"<<"\n" |
357 | << " A ... "<<AX<<" "<<AY<<" "<<AZ<<"\n" |
358 | << " B ... "<<BX<<" "<<BY<<" "<<BZ<<"\n" |
359 | << " C ... "<<CX<<" "<<CY<<" "<<CZ<<"\n" |
360 | << " D ... "<<DX<<" "<<DY<<" "<<DZ<<"\n"; |
7fd59977 |
361 | } |
362 | ent->XValues(AX,BX,CX,DX); |
363 | ent->YValues(AY,BY,CY,DY); |
364 | ent->ZValues(AZ,BZ,CZ,DZ); |
0ebe5b0a |
365 | S << "Terminate Point : X Y Z"<<"\n" |
366 | << " Value "<<AX<<" "<<AY<<" "<<AZ<<"\n" |
367 | << " 1st Derivative "<<BX<<" "<<BY<<" "<<BZ<<"\n" |
368 | << " 2nd Der./2! "<<CX<<" "<<CY<<" "<<CZ<<"\n" |
369 | << " 3rd Der./3! "<<DX<<" "<<DY<<" "<<DZ<<std::endl; |
7fd59977 |
370 | } |