ENH: VTKEdgeFormat: unstructed vtk reader

src/OpenFOAM/Make/files

@@ -74,8 +74,10 @@ primitives/functions/Polynomial/polynomialFunction.C
 strings = primitives/strings
 $(strings)/string/string.C
 $(strings)/string/stringIO.C
+$(strings)/string/stringIOList.C
 $(strings)/word/word.C
 $(strings)/word/wordIO.C
+$(strings)/word/wordIOList.C
 $(strings)/fileName/fileName.C
 $(strings)/fileName/fileNameIO.C
 $(strings)/keyType/keyType.C

src/OpenFOAM/primitives/strings/string/stringIOList.C

@@ -0,0 +1,45 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "stringIOList.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineCompoundTypeName(List<string>, stringList);
+    addCompoundToRunTimeSelectionTable(List<string>, stringList);
+
+    defineTemplateTypeNameAndDebugWithName(stringIOList, "stringList", 0);
+    defineTemplateTypeNameAndDebugWithName
+    (
+        stringListIOList,
+        "stringListList",
+        0
+    );
+}
+
+// ************************************************************************* //

src/OpenFOAM/primitives/strings/string/stringIOList.H

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+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/>.
+
+Typedef
+    Foam::stringIOList
+
+Description
+    IO of a list of strings
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef stringIOList_H
+#define stringIOList_H
+
+#include "stringList.H"
+#include "IOList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef IOList<string> stringIOList;
+    typedef IOList<stringList> stringListIOList;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/OpenFOAM/primitives/strings/word/wordIOList.C

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "wordIOList.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineCompoundTypeName(List<word>, wordList);
+    addCompoundToRunTimeSelectionTable(List<word>, wordList);
+
+    defineTemplateTypeNameAndDebugWithName(wordIOList, "wordList", 0);
+    defineTemplateTypeNameAndDebugWithName(wordListIOList, "wordListList", 0);
+}
+
+// ************************************************************************* //

src/OpenFOAM/primitives/strings/word/wordIOList.H

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+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/>.
+
+Typedef
+    Foam::wordIOList
+
+Description
+    IO of a list of words
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef wordIOList_H
+#define wordIOList_H
+
+#include "wordList.H"
+#include "IOList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef IOList<word> wordIOList;
+    typedef IOList<wordList> wordListIOList;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/conversion/Make/files

@@ -19,6 +19,8 @@ meshReader/starcd/STARCDMeshReader.C
 meshWriter/meshWriter.C
 meshWriter/starcd/STARCDMeshWriter.C
 
+vtk/vtkUnstructuredReader.C
+
 polyDualMesh/polyDualMesh.C
 
 LIB = $(FOAM_LIBBIN)/libconversion

src/conversion/vtk/vtkUnstructuredReader.C

