songtianlun/openfoam
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ENH: VTKEdgeFormat: unstructed vtk reader

Browse Source
This commit is contained in:
mattijs 2012-03-02 15:04:08 +00:00
parent 609453ddbc
commit 7e38936458
12 changed files with 1516 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/OpenFOAM/Make/files
View File

@ -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

45
src/OpenFOAM/primitives/strings/string/stringIOList.C Normal file
View File

@ -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
);
}
// ************************************************************************* //

50
src/OpenFOAM/primitives/strings/string/stringIOList.H Normal file
View File

@ -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
// ************************************************************************* //

40
src/OpenFOAM/primitives/strings/word/wordIOList.C Normal file
View File

@ -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);
}
// ************************************************************************* //

50
src/OpenFOAM/primitives/strings/word/wordIOList.H Normal file
View File

@ -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
// ************************************************************************* //

2
src/conversion/Make/files
View File

@ -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

878
src/conversion/vtk/vtkUnstructuredReader.C Normal file
View File

@ -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;
}
}
// ************************************************************************* //

332
src/conversion/vtk/vtkUnstructuredReader.H Normal file
View File

@ -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
// ************************************************************************* //

2
src/edgeMesh/Make/options
View File

@ -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

84
src/edgeMesh/edgeFormats/vtk/VTKedgeFormat.C
View File

@ -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);
}

36
src/edgeMesh/edgeFormats/vtk/VTKedgeFormat.H
View File

@ -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
VTKedgeFormat();
//- Construct from file name
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
static void write(const fileName&, const edgeMesh&);
//- Write edgeMesh
static void write(const fileName&, const edgeMesh&);
//- Read from file
virtual bool read(const fileName&);
// //- Write object
// virtual void write(Ostream& os) const
// {
// write(os, *this);
// }
//- Write object file
virtual void write(const fileName& name) const
{
write(name, *this);
}
};

12
src/edgeMesh/edgeFormats/vtk/VTKedgeFormatRunTime.C
View File

@ -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,