src/sampling/sampledSurface/writers/vtk/vtkSurfaceWriter.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2008-2011 OpenCFD Ltd.
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software: you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 \*---------------------------------------------------------------------------*/
  25
  26 #include "vtkSurfaceWriter.H"
  27
  28 #include "OFstream.H"
  29 #include "OSspecific.H"
  30
  31 #include "makeSurfaceWriterMethods.H"
  32
  33 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  34
  35 namespace Foam
  36 {
  37     makeSurfaceWriterType(vtkSurfaceWriter);
  38 }
  39
  40
  41 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  42
  43 void Foam::vtkSurfaceWriter::writeGeometry
  44 (
  45     Ostream& os,
  46     const pointField& points,
  47     const faceList& faces
  48 )
  49 {
  50     // header
  51     os
  52         << "# vtk DataFile Version 2.0" << nl
  53         << "sampleSurface" << nl
  54         << "ASCII" << nl
  55         << "DATASET POLYDATA" << nl;
  56
  57     // Write vertex coords
  58     os  << "POINTS " << points.size() << " float" << nl;
  59     forAll(points, pointI)
  60     {
  61         const point& pt = points[pointI];
  62         os  << float(pt.x()) << ' '
  63             << float(pt.y()) << ' '
  64             << float(pt.z()) << nl;
  65     }
  66     os  << nl;
  67
  68
  69     // Write faces
  70     label nNodes = 0;
  71     forAll(faces, faceI)
  72     {
  73         nNodes += faces[faceI].size();
  74     }
  75
  76     os  << "POLYGONS " << faces.size() << ' '
  77         << faces.size() + nNodes << nl;
  78
  79     forAll(faces, faceI)
  80     {
  81         const face& f = faces[faceI];
  82
  83         os  << f.size();
  84         forAll(f, fp)
  85         {
  86             os  << ' ' << f[fp];
  87         }
  88         os  << nl;
  89     }
  90 }
  91
  92
  93 namespace Foam
  94 {
  95
  96     template<>
  97     void Foam::vtkSurfaceWriter::writeData
  98     (
  99         Ostream& os,
 100         const Field<scalar>& values
 101     )
 102     {
 103         os  << "1 " << values.size() << " float" << nl;
 104
 105         forAll(values, elemI)
 106         {
 107             if (elemI)
 108             {
 109                 if (elemI % 10)
 110                 {
 111                     os  << ' ';
 112                 }
 113                 else
 114                 {
 115                     os  << nl;
 116                 }
 117             }
 118
 119             os  << float(values[elemI]);
 120         }
 121         os  << nl;
 122     }
 123
 124
 125     template<>
 126     void Foam::vtkSurfaceWriter::writeData
 127     (
 128         Ostream& os,
 129         const Field<vector>& values
 130     )
 131     {
 132         os  << "3 " << values.size() << " float" << nl;
 133
 134         forAll(values, elemI)
 135         {
 136             const vector& v = values[elemI];
 137             os  << float(v[0]) << ' ' << float(v[1]) << ' ' << float(v[2])
 138                 << nl;
 139         }
 140     }
 141
 142
 143     template<>
 144     void Foam::vtkSurfaceWriter::writeData
 145     (
 146         Ostream& os,
 147         const Field<sphericalTensor>& values
 148     )
 149     {
 150         os  << "1 " << values.size() << " float" << nl;
 151
 152         forAll(values, elemI)
 153         {
 154             const sphericalTensor& v = values[elemI];
 155             os  << float(v[0]) << nl;
 156         }
 157     }
 158
 159
 160     template<>
 161     void Foam::vtkSurfaceWriter::writeData
 162     (
 163         Ostream& os,
 164         const Field<symmTensor>& values
 165     )
 166     {
 167         os  << "6 " << values.size() << " float" << nl;
 168
 169         forAll(values, elemI)
 170         {
 171             const symmTensor& v = values[elemI];
 172             os  << float(v[0]) << ' ' << float(v[1]) << ' ' << float(v[2])
 173                 << float(v[3]) << ' ' << float(v[4]) << ' ' << float(v[5])
 174                 << nl;
 175
 176         }
 177     }
 178
 179
 180     template<>
 181     void Foam::vtkSurfaceWriter::writeData
 182     (
 183         Ostream& os,
 184         const Field<tensor>& values
 185     )
 186     {
 187         os  << "9 " << values.size() << " float" << nl;
 188
 189         forAll(values, elemI)
 190         {
 191             const tensor& v = values[elemI];
 192             os  << float(v[0]) << ' ' << float(v[1]) << ' ' << float(v[2])
 193                 << float(v[3]) << ' ' << float(v[4]) << ' ' << float(v[5])
 194                 << float(v[6]) << ' ' << float(v[7]) << ' ' << float(v[8])
 195                 << nl;
 196         }
 197     }
 198
 199 }
 200
 201
 202 // Write generic field in vtk format
 203 template<class Type>
 204 void Foam::vtkSurfaceWriter::writeData
 205 (
 206     Ostream& os,
 207     const Field<Type>& values
 208 )
 209 {
 210     os  << "1 " << values.size() << " float" << nl;
 211
 212     forAll(values, elemI)
 213     {
 214         os  << float(0) << nl;
 215     }
 216 }
 217
 218
 219 template<class Type>
 220 void Foam::vtkSurfaceWriter::writeTemplate
 221 (
 222     const fileName& outputDir,
 223     const fileName& surfaceName,
 224     const pointField& points,
 225     const faceList& faces,
 226     const word& fieldName,
 227     const Field<Type>& values,
 228     const bool isNodeValues,
 229     const bool verbose
 230 ) const
 231 {
 232     if (!isDir(outputDir))
 233     {
 234         mkDir(outputDir);
 235     }
 236
 237     OFstream os(outputDir/fieldName + '_' + surfaceName + ".vtk");
 238
 239     if (verbose)
 240     {
 241         Info<< "Writing field " << fieldName << " to " << os.name() << endl;
 242     }
 243
 244     writeGeometry(os, points, faces);
 245
 246     // start writing data
 247     if (isNodeValues)
 248     {
 249         os  << "POINT_DATA ";
 250     }
 251     else
 252     {
 253         os  << "CELL_DATA ";
 254     }
 255
 256     os  << values.size() << nl
 257         << "FIELD attributes 1" << nl
 258         << fieldName << " ";
 259
 260     // Write data
 261     writeData(os, values);
 262 }
 263
 264
 265 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 266
 267 Foam::vtkSurfaceWriter::vtkSurfaceWriter()
 268 :
 269     surfaceWriter()
 270 {}
 271
 272
 273 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 274
 275 Foam::vtkSurfaceWriter::~vtkSurfaceWriter()
 276 {}
 277
 278
 279 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 280
 281 void Foam::vtkSurfaceWriter::write
 282 (
 283     const fileName& outputDir,
 284     const fileName& surfaceName,
 285     const pointField& points,
 286     const faceList& faces,
 287     const bool verbose
 288 ) const
 289 {
 290     if (!isDir(outputDir))
 291     {
 292         mkDir(outputDir);
 293     }
 294
 295     OFstream os(outputDir/surfaceName + ".vtk");
 296
 297     if (verbose)
 298     {
 299         Info<< "Writing geometry to " << os.name() << endl;
 300     }
 301
 302     writeGeometry(os, points, faces);
 303 }
 304
 305
 306 // create write methods
 307 defineSurfaceWriterWriteFields(Foam::vtkSurfaceWriter);
 308
 309
 310 // ************************************************************************* //