IOWavefrontOBJ.hpp

/*---------------------------------------------------------------------------*\
 *
 *  mimmo
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of mimmo.
 *
 *  mimmo is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  mimmo is distributed in the hope that it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
 *  License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with mimmo. If not, see <http://www.gnu.org/licenses/>.
 *
\*---------------------------------------------------------------------------*/
 
#ifndef __IOWAVEFRONTOBJ__HPP__
#define __IOWAVEFRONTOBJ__HPP__
 
#include <BaseManipulation.hpp>
 
namespace mimmo{
 
class WavefrontOBJData{
 
    friend class IOWavefrontOBJ;
 
public:
 
    //data
    MimmoPiercedVector<std::string> materials; 
    MimmoPiercedVector<long> smoothids; 
    MimmoPiercedVector<std::string> cellgroups; 
    MimmoSharedPointer<MimmoObject> textures; 
    MimmoSharedPointer<MimmoObject> normals; 
    //list
    std::unordered_map<std::string, long> materialsList; 
    std::unordered_map<std::string, long> smoothidsList; 
    std::unordered_map<std::string, long> cellgroupsList; 
    std::unordered_map<long, std::string> inv_materialsList; 
    std::unordered_map<long, std::string> inv_smoothidsList; 
    std::unordered_map<long, std::string> inv_cellgroupsList; 
    // accessory info
    std::string materialfile; 
    MimmoSharedPointer<MimmoObject> refGeometry; 
    WavefrontOBJData();
    virtual ~WavefrontOBJData(){};
 
    void swap(WavefrontOBJData &x) noexcept;
    void syncListsOnData();
    void autoCompleteCellFields();
 
protected:
 
    void dump(std::ostream & out);
    void restore(std::istream & out);
 
};
 
class ManipulateWFOBJData: public mimmo::BaseManipulation{
 
public:
    enum class OverlapAnnotationMode{
        HARD = 0,  
        SOFT = 1,  
        GETALL = 2,    
        GETALLNOBLANKS = 3    
    };
 
    enum class NormalsComputeMode{
        FLAT_BITPIT = 0,  
        AREA_WEIGHTED = 1,  
        ANGLE_WEIGHTED = 2  
    };
 
    ManipulateWFOBJData();
    virtual ~ManipulateWFOBJData();
    ManipulateWFOBJData(const bitpit::Config::Section & rootXML);
 
    WavefrontOBJData*       getData();
    bool                    getCheckNormalsMagnitude();
    OverlapAnnotationMode   getMultipleAnnotationStrategy();
    NormalsComputeMode      getNormalsComputeStrategy();
 
    std::vector<long>      getPinnedObjectGroup();
    std::vector<long>      getPinnedMaterialGroup();
    std::vector<long>      getPinnedCellGroup();
    std::vector<long>      getPinnedSmoothGroup();
 
    void    setRecomputeNormalsCells(MimmoPiercedVector<long>* cellList);
    void    setData(WavefrontOBJData* data);
    void    addAnnotation(MimmoPiercedVector<long>* annotation);
 
    void    setCheckNormalsMagnitude(bool flag);
    void    setMultipleAnnotationStrategy(OverlapAnnotationMode mode);
    void    setNormalsComputeStrategy(NormalsComputeMode mode);
 
    void    setPinObjects(const std::vector<std::string> & objectsList);
    void    setPinMaterials(const std::vector<std::string> & materialsList);
    void    setPinCellGroups(const std::vector<std::string> & cellgroupsList);
    void    setPinSmoothIds(const std::vector<int> & smoothidsList);
 
    void clearAnnotations();
    void clearRecomputeNormalsCells();
    void clearPinLists();
    void clear();
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name = "");
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name= "");
 
    void    execute();
 
protected:
    void swap(ManipulateWFOBJData & x) noexcept;
    void buildPorts();
 
    void computeAnnotations();
    void computeNormals();
    void checkNormalsMagnitude();
    void extractPinnedLists();
 
    std::array<double,3> evalVNormal(bitpit::SurfaceKernel * mesh, long idCell, int locVertex);
 
    WavefrontOBJData * m_extData; 
    MimmoPiercedVector<long> m_normalsCells; 
    std::vector<MimmoPiercedVector<long> > m_annotations; 
    bool m_checkNormalsMag; 
    OverlapAnnotationMode m_annMode; 
    NormalsComputeMode m_normalsMode; 
    std::unordered_set<std::string> m_pinObjects; 
    std::unordered_set<std::string> m_pinMaterials; 
    std::unordered_set<std::string> m_pinCellGroups; 
    std::unordered_set<int> m_pinSmoothIds; 
    std::array<std::vector<long>, 4> m_pinnedCellLists; 
private:
    //make useless base class methods private;
    MimmoSharedPointer<MimmoObject> getGeometry(){return nullptr;};
    void setGeometry(MimmoSharedPointer<MimmoObject> geo){BITPIT_UNUSED(geo);};
};
 
class IOWavefrontOBJ: public mimmo::BaseManipulation{
 
public:
    typedef std::map<long,std::map<long, std::vector<long>>> TreeGroups;
    enum class IOMode{
        READ = 0, 
        RESTORE = 1, 
        WRITE = 2, 
        DUMP = 3 
    };
 
    IOWavefrontOBJ(IOMode mode = IOMode::READ);
    virtual ~IOWavefrontOBJ();
    IOWavefrontOBJ(const bitpit::Config::Section & rootXML);
 
    IOMode         whichMode();
    int            whichModeInt();
 
