Nektar::Utilities::InputPly Class Reference

Converter for Ply files. More...

#include <InputPly.h>

Inheritance diagram for Nektar::Utilities::InputPly:

Collaboration diagram for Nektar::Utilities::InputPly:

Public Member Functions
	InputPly (NekMeshUtils::MeshSharedPtr m)
virtual	~InputPly ()
virtual void	Process ()
	Populate and validate required data structures. More...
void	ReadPly (io::filtering_istream &mshFile, NekDouble scale=1.0)
Public Member Functions inherited from Nektar::NekMeshUtils::InputModule
NEKMESHUTILS_EXPORT	InputModule (MeshSharedPtr p_m)
NEKMESHUTILS_EXPORT void	OpenStream ()
	Open a file for input. More...
Public Member Functions inherited from Nektar::NekMeshUtils::Module
NEKMESHUTILS_EXPORT	Module (MeshSharedPtr p_m)
NEKMESHUTILS_EXPORT void	RegisterConfig (std::string key, std::string value)
	Register a configuration option with a module. More...
NEKMESHUTILS_EXPORT void	PrintConfig ()
	Print out all configuration options for a module. More...
NEKMESHUTILS_EXPORT void	SetDefaults ()
	Sets default configuration options for those which have not been set. More...
NEKMESHUTILS_EXPORT MeshSharedPtr	GetMesh ()
virtual NEKMESHUTILS_EXPORT void	ProcessVertices ()
	Extract element vertices. More...
virtual NEKMESHUTILS_EXPORT void	ProcessEdges (bool ReprocessEdges=true)
	Extract element edges. More...
virtual NEKMESHUTILS_EXPORT void	ProcessFaces (bool ReprocessFaces=true)
	Extract element faces. More...
virtual NEKMESHUTILS_EXPORT void	ProcessElements ()
	Generate element IDs. More...
virtual NEKMESHUTILS_EXPORT void	ProcessComposites ()
	Generate composites. More...
virtual NEKMESHUTILS_EXPORT void	ClearElementLinks ()

Static Public Member Functions
static NekMeshUtils::ModuleSharedPtr	create (NekMeshUtils::MeshSharedPtr m)
	Creates an instance of this class. More...

Static Public Attributes
static NekMeshUtils::ModuleKey	className

Additional Inherited Members
Protected Member Functions inherited from Nektar::NekMeshUtils::InputModule
NEKMESHUTILS_EXPORT void	PrintSummary ()
	Print summary of elements. More...
Protected Member Functions inherited from Nektar::NekMeshUtils::Module
NEKMESHUTILS_EXPORT void	ReorderPrisms (PerMap &perFaces)
	Reorder node IDs so that prisms and tetrahedra are aligned correctly. More...
NEKMESHUTILS_EXPORT void	PrismLines (int prism, PerMap &perFaces, std::set< int > &prismsDone, std::vector< ElementSharedPtr > &line)
Protected Attributes inherited from Nektar::NekMeshUtils::InputModule
io::filtering_istream	m_mshFile
	Input stream. More...
std::ifstream	m_mshFileStream
	Input stream. More...
Protected Attributes inherited from Nektar::NekMeshUtils::Module
MeshSharedPtr	m_mesh
	Mesh object. More...
std::map< std::string, ConfigOption >	m_config
	List of configuration values. More...

Detailed Description

Converter for Ply files.

Definition at line 47 of file InputPly.h.

Constructor & Destructor Documentation

Nektar::Utilities::InputPly::InputPly

(

NekMeshUtils::MeshSharedPtr

m

)

Definition at line 53 of file InputPly.cpp.

                                  : InputModule(m)
{
}

Nektar::Utilities::InputPly::~InputPly ( )

virtual

Definition at line 57 of file InputPly.cpp.

{
}

Member Function Documentation

static NekMeshUtils::ModuleSharedPtr Nektar::Utilities::InputPly::create ( NekMeshUtils::MeshSharedPtr  m )

inlinestatic

Creates an instance of this class.

Definition at line 51 of file InputPly.h.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr().

    {
        return MemoryManager<InputPly>::AllocateSharedPtr(m);
    }

void Nektar::Utilities::InputPly::Process ( )

virtual

Populate and validate required data structures.

Parameters

pFilename

Filename of Gmsh file to read.

Implements Nektar::NekMeshUtils::Module.

Definition at line 65 of file InputPly.cpp.