@@ -0,0 +1,878 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "vtkUnstructuredReader.H"
+#include "labelIOField.H"
+#include "scalarIOField.H"
+#include "stringIOList.H"
+#include "cellModeller.H"
+#include "vectorIOField.H"
+
+/* * * * * * * * * * * * * * * Static Member Data  * * * * * * * * * * * * * */
+
+defineTypeNameAndDebug(Foam::vtkUnstructuredReader, 0);
+
+template<>
+const char*
+Foam::NamedEnum<Foam::vtkUnstructuredReader::vtkDataType, 3>::names[] =
+{
+    "int",
+    "float",
+    "string"
+};
+const Foam::NamedEnum<Foam::vtkUnstructuredReader::vtkDataType, 3>
+Foam::vtkUnstructuredReader::vtkDataTypeNames;
+
+
+template<>
+const char*
+Foam::NamedEnum<Foam::vtkUnstructuredReader::vtkDataSetType, 3>::names[] =
+{
+    "FIELD",
+    "SCALARS",
+    "VECTORS"
+};
+const Foam::NamedEnum<Foam::vtkUnstructuredReader::vtkDataSetType, 3>
+Foam::vtkUnstructuredReader::vtkDataSetTypeNames;
+
+
+template<>
+const char*
+Foam::NamedEnum<Foam::vtkUnstructuredReader::parseMode, 5>::names[] =
+{
+    "NOMODE",
+    "UNSTRUCTURED_GRID",
+    "POLYDATA",
+    "CELL_DATA",
+    "POINT_DATA"
+};
+const Foam::NamedEnum<Foam::vtkUnstructuredReader::parseMode, 5>
+Foam::vtkUnstructuredReader::parseModeNames;
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class T>
+void Foam::vtkUnstructuredReader::readBlock
+(
+    Istream& inFile,
+    const label n,
+    List<T>& lst
+) const
+{
+    lst.setSize(n);
+    forAll(lst, i)
+    {
+        inFile >> lst[i];
+    }
+}
+
+
+void Foam::vtkUnstructuredReader::warnUnhandledType
+(
+    Istream& inFile,
+    const label type,
+    labelHashSet& warningGiven
+) const
+{
+    if (warningGiven.insert(type))
+    {
+        IOWarningIn("vtkUnstructuredReader::warnUnhandledType(..)", inFile)
+            << "Skipping unknown cell type " << type << endl;
+    }
+}
+
+
+// Split cellTypes into cells, faces and lines
+void Foam::vtkUnstructuredReader::extractCells
+(
+    Istream& inFile,
+    const labelList& cellTypes,
+    const labelList& cellVertData
+)
+{
+    const cellModel& hex = *(cellModeller::lookup("hex"));
+    const cellModel& prism = *(cellModeller::lookup("prism"));
+    const cellModel& pyr = *(cellModeller::lookup("pyr"));
+    const cellModel& tet = *(cellModeller::lookup("tet"));
+
+    labelList tetPoints(4);
+    labelList pyrPoints(5);
+    labelList prismPoints(6);
+    labelList hexPoints(8);
+
+
+    cells_.setSize(cellTypes.size());
+    faces_.setSize(cellTypes.size());
+    lines_.setSize(cellTypes.size());
+
+    label dataIndex = 0;
+    label cellI = 0;
+    label faceI = 0;
+    label lineI = 0;
+
+
+    // To mark whether unhandled type has been visited.
+    labelHashSet warningGiven;
+
+    forAll(cellTypes, i)
+    {
+        switch (cellTypes[i])
+        {
+            case VTK_VERTEX:
+            {
+                warnUnhandledType(inFile, cellTypes[i], warningGiven);
+                label nRead = cellVertData[dataIndex++];
+                if (nRead != 1)
+                {
+                    FatalIOErrorIn
+                    (
+                        "vtkUnstructuredReader::extractCells(..)",
+                        inFile
+                    )   << "Expected size 1 for VTK_VERTEX but found "
+                        << nRead << exit(FatalIOError);
+                }
+                dataIndex += nRead;
+            }
+            break;
+
+            case VTK_POLY_VERTEX:
+            {
+                warnUnhandledType(inFile, cellTypes[i], warningGiven);
+                label nRead = cellVertData[dataIndex++];
+                dataIndex += nRead;
+            }
+            break;
+
+            case VTK_LINE:
+            {
+                //warnUnhandledType(inFile, cellTypes[i], warningGiven);
+                label nRead = cellVertData[dataIndex++];
+                if (nRead != 2)
+                {
+                    FatalIOErrorIn
+                    (
+                        "vtkUnstructuredReader::extractCells(..)",
+                        inFile
+                    )   << "Expected size 2 for VTK_LINE but found "
+                        << nRead << exit(FatalIOError);
+                }
+                labelList& segment = lines_[lineI++];
+                segment.setSize(2);
+                segment[0] = cellVertData[dataIndex++];
+                segment[1] = cellVertData[dataIndex++];
+            }
+            break;
+
+            case VTK_POLY_LINE:
+            {
+                //warnUnhandledType(inFile, cellTypes[i], warningGiven);
+                label nRead = cellVertData[dataIndex++];
+                labelList& segment = lines_[lineI++];
+                segment.setSize(nRead);
+                forAll(segment, i)
+                {
+                    segment[i] = cellVertData[dataIndex++];
+                }
+            }
+            break;
+
+            case VTK_TRIANGLE:
+            {
+                face& f = faces_[faceI++];
+                f.setSize(3);
+                label nRead = cellVertData[dataIndex++];
+                if (nRead != 3)
+                {
+                    FatalIOErrorIn
+                    (
+                        "vtkUnstructuredReader::extractCells(..)",
+                        inFile
+                    )   << "Expected size 3 for VTK_TRIANGLE but found "
+                        << nRead << exit(FatalIOError);
+                }
+                f[0] = cellVertData[dataIndex++];
+                f[1] = cellVertData[dataIndex++];
+                f[2] = cellVertData[dataIndex++];
+            }
+            break;
+
+            case VTK_QUAD:
+            {
+                face& f = faces_[faceI++];
+                f.setSize(4);
+                label nRead = cellVertData[dataIndex++];
+                if (nRead != 4)
+                {
+                    FatalIOErrorIn
+                    (
+                        "vtkUnstructuredReader::extractCells(..)",
+                        inFile
+                    )   << "Expected size 4 for VTK_QUAD but found "
+                        << nRead << exit(FatalIOError);
+                }
+                f[0] = cellVertData[dataIndex++];
+                f[1] = cellVertData[dataIndex++];
+                f[2] = cellVertData[dataIndex++];
+                f[3] = cellVertData[dataIndex++];
+            }
+            break;
+
+            case VTK_POLYGON:
+            {
+                face& f = faces_[faceI++];
+                label nRead = cellVertData[dataIndex++];
+                f.setSize(nRead);
+                forAll(f, fp)
+                {
+                    f[fp] = cellVertData[dataIndex++];
+                }
+            }
+            break;
+
+            case VTK_TETRA:
+            {
+                label nRead = cellVertData[dataIndex++];
+                if (nRead != 4)
+                {
+                    FatalIOErrorIn
+                    (
+                        "vtkUnstructuredReader::extractCells(..)",
+                        inFile
+                    )   << "Expected size 4 for VTK_TETRA but found "
+                        << nRead << exit(FatalIOError);
+                }
+                tetPoints[0] = cellVertData[dataIndex++];
+                tetPoints[1] = cellVertData[dataIndex++];
+                tetPoints[2] = cellVertData[dataIndex++];
+                tetPoints[3] = cellVertData[dataIndex++];
+                cells_[cellI++] = cellShape(tet, tetPoints, true);
+            }
+            break;
+
+            case VTK_PYRAMID:
+            {
+                label nRead = cellVertData[dataIndex++];
+                if (nRead != 5)
+                {
+                    FatalIOErrorIn
+                    (
+                        "vtkUnstructuredReader::extractCells(..)",
+                        inFile
+                    )   << "Expected size 5 for VTK_PYRAMID but found "
+                        << nRead << exit(FatalIOError);
+                }
+                pyrPoints[0] = cellVertData[dataIndex++];
+                pyrPoints[1] = cellVertData[dataIndex++];
+                pyrPoints[2] = cellVertData[dataIndex++];
+                pyrPoints[3] = cellVertData[dataIndex++];
+                pyrPoints[4] = cellVertData[dataIndex++];
+                cells_[cellI++] = cellShape(pyr, pyrPoints, true);
+            }
+            break;
+
+            case VTK_WEDGE:
+            {
+                label nRead = cellVertData[dataIndex++];
+                if (nRead != 6)
+                {
+                    FatalIOErrorIn
+                    (
+                        "vtkUnstructuredReader::extractCells(..)",
+                        inFile
+                    )   << "Expected size 6 for VTK_WEDGE but found "
+                        << nRead << exit(FatalIOError);
+                }
+                prismPoints[0] = cellVertData[dataIndex++];
+                prismPoints[1] = cellVertData[dataIndex++];
+                prismPoints[2] = cellVertData[dataIndex++];
+                prismPoints[3] = cellVertData[dataIndex++];
+                prismPoints[4] = cellVertData[dataIndex++];
+                prismPoints[5] = cellVertData[dataIndex++];
+                cells_[cellI++] = cellShape(prism, prismPoints, true);
+            }
+            break;
+
+            case VTK_HEXAHEDRON:
+            {
+                label nRead = cellVertData[dataIndex++];
+                if (nRead != 8)
+                {
+                    FatalIOErrorIn
+                    (
+                        "vtkUnstructuredReader::extractCells(..)",
+                        inFile
+                    )   << "Expected size 8 for VTK_HEXAHEDRON but found "
+                        << nRead << exit(FatalIOError);
+                }
+                hexPoints[0] = cellVertData[dataIndex++];
+                hexPoints[1] = cellVertData[dataIndex++];
+                hexPoints[2] = cellVertData[dataIndex++];
+                hexPoints[3] = cellVertData[dataIndex++];
+                hexPoints[4] = cellVertData[dataIndex++];
+                hexPoints[5] = cellVertData[dataIndex++];
+                hexPoints[6] = cellVertData[dataIndex++];
+                hexPoints[7] = cellVertData[dataIndex++];
+                cells_[cellI++] = cellShape(hex, hexPoints, true);
+            }
+            break;
+
+            default:
+                warnUnhandledType(inFile, cellTypes[i], warningGiven);
+                label nRead = cellVertData[dataIndex++];
+                dataIndex += nRead;
+        }
+    }
+
+    if (debug)
+    {
+        Info<< "Read " << cellI << " cells;" << faceI << " faces." << endl;
+    }
+    cells_.setSize(cellI);
+    faces_.setSize(faceI);
+    lines_.setSize(lineI);
+}
+
+
+// Read single field and stores it on the objectRegistry.
+void Foam::vtkUnstructuredReader::readField
+(
+    ISstream& inFile,
+    objectRegistry& obj,
+    const word& arrayName,
+    const word& dataType,
+    const label size
+) const
+{
+    switch (vtkDataTypeNames[dataType])
+    {
+        case VTK_INT:
+        {
+            autoPtr<labelIOField> fieldVals
+            (
+                new labelIOField
+                (
+                    IOobject
+                    (
+                        arrayName,
+                        "",
+                        obj
+                    ),
+                    size
+                )
+            );
+            readBlock(inFile, fieldVals().size(), fieldVals());
+            regIOobject::store(fieldVals);
+        }
+        break;
+
+        case VTK_FLOAT:
+        {
+            autoPtr<scalarIOField> fieldVals
+            (
+                new scalarIOField
+                (
+                    IOobject
+                    (
+                        arrayName,
+                        "",
+                        obj
+                    ),
+                    size
+                )
+            );
+            readBlock(inFile, fieldVals().size(), fieldVals());
+            regIOobject::store(fieldVals);
+        }
+        break;
+
+        case VTK_STRING:
+        {
+            if (debug)
+            {
+                Info<< "Reading strings:" << size << endl;
+            }
+            autoPtr<stringIOList> fieldVals
+            (
+                new stringIOList
+                (
+                    IOobject
+                    (
+                        arrayName,
+                        "",
+                        obj
+                    ),
+                    size
+                )
+            );
+            // Consume current line.
+            inFile.getLine(fieldVals()[0]);
+            // Read without parsing
+            forAll(fieldVals(), i)
+            {
+                inFile.getLine(fieldVals()[i]);
+            }
+            regIOobject::store(fieldVals);
+        }
+        break;
+
+        default:
+        {
+            IOWarningIn("vtkUnstructuredReader::extractCells(..)", inFile)
+                << "Unhandled type " << vtkDataTypeNames[dataType] << endl
+                << "Skipping " << size
+                << " words." << endl;
+            scalarField fieldVals;
+            readBlock(inFile, size, fieldVals);
+        }
+        break;
+    }
+}
+
+
+// Reads fields, stores them on the objectRegistry. Returns a list of
+// read fields
+Foam::wordList Foam::vtkUnstructuredReader::readFieldArray
+(
+    ISstream& inFile,
+    objectRegistry& obj,
+    const label wantedSize
+) const
+{
+    DynamicList<word> fields;
+
+    word dataName(inFile);
+    if (debug)
+    {
+        Info<< "dataName:" << dataName << endl;
+    }
+    label numArrays(readLabel(inFile));
+    if (debug)
+    {
+        Pout<< "numArrays:" << numArrays << endl;
+    }
+    for (label i = 0; i < numArrays; i++)
+    {
+        word arrayName(inFile);
+        label numComp(readLabel(inFile));
+        label numTuples(readLabel(inFile));
+        word dataType(inFile);
+
+        if (debug)
+        {
+            Info<< "Reading field " << arrayName
+                << " of " << numTuples << " tuples of rank " << numComp << endl;
+        }
+
+        if (wantedSize != -1 && numTuples != wantedSize)
+        {
+            FatalIOErrorIn("vtkUnstructuredReader::readFieldArray(..)", inFile)
+                << "Expected " << wantedSize << " tuples but only have "
+                << numTuples << exit(FatalIOError);
+        }
+
+        readField
+        (
+            inFile,
+            obj,
+            arrayName,
+            dataType,
+            numTuples*numComp
+        );
+        fields.append(arrayName);
+    }
+    return fields.shrink();
+}
+
+
+Foam::objectRegistry& Foam::vtkUnstructuredReader::selectRegistry
+(
+    const parseMode readMode
+)
+{
+    if (readMode == CELL_DATA)
+    {
+        return cellData_;
+    }
+    else if (readMode == POINT_DATA)
+    {
+        return pointData_;
+    }
+    else
+    {
+        return otherData_;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::vtkUnstructuredReader::vtkUnstructuredReader
+(
+    const objectRegistry& obr,
+    ISstream& inFile
+)
+:
+    cellData_(IOobject("cellData", obr)),
+    pointData_(IOobject("pointData", obr)),
+    otherData_(IOobject("otherData", obr))
+{
+    read(inFile);
+}
+
+
+void Foam::vtkUnstructuredReader::read(ISstream& inFile)
+{
+    inFile.getLine(header_);
+    if (debug)
+    {
+        Info<< "Header   : " << header_ << endl;
+    }
+    inFile.getLine(title_);
+    if (debug)
+    {
+        Info<< "Title    : " << title_ << endl;
+    }
+    inFile.getLine(dataType_);
+    if (debug)
+    {
+        Info<< "dataType : " << dataType_ << endl;
+    }
+
+    parseMode readMode = NOMODE;
+    label wantedSize = -1;
+
+
+    // Temporary storage for vertices of cells.
+    labelList cellVerts;
+
+    while (inFile.good())
+    {
+        word tag(inFile);
+
+        if (!inFile.good())
+        {
+            break;
+        }
+
+        if (debug)
+        {
+            Info<< "line:" << inFile.lineNumber()
+                << " tag:" << tag << endl;
+        }
+
+        if (tag == "DATASET")
+        {
+            word geomType(inFile);
+            if (debug)
+            {
+                Info<< "geomType : " << geomType << endl;
+            }
+            readMode = parseModeNames[geomType];
+            wantedSize = -1;
+        }
+        else if (tag == "POINTS")
+        {
+            label nPoints(readLabel(inFile));
+            points_.setSize(nPoints);    ///3);
+            if (debug)
+            {
+                Info<< "Reading " << nPoints << " numbers representing "
+                    << points_.size() << " coordinates." << endl;
+            }
+
+            word primitiveTag(inFile);
+            if (primitiveTag != "float")
+            {
+                FatalIOErrorIn("vtkUnstructuredReader::read(..)", inFile)
+                    << "Expected 'float' entry but found "
+                    << primitiveTag
+                    << exit(FatalIOError);
+            }
+            forAll(points_, i)
+            {
+                inFile >> points_[i].x() >> points_[i].y() >> points_[i].z();
+            }
+        }
+        else if (tag == "CELLS")
+        {
+            label nCells(readLabel(inFile));
+            label nNumbers(readLabel(inFile));
+            if (debug)
+            {
+                Info<< "Reading " << nCells << " cells or faces." << endl;
+            }
+            readBlock(inFile, nNumbers, cellVerts);
+        }
+        else if (tag == "CELL_TYPES")
+        {
+            label nCellTypes(readLabel(inFile));
+
+            labelList cellTypes;
+            readBlock(inFile, nCellTypes, cellTypes);
+
+            if (cellTypes.size() > 0 && cellVerts.size() == 0)
+            {
+                FatalIOErrorIn("vtkUnstructuredReader::read(..)", inFile)
+                    << "Found " << cellTypes.size()
+                    << " cellTypes but no cells."
+                    << exit(FatalIOError);
+            }
+
+            extractCells(inFile, cellTypes, cellVerts);
+            cellVerts.clear();
+        }
+        else if (tag == "LINES")
+        {
+            label nLines(readLabel(inFile));
+            label nNumbers(readLabel(inFile));
+            if (debug)
+            {
+                Info<< "Reading " << nLines << " lines." << endl;
+            }
+            labelList lineVerts;
+            readBlock(inFile, nNumbers, lineVerts);
+            lines_.setSize(nLines);
+            label elemI = 0;
+            forAll(lines_, lineI)
+            {
+                labelList& f = lines_[lineI];
+                f.setSize(lineVerts[elemI++]);
+                forAll(f, fp)
+                {
+                    f[fp] = lineVerts[elemI++];
+                }
+            }
+        }
+        else if (tag == "POLYGONS")
+        {
+            // If in polydata mode
+
+            label nFaces(readLabel(inFile));
+            label nNumbers(readLabel(inFile));
+            if (debug)
+            {
+                Info<< "Reading " << nFaces << " faces." << endl;
+            }
+            labelList faceVerts;
+            readBlock(inFile, nNumbers, faceVerts);
+            faces_.setSize(nFaces);
+            label elemI = 0;
+            forAll(faces_, faceI)
+            {
+                face& f = faces_[faceI];
+                f.setSize(faceVerts[elemI++]);
+                forAll(f, fp)
+                {
+                    f[fp] = faceVerts[elemI++];
+                }
+            }
+        }
+        else if (tag == "POINT_DATA")
+        {
+            readMode = POINT_DATA;
+            wantedSize = points_.size();
+
+            label nPoints(readLabel(inFile));
+            if (nPoints != wantedSize)
+            {
+                FatalIOErrorIn("vtkUnstructuredReader::read(..)", inFile)
+                    << "Reading POINT_DATA : expected " << wantedSize
+                    << " but read " << nPoints << exit(FatalIOError);
+            }
+        }
+        else if (tag == "CELL_DATA")
+        {
+            readMode = CELL_DATA;
+            wantedSize = cells_.size()+faces_.size();
+
+            label nCells(readLabel(inFile));
+            if (nCells != wantedSize)
+            {
+                FatalIOErrorIn("vtkUnstructuredReader::read(..)", inFile)
+                    << "Reading CELL_DATA : expected "
+                    << wantedSize
+                    << " but read " << nCells << exit(FatalIOError);
+            }
+        }
+        else if (tag == "FIELD")
+        {
+            // wantedSize already set according to type we expected to read.
+            readFieldArray(inFile, selectRegistry(readMode), wantedSize);
+        }
+        else if (tag == "SCALARS")
+        {
+            string line;
+            inFile.getLine(line);
+            IStringStream is(line);
+            word dataName(is);
+            word dataType(is);
+            //label numComp(readLabel(inFile));
+
+            if (debug)
+            {
+                Info<< "Reading scalar " << dataName
+                    << " of type " << dataType
+                    << " from lookup table" << endl;
+            }
+
+            word lookupTableTag(inFile);
+            if (lookupTableTag != "LOOKUP_TABLE")
+            {
+                FatalIOErrorIn("vtkUnstructuredReader::read(..)", inFile)
+                    << "Expected tag LOOKUP_TABLE but read "
+                    << lookupTableTag
+                    << exit(FatalIOError);
+            }
+
+            word lookupTableName(inFile);
+
+            readField
+            (
+                inFile,
+                selectRegistry(readMode),
+                dataName,
+                dataType,
+                wantedSize//*numComp
+            );
+        }
+        else if (tag == "VECTORS" || tag == "NORMALS")
+        {
+            string line;
+            inFile.getLine(line);
+            IStringStream is(line);
+            word dataName(is);
+            word dataType(is);
+            if (debug)
+            {
+                Info<< "Reading vector " << dataName
+                    << " of type " << dataType << endl;
+            }
+
+            objectRegistry& reg = selectRegistry(readMode);
+
+            readField
+            (
+                inFile,
+                reg,
+                dataName,
+                dataType,
+                3*wantedSize
+            );
+
+            if (vtkDataTypeNames[dataType] == VTK_FLOAT)
+            {
+                objectRegistry::iterator iter = reg.find(dataName);
+                scalarField s(*dynamic_cast<const scalarField*>(iter()));
+                reg.erase(iter);
+                autoPtr<vectorIOField> fieldVals
+                (
+                    new vectorIOField
+                    (
+                        IOobject
+                        (
+                            dataName,
+                            "",
+                            reg
+                        ),
+                        s.size()/3
+                    )
+                );
+
+                label elemI = 0;
+                forAll(fieldVals(), i)
+                {
+                    fieldVals()[i].x() = s[elemI++];
+                    fieldVals()[i].y() = s[elemI++];
+                    fieldVals()[i].z() = s[elemI++];
+                }
+                regIOobject::store(fieldVals);
+            }
+        }
+        else
+        {
+            FatalIOErrorIn("vtkUnstructuredReader::read(..)", inFile)
+                << "Unsupported tag "
+                << tag << exit(FatalIOError);
+        }
+    }
+
+    if (debug)
+    {
+        Info<< "Read points:" << points_.size()
+            << " cellShapes:" << cells_.size()
+            << " faces:" << faces_.size()
+            << " lines:" << lines_.size()
+            << nl << endl;
+
+        Info<< "Cell fields:" << endl;
+        printFieldStats<vectorIOField>(cellData_);
+        printFieldStats<scalarIOField>(cellData_);
+        printFieldStats<labelIOField>(cellData_);
+        printFieldStats<stringIOList>(cellData_);
+        Info<< nl << endl;
+
+        Info<< "Point fields:" << endl;
+        printFieldStats<vectorIOField>(pointData_);
+        printFieldStats<scalarIOField>(pointData_);
+        printFieldStats<labelIOField>(pointData_);
+        printFieldStats<stringIOList>(pointData_);
+        Info<< nl << endl;
+
+        Info<< "Other fields:" << endl;
+        printFieldStats<vectorIOField>(otherData_);
+        printFieldStats<scalarIOField>(otherData_);
+        printFieldStats<labelIOField>(otherData_);
+        printFieldStats<stringIOList>(otherData_);
+    }
+}
+
+
+template<class Type>
+void Foam::vtkUnstructuredReader::printFieldStats
+(
+    const objectRegistry& obj
+) const
+{
+    wordList fieldNames(obj.names(Type::typeName));
+
+    if (fieldNames.size() > 0)
+    {
+        Info<< "Read " << fieldNames.size() << " " << Type::typeName
+            << " fields:" << endl;
+        Info<< "Size\tName" << nl
+            << "----\t----" << endl;
+        forAll(fieldNames, i)
+        {
+            Info<< obj.lookupObject<Type>(fieldNames[i]).size()
+                << "\t" << fieldNames[i]
+                << endl;
+        }
+        Info<< endl;
+    }
+}
+
+
+// ************************************************************************* //

src/conversion/vtk/vtkUnstructuredReader.H

@@ -0,0 +1,332 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+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/>.
+
+Class
+    Foam::vtkUnstructuredReader
+
+Description
+    Reader for vtk unstructured legacy files
+
+SourceFiles
+    vtkUnstructuredReader.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef vtkUnstructuredReader_H
+#define vtkUnstructuredReader_H
+
+#include "objectRegistry.H"
+#include "cellShapeList.H"
+#include "HashSet.H"
+#include "NamedEnum.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of friend functions and operators
+
+
+/*---------------------------------------------------------------------------*\
+                     Class vtkUnstructuredReader Declaration
+\*---------------------------------------------------------------------------*/
+
+class vtkUnstructuredReader
+{
+public:
+
+    // Public data types
+
+        //- Enumeration defining the vtk data types
+        enum vtkDataType
+        {
+            VTK_INT,
+            VTK_FLOAT,
+            VTK_STRING
+        };
+
+        static const NamedEnum<vtkDataType, 3> vtkDataTypeNames;
+
+
+        //- Enumeration defining the vtk dataset types
+        enum vtkDataSetType
+        {
+            VTK_FIELD,
+            VTK_SCALARS,
+            VTK_VECTORS
+        };
+
+        static const NamedEnum<vtkDataSetType, 3> vtkDataSetTypeNames;
+
+
+        //- Enumeration defining the parse mode - what type of data is being
+        //  read
+        enum parseMode
+        {
+            NOMODE,
+            UNSTRUCTURED_GRID,
+            POLYDATA,
+            CELL_DATA,
+            POINT_DATA
+        };
+
+        static const NamedEnum<parseMode, 5> parseModeNames;
+
+
+        //- Enumeration defining the cell types
+        enum vtkTypes
+        {
+            VTK_EMPTY_CELL       = 0,
+            VTK_VERTEX           = 1,
+            VTK_POLY_VERTEX      = 2,
+            VTK_LINE             = 3,
+            VTK_POLY_LINE        = 4,
+            VTK_TRIANGLE         = 5,
+            VTK_TRIANGLE_STRIP   = 6,
+            VTK_POLYGON          = 7,
+            VTK_PIXEL            = 8,
+            VTK_QUAD             = 9,
+            VTK_TETRA            = 10,
+            VTK_VOXEL            = 11,
+            VTK_HEXAHEDRON       = 12,
+            VTK_WEDGE            = 13,
+            VTK_PYRAMID          = 14,
+            VTK_PENTAGONAL_PRISM = 15,
+            VTK_HEXAGONAL_PRISM  = 16,
+        };
+
+
+private:
+
+    //- Header
+    string header_;
+
+    //- Title
+    string title_;
+
+    //- DataType
+    string dataType_;
+
+
+    // Geometry
+
+        //- Points
+        pointField points_;
+
+        //- 3D cells.
+        cellShapeList cells_;
+
+        //- 2D cells (=faces)
+        faceList faces_;
+
+        //- 1D cells (=edges)
+        labelListList lines_;
+
+
+    // Data
+
+        //- cell based fields
+        objectRegistry cellData_;
+
+        //- point based fields
+        objectRegistry pointData_;
+
+        //- other fields
+        objectRegistry otherData_;
+
+
+
+    // Private Member Functions
+
+        template<class T>
+        void readBlock
+        (
+            Istream& inFile,
+            const label n,
+            List<T>& lst
+        ) const;
+
+        void warnUnhandledType
+        (
+            Istream& inFile,
+            const label type,
+            labelHashSet& warningGiven
+        ) const;
+
+        void extractCells
+        (
+            Istream& inFile,
+            const labelList& cellTypes,
+            const labelList& cellVertData
+        );
+
+        void readField
+        (
+            ISstream& inFile,
+            objectRegistry& obj,
+            const word& arrayName,
+            const word& dataType,
+            const label size
+        ) const;
+
+        wordList readFieldArray
+        (
+            ISstream& inFile,
+            objectRegistry& obj,
+            const label wantedSize
+        ) const;
+
+        objectRegistry& selectRegistry(const parseMode readMode);
+
+        void read(ISstream& inFile);
+
+        //- Dissallow assignment
+        void operator=(const vtkUnstructuredReader&);
+
+
+public:
+
+    //- Runtime type information
+    ClassName("vtkUnstructuredReader");
+
+    // Constructors
+
+        //- Construct from Istream, read all
+        vtkUnstructuredReader(const objectRegistry& obr, ISstream&);
+
+    // Member Functions
+
+        //- Header
+        const string header() const
+        {
+            return header_;
+        }
+
+        //- Title
+        const string& title() const
+        {
+            return title_;
+        }
+
+        //- DataType
+        const string& dataType() const
+        {
+            return dataType_;
+        }
+
+
+        //- Points
+        const pointField& points() const
+        {
+            return points_;
+        }
+
+        pointField& points()
+        {
+            return points_;
+        }
+
+        //- 3D cells.
+        const cellShapeList& cells() const
+        {
+            return cells_;
+        }
+
+        cellShapeList& cells()
+        {
+            return cells_;
+        }
+
+        //- 2D cells (=faces)
+        const faceList& faces() const
+        {
+            return faces_;
+        }
+
+        faceList& faces()
+        {
+            return faces_;
+        }
+
+        //- 1D cells (=open lines)
+        const labelListList& lines() const
+        {
+            return lines_;
+        }
+
+        labelListList& lines()
+        {
+            return lines_;
+        }
+
+        //- cell based fields
+        const objectRegistry& cellData() const
+        {
+            return cellData_;
+        }
+
+        objectRegistry& cellData()
+        {
+            return cellData_;
+        }
+
+        //- point based fields
+        const objectRegistry& pointData() const
+        {
+            return pointData_;
+        }
+
+        objectRegistry& pointData()
+        {
+            return pointData_;
+        }
+
+        //- other fields
+        const objectRegistry& otherData() const
+        {
+            return otherData_;
+        }
+
+        objectRegistry& otherData()
+        {
+            return otherData_;
+        }
+
+
+        //- Debug: print contents of objectRegistry
+        template<class Type>
+        void printFieldStats(const objectRegistry&) const;
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/edgeMesh/Make/options

@@ -1,9 +1,11 @@
 EXE_INC = \
     -I$(LIB_SRC)/fileFormats/lnInclude \
     -I$(LIB_SRC)/triSurface/lnInclude \
+    -I$(LIB_SRC)/conversion/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude
 
 LIB_LIBS = \
     -ltriSurface \
     -lmeshTools \
+    -lconversion \
     -lfileFormats

src/edgeMesh/edgeFormats/vtk/VTKedgeFormat.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -26,6 +26,9 @@ License
 #include "VTKedgeFormat.H"
 #include "OFstream.H"
 #include "clock.H"
+#include "IFstream.H"
+#include "vtkUnstructuredReader.H"
+#include "Time.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
@@ -72,12 +75,84 @@ void Foam::fileFormats::VTKedgeFormat::writeEdges
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::fileFormats::VTKedgeFormat::VTKedgeFormat()
+Foam::fileFormats::VTKedgeFormat::VTKedgeFormat
-{}
+(
+    const fileName& filename
+)
+{
+    read(filename);
+}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+bool Foam::fileFormats::VTKedgeFormat::read
+(
+    const fileName& filename
+)
+{
+    IFstream is(filename);
+    if (!is.good())
+    {
+        FatalErrorIn
+        (
+            "fileFormats::VTKedgeFormat::read(const fileName&)"
+        )   << "Cannot read file " << filename
+            << exit(FatalError);
+    }
+
+    // Construct dummy time so we have something to create an objectRegistry
+    // from
+    Time dummyTime
+    (
+        "dummyRoot",
+        "dummyCase",
+        "system",
+        "constant",
+        false           // enableFunctionObjects
+    );
+
+    // Make dummy object registry
+    objectRegistry obr
+    (
+        IOobject
+        (
+            "dummy",
+            dummyTime,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE,
+            false
+        )
+    );
+
+    // Construct reader to read file
+    vtkUnstructuredReader reader(obr, is);
+
+
+    // Extract lines
+    storedPoints().transfer(reader.points());
+
+    label nEdges = 0;
+    forAll(reader.lines(), lineI)
+    {
+        nEdges += reader.lines()[lineI].size()-1;
+    }
+    storedEdges().setSize(nEdges);
+
+    nEdges = 0;
+    forAll(reader.lines(), lineI)
+    {
+        const labelList& verts = reader.lines()[lineI];
+        for (label i = 1; i < verts.size(); i++)
+        {
+            storedEdges()[nEdges++] = edge(verts[i-1], verts[i]);
+        }
+    }
+
+    return true;
+}
+
+
 void Foam::fileFormats::VTKedgeFormat::write
 (
     const fileName& filename,
@@ -91,8 +166,7 @@ void Foam::fileFormats::VTKedgeFormat::write
         (
             "fileFormats::VTKedgeFormat::write"
             "(const fileName&, const edgeMesh&)"
-        )
+        )   << "Cannot open file for writing " << filename
-            << "Cannot open file for writing " << filename
             << exit(FatalError);
     }
 

src/edgeMesh/edgeFormats/vtk/VTKedgeFormat.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -78,10 +78,23 @@ protected:
 
 public:
 
+
     // Constructors
 
-        //- Construct null
+        //- Construct from file name
-        VTKedgeFormat();
+        VTKedgeFormat(const fileName&);
+
+
+    // Selectors
+
+        //- Read file and return surface
+        static autoPtr<edgeMesh> New(const fileName& name)
+        {
+            return autoPtr<edgeMesh>
+            (
+                new VTKedgeFormat(name)
+            );
+        }
 
 
     //- Destructor
@@ -91,16 +104,17 @@ public:
 
     // Member Functions
 
-        // Write
+        //- Write surface mesh components by proxy
-
-            //- Write edgeMesh
         static void write(const fileName&, const edgeMesh&);
 
-//            //- Write object
+        //- Read from file
-//            virtual void write(Ostream& os) const
+        virtual bool read(const fileName&);
-//            {
+
-//                write(os, *this);
+        //- Write object file
-//            }
+        virtual void write(const fileName& name) const
+        {
+            write(name, *this);
+        }
 };
 
 

src/edgeMesh/edgeFormats/vtk/VTKedgeFormatRunTime.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -35,6 +35,16 @@ namespace Foam
 namespace fileFormats
 {
 
+// read edgeMesh
+addNamedToRunTimeSelectionTable
+(
+    edgeMesh,
+    VTKedgeFormat,
+    fileExtension,
+    vtk
+);
+
+// write edgeMesh
 addNamedToMemberFunctionSelectionTable
 (
     edgeMesh,