ALSceneLoader.cpp

Go to the documentation of this file.

#include <boost/algorithm/string.hpp>
#include "SO3SceneLoader/ALSceneLoader.h"
 
// boost
#include <boost/filesystem.hpp>
 
// Default load flags
// aiProcess_OptimizeGraph|aiProcess_JoinIdenticalVertices|aiProcess_FixInfacingNormals|aiProcess_MakeLeftHanded 
#define AL_ASSIMP_DEFAULT_FLAG aiProcess_ImproveCacheLocality|aiProcess_RemoveRedundantMaterials|aiProcess_Triangulate|aiProcess_SortByPType|aiProcess_FindInvalidData|aiProcess_LimitBoneWeights|aiProcess_FindDegenerates|aiProcess_FindInstances|aiProcess_CalcTangentSpace //|aiProcess_GlobalScale
#define AL_ASSIMP_ADDITIONNAL_FLAG aiProcess_TransformUVCoords|aiProcess_GenUVCoords
#define AL_ASSIMP_NULL_FLAGS aiProcess_SplitLargeMeshes|aiProcess_OptimizeMeshes
//aiProcess_ValidateDataStructure make fail point clouds
namespace SO3
{
  ALSceneLoader::ALSceneLoader(SScene* scene, std::string filename, std::string group, unsigned int flags, float scale)
  {
    mScene = scene;
    mFilename = filename;
    mGroup = group;
    mSo3Flags = flags;
    mFlags = 0;
    mScale = scale;
 
    if (mSo3Flags & so3Converter_SplitLargeMeshes)
      mFlags |= aiProcess_SplitLargeMeshes;
    
    if (mSo3Flags & so3Converter_GenSmoothNormals)
      mFlags |= aiProcess_GenSmoothNormals;
    
    if (mSo3Flags & so3Converter_OptimizeMeshes)
      mFlags |= aiProcess_OptimizeMeshes;
 
    if (mSo3Flags & so3Converter_OptimizeGraph)
      mFlags |= aiProcess_OptimizeGraph;
 
    if ((mFlags == 0) || (mFlags != 0 && !(mFlags & aiProcess_GenSmoothNormals)))
      mFlags |= aiProcess_GenNormals;
    else if (mFlags != 0)
      mFlags |= aiProcess_RemoveComponent;
  }
 
  ALSceneLoader::ALSceneLoader(std::string filename, std::string group, unsigned int flags, float scale)
  {
    mScene = 0;
    mFilename = filename;
    mGroup = group;
    mSo3Flags = flags;
    mFlags = 0;
    mScale = scale;
 
    if (mSo3Flags & so3Converter_SplitLargeMeshes)
      mFlags |= aiProcess_SplitLargeMeshes;
 
    if (mSo3Flags & so3Converter_GenSmoothNormals)
      mFlags |= aiProcess_GenSmoothNormals;
 
    if (mSo3Flags & so3Converter_OptimizeMeshes)
      mFlags |= aiProcess_OptimizeMeshes;
 
    if (mSo3Flags & so3Converter_OptimizeGraph)
      mFlags |= aiProcess_OptimizeGraph;
 
    if ((mFlags == 0) || (mFlags != 0 && !(mFlags & aiProcess_GenSmoothNormals)))
      mFlags |= aiProcess_GenNormals;
    else if (mFlags != 0)
      mFlags |= aiProcess_RemoveComponent;
  }
 
  ALSceneLoader::~ALSceneLoader()
  {
 
  }
 
  bool ALSceneLoader::loadFile(const std::string& sceneName, SNode* parent, std::vector<SNode*> &objects, std::vector<SMaterial*> &materials)
  {
    const aiScene* loadedScene = NULL;
 
    mImporter.SetPropertyInteger(AI_CONFIG_PP_SBP_REMOVE, aiPrimitiveType_LINE /*| aiPrimitiveType_POINT*/);
    //mImporter.SetPropertyInteger(AI_CONFIG_FAVOUR_SPEED, 1);
    mImporter.SetPropertyBool(AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS, true);
    //AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION
    //AI_CONFIG_IMPORT_IFC_SMOOTHING_ANGLE
    //AI_CONFIG_IMPORT_IFC_CYLINDRICAL_TESSELLATION
 
    unsigned int defFlags = AL_ASSIMP_NULL_FLAGS;
    if (mFlags != 0)
      defFlags = mFlags;
 
    if (defFlags & aiProcess_SplitLargeMeshes)
    {
      mImporter.SetPropertyInteger(AI_CONFIG_PP_SLM_TRIANGLE_LIMIT, 65535 / 3);
      mImporter.SetPropertyInteger(AI_CONFIG_PP_SLM_VERTEX_LIMIT, 65535);
    }
 
    if (defFlags & aiProcess_OptimizeMeshes)
      defFlags = defFlags | aiProcess_JoinIdenticalVertices;
 
    if ((defFlags & aiProcess_GenSmoothNormals) && (defFlags & aiProcess_RemoveComponent))
    {
      mImporter.SetPropertyFloat(AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE, 45.0f);
      mImporter.SetPropertyFloat(AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE, 30.0f);
      mImporter.SetPropertyInteger(AI_CONFIG_PP_RVC_FLAGS, aiComponent_NORMALS | aiComponent_TANGENTS_AND_BITANGENTS);
    }
 
    //always scale even if 1.0
    defFlags |= aiProcess_GlobalScale;
    mImporter.SetPropertyFloat(AI_CONFIG_GLOBAL_SCALE_FACTOR_KEY, mScale); 
 
    std::string ext = boost::filesystem::extension(mFilename);
    boost::algorithm::to_lower(ext);
 
    if (ext == ".ply")
      loadedScene = mImporter.ReadFile(to_utf8(mFilename).c_str(), AL_ASSIMP_DEFAULT_FLAG | defFlags);
    else
      loadedScene = mImporter.ReadFile(to_utf8(mFilename).c_str(), AL_ASSIMP_DEFAULT_FLAG | AL_ASSIMP_ADDITIONNAL_FLAG | defFlags);
 
    //mImporter.SetPropertyBool(AI_CONFIG_IMPORT_FBX_PRESERVE_PIVOTS, false);
 
    if (loadedScene != 0)
    {
      mALScene = ALScene(this, mScene, mGroup, loadedScene, parent, sceneName, true);
      mALScene.load(objects, materials);
      ALStringCleaner::resetUID();
      return true;
    }
    return false;
  }
 