References Nektar::NekMeshUtils::InputModule::m_mshFile, Nektar::NekMeshUtils::InputModule::OpenStream(), Nektar::NekMeshUtils::Module::ProcessComposites(), Nektar::NekMeshUtils::Module::ProcessEdges(), Nektar::NekMeshUtils::Module::ProcessElements(), Nektar::NekMeshUtils::Module::ProcessFaces(), Nektar::NekMeshUtils::Module::ProcessVertices(), and ReadPly().

{

    // Open the file stream.
    OpenStream();

    ReadPly(m_mshFile);

    m_mshFile.reset();

    ProcessVertices();
    ProcessEdges();
    ProcessFaces();
    ProcessElements();
    ProcessComposites();
}

void Nektar::Utilities::InputPly::ReadPly	(	io::filtering_istream &	mshFile,
		NekDouble	scale = 1.0
	)

Definition at line 82 of file InputPly.cpp.

References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, >::CreateInstance(), Nektar::LibUtilities::eTriangle, Nektar::NekMeshUtils::GetElementFactory(), Nektar::NekMeshUtils::Module::m_mesh, and class_topology::Node.

Referenced by Process().

{
    m_mesh->m_expDim = 0;
    string line;
    int nVertices                  = 0;
    int nEntities                  = 0;
    int nProperties                = 0;
    LibUtilities::ShapeType elType = LibUtilities::eTriangle;
    map<string, int> propMap;

    if (m_mesh->m_verbose)
    {
        cout << "InputPly: Start reading file..." << endl;
    }

    while (!mshFile.eof())
    {
        getline(mshFile, line);
        stringstream s(line);
        string word;
        s >> word;
        if (word == "format")
        {
            s >> word;
            if (word != "ascii")
            {
                ASSERTL0(false, "InputPly file currently only set up to read "
                                "ascii formatted ply files");
            }
        }
        else if (word == "element")
        {
            s >> word;
            if (word == "vertex")
            {
                s >> nVertices;
            }
            else if (word == "face")
            {
                s >> nEntities;
            }
            continue;
        }
        else if (word == "property")
        {
            s >> word >> word;
            propMap[word] = nProperties++;
        }
        else if (word == "end_header")
        {
            // Read nodes
            vector<double> data(nProperties);
            for (int i = 0; i < nVertices; ++i)
            {
                getline(mshFile, line);
                stringstream st(line);

                for (int j = 0; j < nProperties; ++j)
                {
                    st >> data[j];
                }

                double x = data[propMap["x"]];
                double y = data[propMap["y"]];
                double z = data[propMap["z"]];

                if ((y * y) > 0.000001 && m_mesh->m_spaceDim != 3)
                {
                    m_mesh->m_spaceDim = 2;
                }
                if ((z * z) > 0.000001)
                {
                    m_mesh->m_spaceDim = 3;
                }

                x *= scale;
                y *= scale;
                z *= scale;

                m_mesh->m_node.push_back(
                    boost::shared_ptr<Node>(new Node(i, x, y, z)));

                // Read vertex normals.
                if (propMap.count("nx") > 0)
                {
                    double nx                  = data[propMap["nx"]];
                    double ny                  = data[propMap["ny"]];
                    double nz                  = data[propMap["nz"]];
                    m_mesh->m_vertexNormals[i] = Node(0, nx, ny, nz);
                }
            }

            // Read elements
            for (int i = 0; i < nEntities; ++i)
            {
                getline(mshFile, line);
                stringstream st(line);
                int id = 0;

                // Create element tags
                vector<int> tags;
                tags.push_back(0); // composite

                // Read element node list
                st >> id;
                vector<NodeSharedPtr> nodeList;
                for (int k = 0; k < 3; ++k)
                {
                    int node = 0;
                    st >> node;
                    nodeList.push_back(m_mesh->m_node[node]);
                }

                // Create element
                ElmtConfig conf(elType, 1, false, false);
                ElementSharedPtr E = GetElementFactory().CreateInstance(
                    elType, conf, nodeList, tags);

                // Determine mesh expansion dimension
                if (E->GetDim() > m_mesh->m_expDim)
                {
                    m_mesh->m_expDim = E->GetDim();
                }
                m_mesh->m_element[E->GetDim()].push_back(E);
            }
        }
    }
}

Member Data Documentation

ModuleKey Nektar::Utilities::InputPly::className

static

Initial value:

= GetModuleFactory().RegisterCreatorFunction(
    ModuleKey(eInputModule, "ply"),
    InputPly::create,
    "Reads ply triangulation format.")

Definition at line 55 of file InputPly.h.