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
  18 #include <gp_Pnt.hxx>
  19 #include <Poly_Triangle.hxx>
  20 #include <Poly_Triangulation.hxx>
  21 #include <Standard_DomainError.hxx>
  22 #include <Standard_NullObject.hxx>
  23 #include <Standard_Type.hxx>
  24
  25 //=======================================================================
  26 //function : Poly_Triangulation
  27 //purpose  :
  28 //=======================================================================
  29 Poly_Triangulation::Poly_Triangulation(const Standard_Integer NbNodes,
  30                                        const Standard_Integer NbTriangles,
  31                                        const Standard_Boolean UVNodes) :
  32    myDeflection(0),
  33    myNbNodes(NbNodes),
  34    myNbTriangles(NbTriangles),
  35    myNodes(1, NbNodes),
  36    myTriangles(1, NbTriangles)
  37 {
  38   if (UVNodes) myUVNodes = new TColgp_HArray1OfPnt2d(1, myNbNodes);
  39 }
  40
  41 //=======================================================================
  42 //function : Poly_Triangulation
  43 //purpose  :
  44 //=======================================================================
  45
  46 Poly_Triangulation::Poly_Triangulation(const TColgp_Array1OfPnt&    Nodes,
  47                                        const Poly_Array1OfTriangle& Triangles) :
  48    myDeflection(0),
  49    myNbNodes(Nodes.Length()),
  50    myNbTriangles(Triangles.Length()),
  51    myNodes(1, Nodes.Length()),
  52    myTriangles(1, Triangles.Length())
  53 {
  54   myNodes = Nodes;
  55   myTriangles = Triangles;
  56 }
  57
  58
  59
  60 //=======================================================================
  61 //function : Poly_Triangulation
  62 //purpose  :
  63 //=======================================================================
  64
  65 Poly_Triangulation::Poly_Triangulation(const TColgp_Array1OfPnt&    Nodes,
  66                                        const TColgp_Array1OfPnt2d&  UVNodes,
  67                                        const Poly_Array1OfTriangle& Triangles) :
  68    myDeflection(0),
  69    myNbNodes(Nodes.Length()),
  70    myNbTriangles(Triangles.Length()),
  71    myNodes(1, Nodes.Length()),
  72    myTriangles(1, Triangles.Length())
  73 {
  74   myNodes = Nodes;
  75   myTriangles = Triangles;
  76   myUVNodes = new TColgp_HArray1OfPnt2d(1, myNbNodes);
  77   myUVNodes->ChangeArray1() = UVNodes;
  78 }
  79
  80 //=======================================================================
  81 //function : Copy
  82 //purpose  :
  83 //=======================================================================
  84
  85 Handle(Poly_Triangulation) Poly_Triangulation::Copy() const
  86 {
  87   Handle(Poly_Triangulation) aCopy;
  88   if (HasUVNodes())
  89     aCopy = new Poly_Triangulation(Nodes(), UVNodes(), Triangles());
  90   else
  91     aCopy = new Poly_Triangulation(Nodes(), Triangles());
  92   aCopy->Deflection(myDeflection);
  93   if (HasNormals())
  94     aCopy->myNormals = new TShort_HArray1OfShortReal(myNormals->Array1());
  95
  96   return aCopy;
  97 }
  98
  99 //=======================================================================
 100 //function : Deflection
 101 //purpose  :
 102 //=======================================================================
 103
 104 Standard_Real Poly_Triangulation::Deflection() const
 105 {
 106   return myDeflection;
 107 }
 108
 109 //=======================================================================
 110 //function : Deflection
 111 //purpose  :
 112 //=======================================================================
 113
 114 void Poly_Triangulation::Deflection(const Standard_Real D)
 115 {
 116   myDeflection = D;
 117 }
 118
 119
 120
 121 //=======================================================================
 122 //function : RemoveUVNodes
 123 //purpose  :
 124 //=======================================================================
 125
 126 void Poly_Triangulation::RemoveUVNodes()
 127 {
 128   myUVNodes.Nullify();
 129 }
 130
 131 //=======================================================================
 132 //function : Nodes
 133 //purpose  :
 134 //=======================================================================
 135
 136 const TColgp_Array1OfPnt& Poly_Triangulation::Nodes() const
 137 {
 138   return myNodes;
 139 }
 140
 141 //=======================================================================
 142 //function : ChangeNodes
 143 //purpose  :
 144 //=======================================================================
 145
 146 TColgp_Array1OfPnt& Poly_Triangulation::ChangeNodes()
 147 {
 148   return myNodes;
 149 }
 150
 151 //=======================================================================
 152 //function : UVNodes
 153 //purpose  :
 154 //=======================================================================
 155
 156 const TColgp_Array1OfPnt2d& Poly_Triangulation::UVNodes() const
 157 {
 158   return myUVNodes->Array1();
 159 }
 160
 161 //=======================================================================
 162 //function : ChangeUVNodes
 163 //purpose  :
 164 //=======================================================================
 165
 166 TColgp_Array1OfPnt2d& Poly_Triangulation::ChangeUVNodes()
 167 {
 168   return myUVNodes->ChangeArray1();
 169 }
 170
 171 //=======================================================================
 172 //function : Triangles
 173 //purpose  :
 174 //=======================================================================
 175
 176 const Poly_Array1OfTriangle& Poly_Triangulation::Triangles() const
 177 {
 178   return myTriangles;
 179 }
 180
 181 //=======================================================================
 182 //function : ChangeTriangles
 183 //purpose  :
 184 //=======================================================================
 185
 186 Poly_Array1OfTriangle& Poly_Triangulation::ChangeTriangles()
 187 {
 188   return myTriangles;
 189 }
 190
 191
 192 //=======================================================================
 193 //function : SetNormals
 194 //purpose  :
 195 //=======================================================================
 196
 197 void Poly_Triangulation::SetNormals
 198                         (const Handle(TShort_HArray1OfShortReal)& theNormals)
 199 {
 200
 201   if(theNormals.IsNull() || theNormals->Length() != 3*myNbNodes) {
 202     Standard_DomainError::Raise("Poly_Triangulation::SetNormals : wrong length");
 203   }
 204
 205   myNormals = theNormals;
 206
 207 }
 208
 209 //=======================================================================
 210 //function : Normals
 211 //purpose  :
 212 //=======================================================================
 213
 214 const TShort_Array1OfShortReal& Poly_Triangulation::Normals() const
 215 {
 216
 217   if(myNormals.IsNull() || myNormals->Length() != 3*myNbNodes) {
 218     Standard_NullObject::Raise("Poly_Triangulation::Normals : "
 219                                "wrong length or null array");
 220   }
 221
 222   return myNormals->Array1();
 223
 224 }
 225
 226 //=======================================================================
 227 //function : ChangeNormals
 228 //purpose  :
 229 //=======================================================================
 230
 231 TShort_Array1OfShortReal& Poly_Triangulation::ChangeNormals()
 232 {
 233
 234   if(myNormals.IsNull() || myNormals->Length() != 3*myNbNodes) {
 235     Standard_NullObject::Raise("Poly_Triangulation::ChangeNormals : "
 236                                "wrong length or null array");
 237   }
 238
 239   return myNormals->ChangeArray1();
 240
 241 }
 242
 243 //=======================================================================
 244 //function : HasNormals
 245 //purpose  :
 246 //=======================================================================
 247
 248 Standard_Boolean Poly_Triangulation::HasNormals() const
 249 {
 250
 251   if(myNormals.IsNull() || myNormals->Length() != 3*myNbNodes) {
 252     return Standard_False;
 253   }
 254   return Standard_True;
 255 }
 256
 257
 258