vtkUnstructuredReader.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
    \\  /    A nd           | www.openfoam.com
     \\/     M anipulation  |
-------------------------------------------------------------------------------
    Copyright (C) 2012-2016 OpenFOAM Foundation
    Copyright (C) 2021 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/>.
 
Class
    Foam::vtkUnstructuredReader
 
Description
    Reader for vtk UNSTRUCTURED_GRID legacy files.
    Supports single CELLS, POINTS etc. entry only.
 
    - all integer types (int, unsigned_int, long etc.) become Foam::label
    - all real types (float, double) become Foam::scalar
    - POINTS becomes OpenFOAM points
    - CELLS gets split into OpenFOAM
        - cells
        - faces
        - lines
    - CELL_DATA or POINT_DATA gets stored on the corresponding objectRegistry
      in original vtk numbering order so use e.g. faceMap() to go from entry
      in faces() back to vtk numbering.
 
SourceFiles
    vtkUnstructuredReader.C
 
\*---------------------------------------------------------------------------*/
 
#ifndef vtkUnstructuredReader_H
#define vtkUnstructuredReader_H
 
#include "foamVtkCore.H"
#include "objectRegistry.H"
#include "cellShapeList.H"
#include "HashSet.H"
#include "Enum.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
/*---------------------------------------------------------------------------*\
                     Class vtkUnstructuredReader Declaration
\*---------------------------------------------------------------------------*/
 
class vtkUnstructuredReader
{
public:
 
    // Public Data Types
 
        //- Enumeration defining the vtk data types
        enum vtkDataType
        {
            VTK_INT,
            VTK_INT64,
            VTK_UINT,
            VTK_LONG,
            VTK_ULONG,
            VTK_FLOAT,
            VTK_DOUBLE,
            VTK_STRING,
            VTK_ID
        };
 
        static const Enum<vtkDataType> vtkDataTypeNames;
 
 
        //- Enumeration defining the vtk dataset types
        enum vtkDataSetType
        {
            VTK_FIELD,
            VTK_SCALARS,
            VTK_VECTORS
        };
 
        static const Enum<vtkDataSetType> vtkDataSetTypeNames;
 
 
        //- Enumeration defining the parse mode - type of data being read
        enum parseMode
        {
            NOMODE,
            UNSTRUCTURED_GRID,
            POLYDATA,
            CELL_DATA,
            POINT_DATA
        };
 
        static const Enum<parseMode> parseModeNames;
 
 
private:
 
    //- The VTK version
    float version_;
 
    //- Header
    string header_;
 
    //- Title
    string title_;
 
    //- DataType
    string dataType_;
 
 
    // Geometry
 
        //- Points
        pointField points_;
 
        //- 3D cells.
        cellShapeList cells_;
 
        //- Map from cells back to original ID
        labelList cellMap_;
 
        //- 2D cells (=faces)
        faceList faces_;
 
        //- Map from faces back to original ID
        labelList faceMap_;
 
        //- 1D cells (=edges)
        labelListList lines_;
 
        labelList lineMap_;
 
 
    // Data
 
        //- Cell based fields
        objectRegistry cellData_;
 
        //- Point based fields
        objectRegistry pointData_;
 
        //- Other fields
        objectRegistry otherData_;
 
 
 
    // Private Member Functions
 
        //- Read OFFSETS, CONNECTIVITY arrays
        static void readOffsetsConnectivity
        (
            ISstream& is,
            const char* entryName,
            const label nOffsets,
            labelList& offsets,
            const label nConnectivity,
            labelList& connectivity
        );
 
        static void warnUnhandledType
        (
            const Istream& is,  // For error message
            const label type,
            labelHashSet& warningGiven
        );
 
        //- Split cellTypes into cells, faces and lines
        void extractCells
        (
            const Istream& is,  // For error message
            const labelUList& cellTypes,
            const labelUList& cellOffsets,
            const labelUList& cellVertData
        );
 
        //- Read single field and stores it on the objectRegistry.
        void readField
        (
            ISstream& inFile,
            objectRegistry& obj,
            const word& arrayName,
            const word& dataType,
            const label size
        ) const;
 
        //- Reads fields, stores them on the objectRegistry. Returns a list of
        //  read fields
        wordList readFieldArray
        (
            ISstream& inFile,
            objectRegistry& obj,
            const label wantedSize
        ) const;
 
        objectRegistry& selectRegistry(const parseMode readMode);
 
        void read(ISstream& inFile);
 
        //- No copy assignment
        void operator=(const vtkUnstructuredReader&) = delete;
 
 
public:
 
    //- Runtime type information
    ClassName("vtkUnstructuredReader");
 
 
    // Constructors
 
        //- Construct from input stream, read all
        vtkUnstructuredReader(const objectRegistry& obr, ISstream& is);
 
 
    // Member Functions
 
        //- Header
        const string& header() const noexcept
        {
            return header_;
        }
 
        //- Title
        const string& title() const noexcept
        {
            return title_;
        }
 
        //- DataType
        const string& dataType() const noexcept
        {
            return dataType_;
        }
 
 
        //- Points
        const pointField& points() const noexcept
        {
            return points_;
        }
 
        pointField& points() noexcept
        {
            return points_;
        }
 
        //- 3D cells
        const cellShapeList& cells() const noexcept
        {
            return cells_;
        }
 
        cellShapeList& cells() noexcept
        {
            return cells_;
        }
 
        const labelList& cellMap() const noexcept
        {
            return cellMap_;
        }
 
        //- 2D cells (=faces)
        const faceList& faces() const noexcept
        {
            return faces_;
        }
 
        faceList& faces() noexcept
        {
            return faces_;
        }
 
        const labelList& faceMap() const noexcept
        {
            return faceMap_;
        }
 
        //- 1D cells (=open lines)
        const labelListList& lines() const noexcept
        {
            return lines_;
        }
 
        labelListList& lines() noexcept
        {
            return lines_;
        }
 
        const labelList& lineMap() const noexcept
        {
            return lineMap_;
        }
 
        //- Cell based fields
        const objectRegistry& cellData() const noexcept
        {
            return cellData_;
        }
 
        objectRegistry& cellData() noexcept
        {
            return cellData_;
        }
 
        //- Point based fields
        const objectRegistry& pointData() const noexcept
        {
            return pointData_;
        }
 
        objectRegistry& pointData() noexcept
        {
            return pointData_;
        }
 
        //- Other fields
        const objectRegistry& otherData() const noexcept
        {
            return otherData_;
        }
 
        objectRegistry& otherData() noexcept
        {
            return otherData_;
        }
 
 
        //- Debug: print contents of objectRegistry
        template<class Type>
        static void printFieldStats(const objectRegistry&);
};
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#ifdef NoRepository
    #include "vtkUnstructuredReaderTemplates.C"
#endif
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //