Source/System/FileIO/STL/OSGSTLSceneFileType.cpp

   1 /*---------------------------------------------------------------------------*\
   2 *                                OpenSG                                     *
   3 *                                                                           *
   4 *                                                                           *
   5 *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
   6 *                                                                           *
   7 *                            www.opensg.org                                 *
   8 *                                                                           *
   9 *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10 *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13 *                                License                                    *
  14 *                                                                           *
  15 * This library is free software; you can redistribute it and/or modify it   *
  16 * under the terms of the GNU Library General Public License as published    *
  17 * by the Free Software Foundation, version 2.                               *
  18 *                                                                           *
  19 * This library is distributed in the hope that it will be useful, but       *
  20 * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22 * Library General Public License for more details.                          *
  23 *                                                                           *
  24 * You should have received a copy of the GNU Library General Public         *
  25 * License along with this library; if not, write to the Free Software       *
  26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27 *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30 *                                Changes                                    *
  31 *                                                                           *
  32 *                                                                           *
  33 *                                                                           *
  34 *                                                                           *
  35 *                                                                           *
  36 *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 //-------------------------------
  40 //  Includes
  41 //-------------------------------
  42
  43 #include <stdlib.h>
  44 #include <stdio.h>
  45
  46 #include "OSGConfig.h"
  47
  48 #include <iostream>
  49 #include <fstream>
  50
  51 #include "OSGLog.h"
  52
  53 #include "OSGNode.h"
  54 #include "OSGGeometry.h"
  55 #include "OSGSimpleMaterial.h"
  56 #include "OSGTypedGeoIntegralProperty.h"
  57 #include "OSGTypedGeoVectorProperty.h"
  58
  59 #include "OSGSTLSceneFileType.h"
  60
  61 OSG_USING_NAMESPACE
  62
  63 #if defined(OSG_WIN32_ICL) && !defined(OSG_CHECK_FIELDSETARG)
  64 #pragma warning (disable : 383)
  65 #endif
  66
  67
  68 /*! \class OSG::STLSceneFileType
  69     \ingroup GrpSystemFileIO
  70
  71 */
  72
  73 /*****************************
  74 *   Types
  75 *****************************/
  76 // Static Class Varible implementations:
  77
  78 const Char8            *STLSceneFileType::_suffixA[] = {"stl", "stla", "stlb"};
  79
  80
  81 STLSceneFileType  STLSceneFileType::_the(_suffixA,
  82                                         sizeof(_suffixA),
  83                                         false,
  84                                         10,
  85                                         SceneFileType::OSG_READ_SUPPORTED);
  86
  87 /*****************************
  88 *    Classvariables
  89 *****************************/
  90
  91
  92 /********************************
  93 *    Class methodes
  94 *******************************/
  95
  96
  97 /*******************************
  98 *public
  99 *******************************/
 100
 101 //----------------------------
 102 // Function name: read
 103 //----------------------------
 104 //
 105 //Parameters:
 106 //p: Scene &image, const char *fileName
 107 //GlobalVars:
 108 //g:
 109 //Returns:
 110 //r:bool
 111 // Caution
 112 //c:
 113 //Assumations:
 114 //a:
 115 //Describtions:
 116 //d: read the image from the given file
 117 //SeeAlso:
 118 //s:
 119 //
 120 //------------------------------
 121
 122 #ifdef __sgi
 123 #pragma set woff 1209
 124 #endif
 125
 126 NodeTransitPtr STLSceneFileType::read(      std::istream &is,
 127                                     const Char8        *fileNameOrExtension,
 128                                             Resolver        ) const
 129 {
 130
 131     NodeTransitPtr              root;
 132     GeometryUnrecPtr            geo;
 133     GeoPnt3fPropertyUnrecPtr    points;
 134     GeoVec3fPropertyUnrecPtr    normals;
 135     GeoIntegralPropertyUnrecPtr index;
 136     GeoIntegralPropertyUnrecPtr lens;
 137     GeoIntegralPropertyUnrecPtr type;
 138
 139     STLFaceList theFaces;
 140     std::string theName;
 141     bool        isAscii = isASCII(is, fileNameOrExtension);
 142
 143     if(isAscii)
 144     {
 145         if(!readASCII(is, theFaces, theName))
 146             return root;
 147     }
 148     else
 149     {
 150         if(!readBinary(is, theFaces, theName))
 151             return root;
 152     }
 153     if(!theFaces.empty())
 154     {
 155         geo = Geometry::create();
 156
 157         points = GeoPnt3fProperty::create();
 158         geo->setPositions(points);
 159         normals = GeoVec3fProperty::create();
 160         geo->setNormals(normals);
 161         lens = GeoUInt32Property::create();
 162         geo->setLengths(lens);
 163         lens->push_back(theFaces.size()*3);
 164         type = GeoUInt8Property::create();
 165         geo->setTypes(type);
 166         type->push_back(GL_TRIANGLES);
 167
 168         root = Node::create();
 169         //setName(root, theName.c_str());
 170
 171         GeoPnt3fProperty::StoredFieldType *fPos  = points ->editFieldPtr();
 172         GeoVec3fProperty::StoredFieldType *fNorm = normals->editFieldPtr();
 173
 174         STLFaceListIterator actIt, endIt;
 175         actIt = theFaces.begin();
 176         endIt = theFaces.end();
 177
 178         while(actIt != endIt)
 179         {
 180             fPos ->push_back(Pnt3f(actIt->v1x, actIt->v1y, actIt->v1z));
 181             fPos ->push_back(Pnt3f(actIt->v2x, actIt->v2y, actIt->v2z));
 182             fPos ->push_back(Pnt3f(actIt->v3x, actIt->v3y, actIt->v3z));
 183
 184             fNorm->push_back(Vec3f(actIt->nx,  actIt->ny,  actIt->nz));
 185             fNorm->push_back(Vec3f(actIt->nx,  actIt->ny,  actIt->nz));
 186             fNorm->push_back(Vec3f(actIt->nx,  actIt->ny,  actIt->nz));
 187
 188             ++actIt;
 189         }
 190
 191         geo->setTypes    (type);
 192         geo->setLengths  (lens);
 193         geo->setPositions(points);
 194         geo->setNormals  (normals);
 195
 196         geo->setMaterial(getDefaultMaterial());
 197
 198         root->setCore(geo);
 199     }
 200
 201     commitChanges();
 202
 203     return root;
 204 }
 205
 206 bool STLSceneFileType::isASCII(std::istream &is, const Char8* fileNameOrExtension) const
 207 {
 208     std::string theAbsName = fileNameOrExtension;
 209     std::string theExtension;
 210     int nameLength = int(theAbsName.length());
 211     SizeT separator  = theAbsName.rfind(".", nameLength);
 212     theExtension = theAbsName.substr(separator+1, nameLength-separator-1);
 213
 214     for (UInt32 i = 0; i < theExtension.length(); i++)
 215         theExtension[i] = tolower(theExtension[i]);
 216
 217     if (theExtension.compare("stla") == 0)
 218         return true;
 219     else if (theExtension.compare("stlb") == 0)
 220         return false;
 221     else
 222     {
 223         // we have to check if our file start with "solid"
 224         std::string theCheck;
 225         is >> theCheck;
 226         for (UInt32 i = 0; i< theCheck.length(); i++)
 227                 theCheck[i] = tolower(theCheck[i]);
 228
 229         is.seekg( 0, std::ios_base::beg );
 230
 231         return (theCheck.compare("solid") == 0);
 232     }
 233 }
 234
 235 bool STLSceneFileType::readASCII(std::istream &is, STLFaceList& theFaces, std::string& theName) const
 236 {
 237     FDEBUG(("STLSceneFileType::readASCII:\n"));
 238
 239     char token[9];
 240     int finished = 0;
 241     UInt32 i;
 242
 243     if(!is)
 244     return false;
 245
 246     while ((finished == 0) && (! (is.eof())))
 247     {
 248         //SceneFileHandler::the().updateReadProgress();
 249         memset(token, ' ', 9);
 250         is >> token;
 251         for (i = 0; i < strlen(token); i++)
 252         {
 253             token[i] = tolower(token[i]);
 254         }
 255         if (strcmp(token, "solid") == 0)
 256         {
 257             char tmp = is.get();
 258             if (tmp == ' ')
 259             is >> theName;
 260         }
 261         else if (strcmp(token, "facet") == 0)
 262         {
 263             STLFace tmpFace;
 264             is >> token >> tmpFace.nx >> tmpFace.ny >> tmpFace.nz;
 265             is >> token >> token;// skip "outer loop"
 266             is >> token >> tmpFace.v1x >> tmpFace.v1y >> tmpFace.v1z;
 267             is >> token >> tmpFace.v2x >> tmpFace.v2y >> tmpFace.v2z;
 268             is >> token >> tmpFace.v3x >> tmpFace.v3y >> tmpFace.v3z;
 269             is >> token;// skip "endloop"
 270             is >> token;// skip "endfacet"
 271             theFaces.push_back(tmpFace);
 272         }
 273         else if (strcmp(token, "endsolid") == 0)
 274         {
 275             finished = 1;
 276             return true;
 277         }
 278     }
 279     return false;
 280 }
 281
 282 bool STLSceneFileType::readBinary(std::istream &is, STLFaceList& theFaces, std::string& theName) const
 283 {
 284     FDEBUG(("STLSceneFileType::readBinary:\n"));
 285
 286     if(!is)
 287         return false;
 288
 289     bool   bigEndian  = osgIsBigEndian();
 290     char   name[80]   = "";
 291     UInt32 facetCount = 0;
 292     UInt32 facet      = 0;
 293
 294     is.read(&name[0], 80);  // read the header
 295     theName = name;
 296     facetCount = readUInt32(is, bigEndian);
 297
 298     for(; facet < facetCount && !is.eof(); ++facet)
 299     {
 300         //SceneFileHandler::the().updateReadProgress();
 301         // a binary facet block has 50 bytes
 302         STLFace tmpFace;
 303
 304         tmpFace.nx = readFloat(is, bigEndian);
 305         tmpFace.ny = readFloat(is, bigEndian);
 306         tmpFace.nz = readFloat(is, bigEndian);
 307
 308         tmpFace.v1x = readFloat(is, bigEndian);
 309         tmpFace.v1y = readFloat(is, bigEndian);
 310         tmpFace.v1z = readFloat(is, bigEndian);
 311
 312         tmpFace.v2x = readFloat(is, bigEndian);
 313         tmpFace.v2y = readFloat(is, bigEndian);
 314         tmpFace.v2z = readFloat(is, bigEndian);
 315
 316         tmpFace.v3x = readFloat(is, bigEndian);
 317         tmpFace.v3y = readFloat(is, bigEndian);
 318         tmpFace.v3z = readFloat(is, bigEndian);
 319
 320         theFaces.push_back(tmpFace);
 321         char buffer[2]; // offset filler
 322         is.read (&buffer[0], 2);
 323     }
 324
 325     if(facet < facetCount)
 326     {
 327         SWARNING << "STLSceneFileType::readBinary: Encountered EOF after "
 328                  << "reading [" << facet << "] facets, was expecting ["
 329                  << facetCount << "]."
 330                  << std::endl;
 331     }
 332
 333     return true;
 334 }
 335
 336 Real32 STLSceneFileType::readFloat(std::istream& is, bool bigEndian) const
 337 {
 338     Real32 result = 0.f;
 339
 340     if(bigEndian)
 341     {
 342         UInt32 buffer;
 343
 344         is.read(reinterpret_cast<char *>(&buffer), sizeof(Real32));
 345         result = osgNetToHostFP(buffer);
 346     }
 347     else
 348     {
 349         is.read(reinterpret_cast<char *>(&result), sizeof(Real32));
 350     }
 351
 352     return result;
 353 }
 354
 355 UInt32 STLSceneFileType::readUInt32(std::istream &is, bool bigEndian) const
 356 {
 357     UInt32 result = 0;
 358     char   buffer[4];
 359
 360     is.read(&buffer[0], 4);
 361     std::memcpy(reinterpret_cast<char *>(&result), buffer, 4);
 362
 363     if(bigEndian)
 364         result = osgNetToHost(result);
 365
 366     return result;
 367 }
 368
 369 #ifdef __sgi
 370 #pragma reset woff 1209
 371 #endif
 372
 373 /******************************
 374 *protected
 375 ******************************/
 376
 377
 378 /******************************
 379 *private
 380 ******************************/
 381
 382
 383 /***************************
 384 *instance methodes
 385 ***************************/
 386
 387
 388 /***************************
 389 *public
 390 ***************************/
 391
 392
 393 /**constructors & destructors**/
 394
 395
 396 STLSceneFileType::STLSceneFileType(const Char8  *suffixArray[],
 397                                         UInt16  suffixByteCount,
 398                                         bool    override,
 399                                         UInt32  overridePriority,
 400                                         UInt32  flags) :
 401     SceneFileType(suffixArray,
 402                 suffixByteCount,
 403                 override,
 404                 overridePriority,
 405                 flags)
 406 {
 407 }
 408
 409 STLSceneFileType &STLSceneFileType::the(void)
 410 {
 411     return _the;
 412 }
 413
 414 const Char8 *STLSceneFileType::getName(void) const
 415 {
 416     return "Stereolithography Geometry";
 417 }
 418
 419
 420 STLSceneFileType::~STLSceneFileType (void )
 421 {
 422     return;
 423 }
 424
 425