ply2tri.cxx

Go to the documentation of this file.

/*
         Copyright 2013-2019 Pierre SMARS (smars@yuntech.edu.tw)
         This program is free software: you can redistribute it and/or modify
         it under the terms of the GNU General Public License as published by
         the Free Software Foundation, either version 2 of the License, or
         (at your option) any later version.
 
         This program 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 General Public License for more details.
 
         You should have received a copy of the GNU General Public License
         along with this program.  If not, see <http://www.gnu.org/licenses/>.
         */
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
 
#include "vtkCellArray.h"
#include "vtkCleanPolyData.h"
#include "vtkPLYReader.h"
#include "vtkPoints.h" 
#include "vtkPolyData.h"
#include "vtkTriangleFilter.h"
 
#include "SimpleOpt.h"
 
enum { OPT_HELP, OPT_PRECISION};
 
std::istringstream in;
int n_pt;
int n_tri;
//prepare output streams: 'on' (to stdout) and 'off' (to sink)
std::streambuf* on = std::cout.rdbuf();
std::ofstream   fout("/dev/null");
std::streambuf* off = fout.rdbuf();
 
//---------------------------------------------------------------------------
CSimpleOpt::SOption g_rgOptions[] = {
        { OPT_PRECISION, _T("-p"),     SO_REQ_SEP    },
        { OPT_PRECISION, _T("--precision"),     SO_REQ_SEP    },
        { OPT_HELP, _T("-?"),     SO_NONE    },
        { OPT_HELP, _T("-h"),     SO_NONE    },
        { OPT_HELP, _T("--help"), SO_NONE    },
        SO_END_OF_OPTIONS
};
//---------------------------------------------------------------------------
int error(int val)
{
#include "ply2tri.help"
        return val;
}
//---------------------------------------------------------------------------
void set_cout(std::streambuf* buf)
{
        std::cout.rdbuf(buf);
}
//---------------------------------------------------------------------------
int main( int argc, char *argv[])
{
        int pre = 3;
        CSimpleOpt args(argc, argv, g_rgOptions);
        while (args.Next())
        {
                if (args.LastError() == SO_SUCCESS)
                {
                        if (args.OptionId() == OPT_HELP)
                                return error(0);
                        else if (args.OptionId() == OPT_PRECISION)
                        {
                                std::ostringstream o;
                                o <<  args.OptionArg();
                                std::istringstream in(o.str().c_str());
                                int val;
                                in >> val;
                                if ((val>-1)&&(val<10))
                                        pre = val;
                        }
                        else
                                return error(-1);
                } else {
                        std::cerr << "Invalid argument: " << args.OptionText() << std::endl;
                        return error(args.LastError());
                }
        }
        if (args.FileCount() != 0) return error(-3);
        vtkPLYReader * reader = vtkPLYReader::New();
        reader->SetFileName("/dev/stdin");
        //don't output anything while reading
        set_cout(off);
        reader->Update();
        set_cout(on);
        vtkPolyData * output = reader->GetOutput();
        vtkCellArray * triangles_n = output->GetPolys();
        int n_tri = output->GetNumberOfPolys();
        if (n_tri > 0)
        {
                vtkCleanPolyData * clean = vtkCleanPolyData::New();
                clean->SetInputConnection(reader->GetOutputPort());
                reader->Delete();
                clean->ConvertPolysToLinesOff();
                vtkTriangleFilter * onlytri = vtkTriangleFilter::New();
                onlytri->SetInputConnection(clean->GetOutputPort());
                clean->Delete();
                onlytri->Update();
                output = onlytri->GetOutput();
        }
        vtkPoints * pts_n = output->GetPoints();
        int n_pts =  pts_n->GetNumberOfPoints();
        std::cout << n_pts << std::endl;
        std::cout << std::fixed << std::setprecision(pre);
        for (unsigned int k = 0; k < n_pts; k++)
        {
                double x[3];
                pts_n->GetPoint(k,x);
                std::cout << x[0] << ' ' << x[1] << ' ' << x[2] << std::endl;
        }
        triangles_n = output->GetPolys();
        n_tri = output->GetNumberOfPolys();
        std::cout << n_tri << std::endl;
        triangles_n->InitTraversal();
        for (unsigned int k = 0; k < n_tri; k++)
        {
                const vtkIdType * ref_pt = nullptr;
                vtkIdType npt = 3;
                triangles_n->GetNextCell(npt,ref_pt);
                std::cout << ref_pt[0] << ' ' << ref_pt[1] << ' ' << ref_pt[2] << std::endl;
        }
        return 0;
}