  bool ALSceneLoader::convertFile(boost::filesystem::path expFolder, const std::string& sceneName)
  {
    const aiScene* loadedScene = NULL;
 
    mImporter.SetPropertyInteger(AI_CONFIG_PP_SBP_REMOVE, aiPrimitiveType_LINE /*| aiPrimitiveType_POINT*/);    
    //mImporter.SetPropertyInteger(AI_CONFIG_FAVOUR_SPEED, 1);
    mImporter.SetPropertyBool(AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS, true);
    //AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION
    //AI_CONFIG_IMPORT_IFC_SMOOTHING_ANGLE
    //AI_CONFIG_IMPORT_IFC_CYLINDRICAL_TESSELLATION
 
    unsigned int defFlags = AL_ASSIMP_NULL_FLAGS;
    if (mFlags != 0)
      defFlags = mFlags;
 
    if (defFlags & aiProcess_SplitLargeMeshes)
    {
      mImporter.SetPropertyInteger(AI_CONFIG_PP_SLM_TRIANGLE_LIMIT, 65535 / 3);
      mImporter.SetPropertyInteger(AI_CONFIG_PP_SLM_VERTEX_LIMIT, 65535);
    }
 
    if (defFlags & aiProcess_OptimizeMeshes)
      defFlags = defFlags | aiProcess_JoinIdenticalVertices;
 
    if ((defFlags & aiProcess_GenSmoothNormals) && (defFlags & aiProcess_RemoveComponent))
    {
      mImporter.SetPropertyFloat(AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE, 45.0f);
      mImporter.SetPropertyFloat(AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE, 30.0f);
      mImporter.SetPropertyInteger(AI_CONFIG_PP_RVC_FLAGS, aiComponent_NORMALS | aiComponent_TANGENTS_AND_BITANGENTS);
    }
 
    //always scale even if 1.0
    defFlags |= aiProcess_GlobalScale;
    mImporter.SetPropertyFloat(AI_CONFIG_GLOBAL_SCALE_FACTOR_KEY, mScale);
 
    std::string ext = boost::filesystem::extension(mFilename);
    boost::algorithm::to_lower(ext);
 
    if (ext == ".ply")
      loadedScene = mImporter.ReadFile(to_utf8(mFilename).c_str(), AL_ASSIMP_DEFAULT_FLAG | defFlags);
    else
      loadedScene = mImporter.ReadFile(to_utf8(mFilename).c_str(), AL_ASSIMP_DEFAULT_FLAG | AL_ASSIMP_ADDITIONNAL_FLAG | defFlags);
 
    if (loadedScene != 0)
    {
      createDirectory(expFolder);
      mALScene = ALScene(this, mScene, mGroup, loadedScene, 0, sceneName);
      mALScene.convert(expFolder);
      ALStringCleaner::resetUID();
 
      //MMechostr (MSKDEBUG, "ASSIMP LOG : %s\n", mImporter.GetErrorString());
      return true;
    }
    else
    {
      //MMechostr (MSKDEBUG, "ASSIMP LOG : %s\n", mImporter.GetErrorString());
      return false;
    }
  }
 
  void ALSceneLoader::createDirectory(boost::filesystem::path path)
  {
    if (!boost::filesystem::exists(path))
      boost::filesystem::create_directories(path);
 
    boost::filesystem::path texPath = path;
    texPath /= "textures";
    boost::filesystem::create_directory(texPath);
 
    boost::filesystem::path meshPath = path;
    meshPath /= "meshes";
    boost::filesystem::create_directory(meshPath);
 
    boost::filesystem::path matPath = path;
    matPath /= "materials";
    boost::filesystem::create_directory(matPath);
  }
 
  boost::filesystem::path ALSceneLoader::getFilePath()
  {
    return boost::filesystem::path(mFilename);
  }
 
}