structgrid.h

/***********************************************************************************
 * VTKwrap - Simple VTK wrappers                                                   *
 * Copyright (C) 2005 Dorival de Moraes Pedroso <dorival.pedroso at gmail.com>     *
 *                                                                                 *
 * This file is part of VTKwrap.                                                   *
 *                                                                                 *
 * VTKwrap 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 2 of the License, or (at your option) any later      *
 * version.                                                                        *
 *                                                                                 *
 * VTKwrap 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    *
 * VTKwrap; if not, write to the Free Software Foundation, Inc., 51 Franklin       *
 * Street, Fifth Floor, Boston, MA 02110-1301, USA                                 *
 ***********************************************************************************/

#ifndef VTKWRAP_STRUCTGRID_H
#define VTKWRAP_STRUCTGRID_H

#include "numerical/meshgrid.h"

#include "vtkPoints.h"
#include "vtkFloatArray.h"
#include "vtkStructuredGrid.h"
#include "vtkPointData.h"
#include "vtkStructuredGridWriter.h"

class StructGrid // Porco-espinho
{
    friend std::ostream & operator<< (std::ostream & os, StructGrid const & sg);
public:
    struct VectorTuple
    {
        double vx;
        double vy;
        double vz;
    };
    StructGrid(double const X[], int nX,
               double const Y[], int nY,
               double const Z[], int nZ,
               double const F[]=NULL, VectorTuple const V[]=NULL) // arrays size must be equal to nX*nY*nZ
    {
        // Create VTK points, scalars and vectors
        _points  = vtkPoints              ::New();
        _scalars = vtkFloatArray          ::New();
        _vectors = vtkFloatArray          ::New();
        _points  -> Allocate              (nX*nY*nZ);
        _scalars -> Allocate              (nX*nY*nZ);
        _vectors -> SetNumberOfComponents (3);
        _vectors -> SetNumberOfTuples     (nX*nY*nZ);

        // Fill structures
        for (int i=0; i<nX*nY*nZ; ++i)
        {
            _points -> InsertPoint(i, X[i], Y[i], Z[i]);
            if (F==NULL) _scalars -> InsertTuple1(i, i);
            else         _scalars -> InsertTuple1(i, F[i]);
            if (V==NULL) _vectors -> InsertTuple3(i, 1.0, 1.0, 1.0); // point along hydro-axis
            else         _vectors -> InsertTuple3(i, V[i].vx, V[i].vy, V[i].vz);
        }

        // Create VTK StructuredGrid
        _sgrid = vtkStructuredGrid ::New();
        _sgrid -> SetDimensions    (nX, nY, nZ);
        _sgrid -> SetPoints        (_points);
        _sgrid -> GetPointData     () -> SetScalars(_scalars);
        _sgrid -> GetPointData     () -> SetVectors(_vectors);
    }
    StructGrid(MeshGrid const & mg, double const F[]=NULL, VectorTuple const V[]=NULL) // F size must be equal to mg.Length()
    {
        // Create VTK points, scalars and vectors
        _points  = vtkPoints              ::New();
        _scalars = vtkFloatArray          ::New();
        _vectors = vtkFloatArray          ::New();
        _points  -> Allocate              (mg.Length()); // mg.Length() == mg.nX()*mg.nY()*mg.nZ()
        _scalars -> Allocate              (mg.Length());
        _vectors -> SetNumberOfComponents (3);
        _vectors -> SetNumberOfTuples     (mg.Length());

        // Fill structures
        for (int i=0; i<mg.Length(); ++i)
        {
            _points -> InsertPoint(i, mg.X(i), mg.Y(i), mg.Z(i));
            if (F==NULL) _scalars -> InsertTuple1(i, i);
            else         _scalars -> InsertTuple1(i, F[i]);
            if (V==NULL) _vectors -> InsertTuple3(i, 1.0, 1.0, 1.0); // point along hydro-axis
            else         _vectors -> InsertTuple3(i, V[i].vx, V[i].vy, V[i].vz);
        }

        // Create VTK StructuredGrid
        _sgrid = vtkStructuredGrid ::New();
        _sgrid -> SetDimensions    (mg.nX(), mg.nY(), mg.nZ());
        _sgrid -> SetPoints        (_points);
        _sgrid -> GetPointData     () -> SetScalars(_scalars);
        _sgrid -> GetPointData     () -> SetVectors(_vectors);
    }
    ~StructGrid()
    {
        _points  -> Delete();
        _scalars -> Delete();
        _vectors -> Delete();
        _sgrid   -> Delete();
    }
    vtkStructuredGrid * GetGrid() { return _sgrid; }
    void WriteFile(char const * Filename)
    {
        vtkStructuredGridWriter * writer = vtkStructuredGridWriter::New();
        writer -> SetInput(_sgrid);
        writer -> SetFileName(Filename);
        writer -> Write();
    }
private:
    vtkPoints         * _points;
    vtkFloatArray     * _scalars;
    vtkFloatArray     * _vectors;
    vtkStructuredGrid * _sgrid;
}; // class StructGrid

std::ostream & operator<< (std::ostream & os, StructGrid const & sg)
{
    sg._sgrid->Print(os);
    return os;
}

#endif // VTKWRAP_STRUCTGRID_H

// vim:fdm=marker

---