rtcMeshSet3D.cpp

Go to the documentation of this file.

/*
 * Copyright (C) 2008
 * Robert Bosch LLC
 * Research and Technology Center North America
 * Palo Alto, California
 *
 * All rights reserved.
 *
 *------------------------------------------------------------------------------
 * project ....: Autonomous Technologies
 * file .......: MeshSet3D.cpp
 * authors ....: Benjamin Pitzer
 * organization: Robert Bosch LLC
 * creation ...: 02/29/2008
 * modified ...: $Date: 2009-02-16 15:05:05 -0800 (Mon, 16 Feb 2009) $
 * changed by .: $Author: wg75pal $
 * revision ...: $Revision: 817 $
 */

//== INCLUDES ==================================================================
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <string>
#include "rtc/rtcMeshSet3D.h"
#include "rtc/rtcBinaryInputHandler.h"
#include "rtc/rtcBinaryOutputHandler.h"

//== NAMESPACES ================================================================
namespace rtc {

// Constructor
MeshSet3D::MeshSet3D()
:IOObject(), flags(0)
{
}

MeshSet3D::MeshSet3D(const MeshSet3D& other)
:IOObject(), flags(0)
{
  set(other);
}

const MeshSet3D &MeshSet3D::operator=(const MeshSet3D& other)
{
  set(other);
  return *this;
}

// Destructor
MeshSet3D::~MeshSet3D() {
  clear();
}

int MeshSet3D::numMeshes() const
{
  return (int)meshes.size();
}

void MeshSet3D::clear()
{
  for (int i=0;i<int(meshes.size());i++) delete (meshes[i]);
  meshes.clear();
}

void MeshSet3D::set(const MeshSet3D& other)
{
  clear();
  flags = other.flags;
  VecMesh3D::const_iterator it,it_end;
  for (it=other.meshes.begin(),it_end=other.meshes.end(); it!=it_end; ++it){
    Mesh3D* mesh = new Mesh3D(*(*it));
    meshes.push_back(mesh);
  }
}

// updates the normals in all meshes
void MeshSet3D::updateNormals()
{
  for (unsigned int i=0;i<meshes.size();i++)
    meshes[i]->updateNormals();
}

bool MeshSet3D::getFlag(int flag) const
{
  return (flags&flag);
}

void MeshSet3D::setFlag(int flag, bool value)
{
  if(value)
    flags|=flag;
  else
    flags&=flag;
}

bool MeshSet3D::hasAABB() const
{
  return (flags&MESHSET3D_HAS_AABB);
}

bool MeshSet3D::write(OutputHandler &oh) const
{
  // write number of meshes
  int num_meshes = meshes.size();
  rtc_write(oh,"flags",flags);
  rtc_write(oh,"num_meshes",num_meshes);
  // write meshes
  for(unsigned int i=0;i<meshes.size();++i) {
    meshes[i]->write(oh);
  }
  if (hasAABB()) {
    topleft.write(oh);
    bottomright.write(oh);
  }
  return oh.good();
}

bool MeshSet3D::read(InputHandler &ih)
{
  // read number of meshes
  clear();
  int num_meshes;
  rtc_read(ih,"flags",flags);
  rtc_read(ih,"num_meshes",num_meshes);
  // load meshes
  for(int i=0;i<num_meshes;++i) {
    Mesh3D* mesh = new Mesh3D();
    mesh->read(ih);
    meshes.push_back(mesh);
    if(!ih.good())
      throw Exception("format error: unexpected end of file");
  }
  if (hasAABB()) {
    topleft.read(ih);
    bottomright.read(ih);
  }
  return ih.good();
}

bool MeshSet3D::writeToFile( const char* filename ) const
{
  try
  {
    rtc::BinaryOutputHandler bsh;
    std::ofstream out(filename, std::ios_base::binary);
    bsh.use(out);
    write(bsh);
  }
  catch (Exception e)
  {
    std::cout << e.getErrorMessage() << std::endl;
    return false;
  }
  return true;
}

bool MeshSet3D::readFromFile( const char* filename )
{
  // load file in binary mode
  try {
    // Open a stream in binary mode
    rtc::BinaryInputHandler bsh;
    std::ifstream in(filename,std::ios_base::binary);
    bsh.use(in);
    read(bsh);
  }
  catch (Exception e) {
    std::cout << e.getErrorMessage() << std::endl;
    return false;
  }
  return true;
}

void MeshSet3D::read( FILE *fp )
{
  size_t res = 0;
  // read number of meshes
  clear();
  int num_meshes;
  res+=fread(&flags,sizeof(flags),1,fp);
  res+=fread(&num_meshes,sizeof(num_meshes),1,fp);
  // load meshes
  for(int i=0;i<num_meshes;++i) {
    Mesh3D* mesh = new Mesh3D();
    mesh->read(fp);
    meshes.push_back(mesh);
    if(feof(fp))
      throw Exception("format error: unexpected end of file");
  }
  if (hasAABB()) {
    res+=fread(&topleft,sizeof(topleft),1,fp);
    res+=fread(&bottomright,sizeof(bottomright),1,fp);
  }
}

void MeshSet3D::write(FILE *fp) const
{
  // write number of meshes
  int num_meshes = meshes.size();
  fwrite(&flags,sizeof(flags),1,fp);
  fwrite(&num_meshes,sizeof(num_meshes),1,fp);
  // write meshes
  for(unsigned int i=0;i<meshes.size();++i) {
    meshes[i]->write(fp);
  }
  if (hasAABB()) {
    fwrite(&topleft,sizeof(topleft),1,fp);
    fwrite(&bottomright,sizeof(bottomright),1,fp);
  }
}

void MeshSet3D::loadToGPU()
{
  for (size_t i=0;i<meshes.size();i++)
    meshes[i]->loadTexture();
}

void MeshSet3D::unloadGPU()
{
  for (size_t i=0;i<meshes.size();i++)
    meshes[i]->unloadTexture();
}

//==============================================================================
} // namespace rtc
//==============================================================================