openfoam/applications/utilities/mesh/manipulation/objToVTK/objToVTK.C

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
    \\  /    A nd           | www.openfoam.com
     \\/     M anipulation  |
-------------------------------------------------------------------------------
    Copyright (C) 2011-2015 OpenFOAM Foundation
    Copyright (C) 2019-2025 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.

    OpenFOAM 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 3 of the License, or
    (at your option) any later version.

    OpenFOAM 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 OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.

Application
    objToVTK

Group
    grpMeshManipulationUtilities

Description
    Read obj line (not surface) file and convert into legacy VTK file.

\*---------------------------------------------------------------------------*/

#include "argList.H"
#include "OFstream.H"
#include "stringOps.H"
#include "point.H"
#include "DynamicList.H"

using namespace Foam;

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

string getLine(std::ifstream& is)
{
    string line;
    do
    {
        std::getline(is, line);
    }
    while (line.starts_with('#'));

    return line;
}


// Token list with one of the following:
//     f v1 v2 v3 ...
//     f v1/vt1 v2/vt2 v3/vt3 ...
//     l v1 v2 v3 ...
//     l v1/vt1 v2/vt2 v3/vt3 ...
static label readObjVertices
(
    const SubStrings& tokens,
    DynamicList<label>& verts
)
{
    verts.clear();

    bool first = true;
    for (const auto& tok : tokens)
    {
        if (first)
        {
            // skip initial "f" or "l"
            first = false;
            continue;
        }

        std::string vrtSpec(tok.str());

        if
        (
            const auto slash = vrtSpec.find('/');
            slash != std::string::npos
        )
        {
            vrtSpec.erase(slash);
        }

        label vertId = readLabel(vrtSpec);

        verts.push_back(vertId - 1);
    }

    return verts.size();
}

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

int main(int argc, char *argv[])
{
    argList::addNote
    (
        "Read obj line (not surface) file and convert into legacy VTK file"
    );

    argList::noParallel();
    argList::addArgument("obj-file", "The input obj line file");
    argList::addArgument("vtk-file", "The output vtk file");
    argList args(argc, argv);

    const auto objName = args.get<fileName>(1);
    const auto outName = args.get<fileName>(2);

    std::ifstream OBJfile(objName);

    Info<< "Processing file " << objName << endl;

    if (!OBJfile.good())
    {
        FatalErrorInFunction
            << "Cannot read file " << objName << exit(FatalError);
    }

    // Points and lines
    DynamicList<point> points;
    DynamicList<vector> pointNormals;
    DynamicList<labelList> polyLines;
    DynamicList<labelList> polygons;

    DynamicList<label> dynVerts;

    bool hasWarned = false;

    label lineNo = 0;
    while (OBJfile.good())
    {
        const string line = getLine(OBJfile);
        lineNo++;

        if (line.empty()) continue;

        const auto tokens = stringOps::splitSpace(line);

        // Require command and some arguments
        if (tokens.size() < 2)
        {
            continue;
        }

        const word cmd = word::validate(tokens[0]);

        if (cmd == "v")
        {
            // Vertex
            // v x y z

            points.emplace_back
            (
                readScalar(tokens[1]),
                readScalar(tokens[2]),
                readScalar(tokens[3])
            );
        }
        else if (cmd == "vn")
        {
            // Vertex normals
            // vn x y z

            pointNormals.emplace_back
            (
                readScalar(tokens[1]),
                readScalar(tokens[2]),
                readScalar(tokens[3])
            );
        }
        else if (cmd == "l")
        {
            // Line
            // l v1 v2 v3 ...
            // OR
            // l v1/vt1 v2/vt2 v3/vt3 ...

            readObjVertices(tokens, dynVerts);
            polyLines.emplace_back() = dynVerts;
        }
        else if (cmd == "f")
        {
            // f v1 v2 v3 ...
            // OR
            // f v1/vt1 v2/vt2 v3/vt3 ...

            readObjVertices(tokens, dynVerts);
            polygons.emplace_back() = dynVerts;
        }
        else if (cmd != "")
        {
            if (!hasWarned)
            {
                hasWarned = true;

                WarningInFunction
                    << "Unrecognized OBJ command " << cmd << nl
                    << "In line " << line
                    << " at linenumber " << lineNo << nl
                    << "Only recognized commands are 'v' and 'l'.\n"
                    << "If this is a surface command use surfaceConvert instead"
                    << " to convert to a file format that can be read by VTK"
                    << endl;
            }
        }
    }


    //
    // Write as vtk 'polydata' file
    //


    OFstream outFile(outName);

    outFile
        << "# vtk DataFile Version 2.0\n"
        << objName << nl
        << "ASCII\n"
        << "DATASET POLYDATA\n"
        << "POINTS " << points.size() << " double\n";

    for (const point& pt : points)
    {
        outFile
            << float(pt.x()) << ' '
            << float(pt.y()) << ' '
            << float(pt.z()) << nl;
    }

    outFile
        << "VERTICES " << points.size() << ' ' << (2 * points.size()) << nl;

    forAll(points, i)
    {
        outFile << 1 << ' ' << i << nl;
    }

    label nItems = 0;
    for (const labelList& line : polyLines)
    {
        nItems += line.size() + 1;
    }

    outFile
        << "LINES " << polyLines.size() << ' ' << nItems << nl;

    for (const labelList& line : polyLines)
    {
        outFile << line.size();

        for (const label vrt : line)
        {
            outFile << ' ' << vrt;
        }
        outFile << nl;
    }


    nItems = 0;
    for (const labelList& line : polygons)
    {
        nItems += line.size() + 1;
    }

    outFile
        << "POLYGONS " << polygons.size() << ' ' << nItems << nl;

    for (const labelList& line : polygons)
    {
        outFile << line.size();

        for (const label vrt : line)
        {
            outFile << ' ' << vrt;
        }
        outFile << nl;
    }


    outFile
        << "POINT_DATA " << points.size() << nl
        << "SCALARS pointID double 1\n"
        << "LOOKUP_TABLE default\n";

    forAll(points, i)
    {
        outFile << i;

        if ((i % 10) == 1)
        {
            outFile << nl;
        }
        else
        {
            outFile << ' ';
        }
    }

    if (!pointNormals.empty())
    {
        outFile << nl << "NORMALS pointNormals double\n";

        for(const vector& n : pointNormals)
        {
            outFile
                << float(n.x()) << ' '
                << float(n.y()) << ' '
                << float(n.z()) << nl;
        }
    }

    Info<< "End\n" << endl;

    return 0;
}


// ************************************************************************* //