    WavefrontOBJData*                       getData();
    std::unordered_map<long, std::string>   getSubParts();
    std::string                             getMaterialFile();
 
    MimmoPiercedVector<std::string>*        getMaterials();
    MimmoPiercedVector<std::string>*        getCellGroups();
    MimmoPiercedVector<long>*               getSmoothIds();
 
    MimmoSharedPointer<MimmoObject>                           getNormals();
    MimmoSharedPointer<MimmoObject>                           getTextures();
 
    void    setGeometry(MimmoSharedPointer<MimmoObject> geo);
    void    setData(WavefrontOBJData* data);
    void    setDir(const std::string & pathdir);
    void    setFilename(const std::string & name);
    void    setGeometryTolerance(double tolerance);
    void    setCleanDoubleMeshVertices(bool clean);
    void    setIgnoreCellGroups(bool ignore);
    void    setTextureUVMode(bool UVmode);
    void    printResumeFile(bool print);
 
    virtual void absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name = "");
    virtual void flushSectionXML(bitpit::Config::Section & slotXML, std::string name= "");
 
    void    execute();
 
protected:
    void swap(IOWavefrontOBJ & x) noexcept;
    void buildPorts();
 
    void read(const std::string & fullpath);
    void write(const std::string & fullpath);
    void restore(std::istream &);
    void dump(std::ostream &);
    void writeResumeFile();
 
    std::string searchMaterialFile(std::ifstream & in);
 
    void searchObjectPosition(std::ifstream & in,
                              std::vector<std::streampos> & mapPos,
                              std::vector<std::string>& mapNames,
                              std::vector<std::array<long,3>>& mapVCountObject,
                              std::array<long,3>& mapVCountTotal,
                              long &nCellTot);
 
    void readObjectData(std::ifstream & in, const std::streampos &begObjectStream, const long &PID,
                        const std::string & defaultGroup, const std::array<long,3> & vCounter,
                        long &vOffset, long &vnOffset, long &vTxtOffset, long &cOffset);
 
    void writeObjectData(WavefrontOBJData* objData, std::ofstream & out,
                         const std::array<std::vector<long>,3> & vertexLists,
                         const std::vector<long> & cellList,
                         std::array<long,3> &vOffsets,
                         std::array<std::unordered_map<long,long>,3> & vinsertion_maps,
                         const std::string & defaultGroup,
                         long & activeGroup, long & activeMaterial, long &activeSmoothId);
 
    TreeGroups regroupCells(const WavefrontOBJData* objData, const livector1D & cellList);
 
 
private:
 
    IOMode m_mode;      
    std::unique_ptr<WavefrontOBJData> m_intData; 
    WavefrontOBJData * m_extData; 
    std::string m_dir; 
    std::string m_filename; 
    bool m_resume; 
    double m_tol; 
    bool m_cleanDoubleVertices; 
    bool m_ignoringCellGroups; 
    bool m_textureUVMode;  
    //INTERNAL METHODS
    int convertKeyEntryToInt(char key);
    long pushCell(MimmoSharedPointer<MimmoObject> geo, std::vector<long> &conn, long PID, long id, int rank = -1 );
    int checkFacetDefinition(const std::string & str);
};
 
REGISTER_PORT(M_GEOM, MC_SCALAR, MD_MIMMO_, __IOWAVEFRONTOBJ__HPP__)
REGISTER_PORT(M_WAVEFRONTDATA, MC_SCALAR, MD_WOBJDATA_, __IOWAVEFRONTOBJ__HPP__)
REGISTER_PORT(M_STRINGFIELD, MC_SCALAR, MD_MPVECSTRING_, __IOWAVEFRONTOBJ__HPP__)
REGISTER_PORT(M_STRINGFIELD2, MC_SCALAR, MD_MPVECSTRING_, __IOWAVEFRONTOBJ__HPP__)
REGISTER_PORT(M_LONGFIELD, MC_SCALAR, MD_MPVECLONG_, __IOWAVEFRONTOBJ__HPP__)
REGISTER_PORT(M_LONGFIELD2, MC_SCALAR, MD_MPVECLONG_, __IOWAVEFRONTOBJ__HPP__)
REGISTER_PORT(M_GEOM2, MC_SCALAR, MD_MIMMO_, __IOWAVEFRONTOBJ__HPP__)
REGISTER_PORT(M_GEOM3, MC_SCALAR, MD_MIMMO_, __IOWAVEFRONTOBJ__HPP__)
REGISTER_PORT(M_GDISPLS, MC_SCALAR, MD_MPVECARR3FLOAT_, __IOWAVEFRONTOBJ__HPP__)
REGISTER_PORT(M_NAME, MC_SCALAR, MD_STRING, __IOWAVEFRONTOBJ__HPP__)
REGISTER_PORT(M_VECTORLI, MC_VECTOR, MD_LONG, __IOWAVEFRONTOBJ__HPP__)
REGISTER_PORT(M_VECTORLI2, MC_VECTOR, MD_LONG, __IOWAVEFRONTOBJ__HPP__)
REGISTER_PORT(M_VECTORLI3, MC_VECTOR, MD_LONG, __IOWAVEFRONTOBJ__HPP__)
REGISTER_PORT(M_VECTORLI4, MC_VECTOR, MD_LONG, __IOWAVEFRONTOBJ__HPP__)
 
 
REGISTER(BaseManipulation, IOWavefrontOBJ, "mimmo.IOWaveFrontOBJ")
REGISTER(BaseManipulation, ManipulateWFOBJData, "mimmo.ManipulateWFOBJData")
 
}
 
#endif /* __IOWAVEFRONTOBJ__HPP__ */