0031313: Foundation Classes - Dump improvement for classes
[occt.git] / src / Poly / Poly_Triangulation.cxx
1 // Created on: 1995-03-06
2 // Created by: Laurent PAINNOT
3 // Copyright (c) 1995-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 #include <Poly_Triangulation.hxx>
18
19 #include <gp_Pnt.hxx>
20 #include <Poly_Triangle.hxx>
21 #include <Standard_DomainError.hxx>
22 #include <Standard_Dump.hxx>
23 #include <Standard_NullObject.hxx>
24 #include <Standard_Type.hxx>
25
26 IMPLEMENT_STANDARD_RTTIEXT (Poly_Triangulation, Standard_Transient)
27
28 //=======================================================================
29 //function : Poly_Triangulation
30 //purpose  : 
31 //=======================================================================
32 Poly_Triangulation::Poly_Triangulation(const Standard_Integer theNbNodes,
33                                        const Standard_Integer theNbTriangles,
34                                        const Standard_Boolean theHasUVNodes)
35 : myDeflection(0),
36   myNodes     (1, theNbNodes),
37   myTriangles (1, theNbTriangles)
38 {
39   if (theHasUVNodes) myUVNodes = new TColgp_HArray1OfPnt2d(1, theNbNodes);
40 }
41
42 //=======================================================================
43 //function : Poly_Triangulation
44 //purpose  : 
45 //=======================================================================
46
47 Poly_Triangulation::Poly_Triangulation(const TColgp_Array1OfPnt&    theNodes,
48                                        const Poly_Array1OfTriangle& theTriangles)
49 : myDeflection(0),
50   myNodes     (1, theNodes.Length()),
51   myTriangles (1, theTriangles.Length())
52 {
53   myNodes = theNodes;
54   myTriangles = theTriangles;
55 }
56
57 //=======================================================================
58 //function : Poly_Triangulation
59 //purpose  : 
60 //=======================================================================
61
62 Poly_Triangulation::Poly_Triangulation(const TColgp_Array1OfPnt&    theNodes,
63                                        const TColgp_Array1OfPnt2d&  theUVNodes,
64                                        const Poly_Array1OfTriangle& theTriangles)
65 : myDeflection(0),
66   myNodes     (1, theNodes.Length()),
67   myTriangles (1, theTriangles.Length())
68 {
69   myNodes = theNodes;
70   myTriangles = theTriangles;
71   myUVNodes = new TColgp_HArray1OfPnt2d (1, theNodes.Length());
72   myUVNodes->ChangeArray1() = theUVNodes;
73 }
74
75 //=======================================================================
76 //function : Copy
77 //purpose  : 
78 //=======================================================================
79
80 Handle(Poly_Triangulation) Poly_Triangulation::Copy() const
81 {
82   Handle(Poly_Triangulation) aCopy;
83   if (HasUVNodes())
84     aCopy = new Poly_Triangulation(Nodes(), UVNodes(), Triangles());
85   else
86     aCopy = new Poly_Triangulation(Nodes(), Triangles());
87   aCopy->Deflection(myDeflection);
88   if (HasNormals())
89     aCopy->myNormals = new TShort_HArray1OfShortReal(myNormals->Array1());
90
91   return aCopy;
92 }
93
94 //=======================================================================
95 //function : Poly_Triangulation
96 //purpose  : 
97 //=======================================================================
98
99 Poly_Triangulation::Poly_Triangulation (const Handle(Poly_Triangulation)& theTriangulation)
100 : myDeflection ( theTriangulation->myDeflection ),
101   myNodes(theTriangulation->Nodes()),
102   myTriangles(theTriangulation->Triangles())
103 {
104   if (theTriangulation->HasUVNodes())
105   {
106     myUVNodes = new TColgp_HArray1OfPnt2d(theTriangulation->myUVNodes->Array1());
107   }
108   if (theTriangulation->HasNormals())
109   {
110     myNormals = new TShort_HArray1OfShortReal(theTriangulation->myNormals->Array1());
111   }
112 }
113
114 //=======================================================================
115 //function : Deflection
116 //purpose  : 
117 //=======================================================================
118
119 void Poly_Triangulation::Deflection(const Standard_Real theDeflection)
120 {
121   myDeflection = theDeflection;
122 }
123
124 //=======================================================================
125 //function : RemoveUVNodes
126 //purpose  : 
127 //=======================================================================
128
129 void Poly_Triangulation::RemoveUVNodes()
130 {
131   myUVNodes.Nullify();
132 }
133
134 //=======================================================================
135 //function : Node
136 //purpose  : 
137 //=======================================================================
138
139 const gp_Pnt& Poly_Triangulation::Node (const Standard_Integer theIndex) const
140 {
141   if (theIndex < 1 || theIndex > myNodes.Size())
142   {
143     throw Standard_OutOfRange ("Poly_Triangulation::Node : index out of range");
144   }
145   return myNodes.Value (theIndex);
146 }
147
148 //=======================================================================
149 //function : ChangeNode
150 //purpose  : 
151 //=======================================================================
152
153 gp_Pnt& Poly_Triangulation::ChangeNode (const Standard_Integer theIndex)
154 {
155   if (theIndex < 1 || theIndex > myNodes.Size())
156   {
157     throw Standard_OutOfRange ("Poly_Triangulation::ChangeNode : index out of range");
158   }
159   return myNodes.ChangeValue (theIndex);
160 }
161
162 //=======================================================================
163 //function : UVNode
164 //purpose  : 
165 //=======================================================================
166
167 const gp_Pnt2d& Poly_Triangulation::UVNode (const Standard_Integer theIndex) const
168 {
169   if (myUVNodes.IsNull() || theIndex < 1 || theIndex > myUVNodes->Size())
170   {
171     throw Standard_OutOfRange ("Poly_Triangulation::UVNode : index out of range");
172   }
173   return myUVNodes->Value (theIndex);
174 }
175
176 //=======================================================================
177 //function : ChangeUVNode
178 //purpose  : 
179 //=======================================================================
180
181 gp_Pnt2d& Poly_Triangulation::ChangeUVNode (const Standard_Integer theIndex)
182 {
183   if (myUVNodes.IsNull() || theIndex < 1 || theIndex > myUVNodes->Size())
184   {
185     throw Standard_OutOfRange ("Poly_Triangulation::ChangeUVNode : index out of range");
186   }
187   return myUVNodes->ChangeValue (theIndex);
188 }
189
190 //=======================================================================
191 //function : Triangle
192 //purpose  : 
193 //=======================================================================
194
195 const Poly_Triangle& Poly_Triangulation::Triangle (const Standard_Integer theIndex) const
196 {
197   if (theIndex < 1 || theIndex > myTriangles.Size())
198   {
199     throw Standard_OutOfRange ("Poly_Triangulation::Triangle : index out of range");
200   }
201   return myTriangles.Value (theIndex);
202 }
203
204 //=======================================================================
205 //function : ChangeTriangle
206 //purpose  : 
207 //=======================================================================
208
209 Poly_Triangle& Poly_Triangulation::ChangeTriangle (const Standard_Integer theIndex)
210 {
211   if (theIndex < 1 || theIndex > myTriangles.Size())
212   {
213     throw Standard_OutOfRange ("Poly_Triangulation::ChangeTriangle : index out of range");
214   }
215   return myTriangles.ChangeValue (theIndex);
216 }
217
218 //=======================================================================
219 //function : SetNormals
220 //purpose  : 
221 //=======================================================================
222
223 void Poly_Triangulation::SetNormals (const Handle(TShort_HArray1OfShortReal)& theNormals)
224 {
225
226   if(theNormals.IsNull() || theNormals->Length() != 3 * NbNodes()) {
227     throw Standard_DomainError("Poly_Triangulation::SetNormals : wrong length");
228   }
229
230   myNormals = theNormals;
231 }
232
233 //=======================================================================
234 //function : Normals
235 //purpose  : 
236 //=======================================================================
237
238 const TShort_Array1OfShortReal& Poly_Triangulation::Normals() const
239 {
240
241   if(myNormals.IsNull() || myNormals->Length() != 3 * NbNodes()) {
242     throw Standard_NullObject("Poly_Triangulation::Normals : "
243                               "wrong length or null array");
244   }
245
246   return myNormals->Array1();
247 }
248
249 //=======================================================================
250 //function : ChangeNormals
251 //purpose  : 
252 //=======================================================================
253
254 TShort_Array1OfShortReal& Poly_Triangulation::ChangeNormals()
255 {
256
257   if(myNormals.IsNull() || myNormals->Length() != 3 * NbNodes()) {
258     throw Standard_NullObject("Poly_Triangulation::ChangeNormals : "
259                               "wrong length or null array");
260   }
261
262   return myNormals->ChangeArray1();
263 }
264
265 //=======================================================================
266 //function : HasNormals
267 //purpose  : 
268 //=======================================================================
269
270 Standard_Boolean Poly_Triangulation::HasNormals() const
271 {
272   if(myNormals.IsNull() || myNormals->Length() != 3 * NbNodes()) {
273     return Standard_False;
274   }
275   return Standard_True;
276 }
277
278 //=======================================================================
279 //function : SetNormal
280 //purpose  : 
281 //=======================================================================
282
283 void Poly_Triangulation::SetNormal (const Standard_Integer theIndex, const gp_Dir& theNormal)
284 {
285   if (myNormals.IsNull() || theIndex < 1 || theIndex > myNodes.Size())
286   {
287     throw Standard_NullObject ("Poly_Triangulation::SetNormal : empty array or index out of range");
288   }
289
290   myNormals->ChangeValue (theIndex * 3 - 2) = (Standard_ShortReal) theNormal.X();
291   myNormals->ChangeValue (theIndex * 3 - 1) = (Standard_ShortReal) theNormal.Y();
292   myNormals->ChangeValue (theIndex * 3)     = (Standard_ShortReal) theNormal.Z();
293 }
294
295 //=======================================================================
296 //function : Normal
297 //purpose  : 
298 //=======================================================================
299
300 gp_Dir Poly_Triangulation::Normal (const Standard_Integer theIndex) const
301 {
302   if (myNormals.IsNull() || theIndex < 1 || theIndex > myNodes.Size())
303   {
304     throw Standard_NullObject ("Poly_Triangulation::Normal : empty array or index out of range");
305   }
306
307   gp_Dir N(myNormals->Value(theIndex * 3 - 2),
308            myNormals->Value(theIndex * 3 - 1),
309            myNormals->Value(theIndex * 3));
310
311   return N;
312 }
313
314 // =======================================================================
315 // function : DumpJson
316 // purpose  :
317 // =======================================================================
318 void Poly_Triangulation::DumpJson (Standard_OStream& theOStream, Standard_Integer) const
319 {
320   OCCT_DUMP_TRANSIENT_CLASS_BEGIN (theOStream)
321
322   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myDeflection)
323
324   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myNodes.Size())
325   if (!myUVNodes.IsNull())
326     OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myUVNodes->Size())
327   if (!myNormals.IsNull())
328     OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myNormals->Size())
329   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myTriangles.Size())
330 }