arrow.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_ARROW3D_H
#define VTKWRAP_ARROW3D_H

#include "vtkConeSource.h"
#include "vtkCylinderSource.h"
#include "vtkAppendPolyData.h"
#include "vtkTransform.h"
#include "vtkTransformFilter.h"
#include "vtkPoints.h"
#include "vtkFloatArray.h"
#include "vtkPolyData.h"
#include "vtkPointData.h"
#include "vtkArrowSource.h"
#include "vtkGlyph3D.h"
#include "vtkPolyDataMapper.h"
#include "vtkProperty.h"
#include "vtkLODActor.h"

#include "tensors/tensor1.h"

#include "colors.h"

class Arrow
{
    friend std::ostream & operator<< (std::ostream & os, Arrow const & ar);
public:
    // Auxiliar class
    class Geometry
    { // {{{
        /*                +-------------------------------+ 
         *                |            length             |
         *                +-----------------------+-------+
         *                |        bod_len        |tip_len|
         *                |                       |       |
         *                                        `.      ----+  
         *                                        | ``.       |
         *             +  +-----------------------|    ``.    |
         *     bod_rad |  |           +           |   +   >   | tip_rad   
         *             +  +-----------|-----------|   |_-'    |
         *                |           |           | _-|       |
         *                |           |           ''  |     --+  
         *                |           |               |
         *                +-----------+---------------+-------> y axis
         *                |           |               |    
         *                y0      y_bod_cen      y_tip_cen
         */
    public:
        Geometry(double BodyRadius=0.015, double TipRadius=0.03, double TipMultiplier=4.0, int Resolution=22)
            : _bod_rad (BodyRadius)       , 
              _tip_rad (TipRadius)        , 
              _tip_mul (TipMultiplier)    , 
              _resolut (Resolution)       , 
              _tip_len (_tip_mul*_tip_rad)
        {}
        Geometry(Geometry const & G)
        {
            _bod_rad = G._bod_rad;
            _tip_rad = G._tip_rad;
            _tip_mul = G._tip_mul;
            _resolut = G._resolut;
            _tip_len = G._tip_len;
        }
        double BodRad() const { return _bod_rad; }
        double TipRad() const { return _tip_rad; }
        double TipMul() const { return _tip_mul; }
        int    Resolu() const { return _resolut; }
        double TipLen() const { return _tip_len; }

    private:
        double _bod_rad; // body (cylinder) radius
        double _tip_rad; // tip (cone) radius
        double _tip_mul; // tip_len = tip_mul * tip_rad
        int    _resolut; // number of facets
        double _tip_len; // tip_len = tip_mul * tip_rad
    }; // class Geometry }}}

    // Constructor
    Arrow(double vx, double vy, double vz,  char const * Color=NULL, double x0=0.0, double y0=0.0, double z0=0.0, Geometry const * Geom=NULL)
    { _construct(vx,vy,vz, x0,y0,z0, Color, Geom); }

    Arrow(TensorsLib::Tensor1<double,3> const & V, char const * Color=NULL, double x0=0.0, double y0=0.0, double z0=0.0, Geometry const * Geom=NULL)
    { _construct(V[0],V[1],V[2], x0,y0,z0, Color, Geom); }

    // Destructor
    ~Arrow()
    {
        _vector        -> Delete();
        _vector_mapper -> Delete();
        _vector_actor  -> Delete();
    }

    // Methods
    vtkActor * GetActor() { return _vector_actor; }

private:
    // Data
    vtkGlyph3D        * _vector;
    vtkPolyDataMapper * _vector_mapper;
    vtkLODActor       * _vector_actor;
    void _construct(double vx, double vy, double vz, double x0, double y0, double z0, char const * Color, Geometry const * Geom);
}; // class Arrow

std::ostream & operator<< (std::ostream & os, Arrow const & ar)
{
    ar._vector->Print(os);
    return os;
}



inline void Arrow::_construct(double vx, double vy, double vz, double x0, double y0, double z0, char const * Color, Geometry const * Geom) // {{{
{
    // Color
    std::string * color;
    if (Color==NULL) color = new std::string ("red");
    else             color = new std::string (Color);

    // SetGeometry
    Geometry * geom;
    if (Geom==NULL) geom = new Geometry;
    else            geom = new Geometry (*Geom);

    // Dimensions
    double length  = sqrt(vx*vx + vy*vy + vz*vz);
    double bod_len = length-geom->TipLen();
    double bod_cen = bod_len/2.0;
    double tip_cen = bod_len+geom->TipLen()/2.0;

    // Create the body (cylinder) and tip (cone) of the arrow
    vtkConeSource     * cone  = vtkConeSource     ::New();
    vtkCylinderSource * cylin = vtkCylinderSource ::New();
    vtkAppendPolyData * arrow = vtkAppendPolyData ::New();
    cylin -> SetCenter     (0.0, bod_cen, 0.0);
    cylin -> SetHeight     (bod_len);
    cylin -> SetRadius     (geom->BodRad());
    cylin -> SetResolution (geom->Resolu());
    cone  -> SetCenter     (0.0, tip_cen, 0.0);
    cone  -> SetDirection  (0,1,0); // because cylinder direction is along y axis
    cone  -> SetHeight     (geom->TipLen());
    cone  -> SetRadius     (geom->TipRad());
    cone  -> SetResolution (geom->Resolu());
    arrow -> AddInput      (cone->GetOutput());
    arrow -> AddInput      (cylin->GetOutput());

    // Rotate arrow around z axis because glyph3D uses arrows on x axis
    vtkTransform       * rotate        = vtkTransform       ::New();
    vtkTransformFilter * arrow_along_x = vtkTransformFilter ::New();
    rotate        -> RotateZ      (-90.0);
    arrow_along_x -> SetTransform (rotate);
    arrow_along_x -> SetInput     (arrow->GetOutput());

    // Setup data for the glyph
    vtkPoints     * points   = vtkPoints     ::New();
    vtkFloatArray * vectors  = vtkFloatArray ::New();
    vtkPolyData   * polydata = vtkPolyData   ::New();
    points   -> SetNumberOfPoints     (1);
    points   -> InsertPoint           (0, x0,y0,z0);
    vectors  -> SetNumberOfComponents (3);
    vectors  -> SetNumberOfTuples     (1);
    vectors  -> InsertTuple3          (0, vx,vy,vz);
    polydata -> SetPoints             (points);
    polydata -> GetPointData() -> SetVectors(vectors);

    // Create the glyph
    _vector =  vtkGlyph3D                   ::New();
    _vector -> SetInput                     (polydata);
    _vector -> SetSource                    (arrow_along_x->GetPolyDataOutput());
    _vector -> SetVectorModeToUseVector     ();
    _vector -> SetScaleModeToDataScalingOff ();

    // Create mapper and actor
    _vector_mapper = vtkPolyDataMapper   ::New();
    _vector_actor  = vtkLODActor         ::New();
    _vector_mapper -> SetInputConnection (_vector->GetOutputPort());
    _vector_actor  -> SetMapper          (_vector_mapper);
    _vector_actor  -> GetProperty        ()->SetColor(CLR[color->c_str()].C);   
    _vector_actor  -> VisibilityOn       ();
    
    // Clean up
    cone          -> Delete();
    cylin         -> Delete();
    arrow         -> Delete();
    rotate        -> Delete();
    arrow_along_x -> Delete();
    points        -> Delete();
    vectors       -> Delete();
    polydata      -> Delete();

    // Clean up
    delete color;
    delete geom;
    
} // }}}

#endif // VTKWRAP_ARROW3D_H

// vim:fdm=marker

---