cutclip.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_CUTCLIP_H
#define VTKWRAP_CUTCLIP_H

#include <vector>

// VTK
#include "vtkPlane.h"
#include "vtkClipPolyData.h"
#include "vtkPolyDataMapper.h"
#include "vtkProperty.h"
#include "vtkActor.h"
#include "vtkCutter.h"
#include "vtkStripper.h"
#include "vtkPolyData.h"
#include "vtkTriangleFilter.h"

// MechSys
#include "util/string.h"
#include "vtkwrap/colors.h"
#include "vtkwrap/vtkwin.h"

class CutClip
{
    friend std::ostream & operator<< (std::ostream & os, CutClip const & cc);
public:
    // Constructor & Destructor
     CutClip();
    ~CutClip();

    // Config methods
    CutClip & SetClipColor  (String const & Color  ) { _clip_clr  =Color  ; return (*this); }
    CutClip & SetClipOpac   (double         Opacity) { _clip_opac =Opacity; return (*this); }
    CutClip & SetBackColor  (String const & Color  ) { _back_clr  =Color  ; return (*this); }
    CutClip & SetCutColor   (String const & Color  ) { _cut_clr   =Color  ; return (*this); }
    CutClip & SetCutOpac    (double         Opacity) { _cut_opac  =Opacity; return (*this); }
    CutClip & SetCPartColor (String const & Color  ) { _cpart_clr =Color  ; return (*this); }
    CutClip & SetCPartOpac  (double         Opacity) { _cpart_opac=Opacity; return (*this); }
    CutClip & SetCPartWire  (bool           UseWire) { _cpart_wire=UseWire; return (*this); }

    // Methods
    void Generate (double x0, double y0, double z0, double nx, double ny, double nz, vtkAlgorithmOutput * OutPort);

    // Methods
    vtkActor * GetClipActor () { return _clip_actor;  }
    vtkActor * GetCutActor  () { return _cut_actor;   }
    vtkActor * GetCPartActor() { return _cpart_actor; }

    // Methods
    void AddActorsTo   (VTKWin & Win);
    void DelActorsFrom (VTKWin & Win);

private:
    // Data
    String              _clip_clr;
    double              _clip_opac;
    String              _back_clr;
    String              _cut_clr;
    double              _cut_opac;
    String              _cpart_clr;
    double              _cpart_opac;
    bool                _cpart_wire;
    // Clipper
    vtkPlane          * _plane;
    vtkClipPolyData   * _clipper;
    vtkPolyDataMapper * _clip_mapper;
    vtkProperty       * _back_prop;
    vtkActor          * _clip_actor;
    // Cutter
    vtkCutter         * _cut_edges;
    vtkStripper       * _cut_strips;
    vtkPolyData       * _cut_poly;
    vtkTriangleFilter * _cut_triangles;
    vtkPolyDataMapper * _cut_mapper;
    vtkActor          * _cut_actor;
    // Clipped part
    vtkPolyDataMapper * _cpart_mapper;
    vtkActor          * _cpart_actor;

    // Methods
    void _clean_up ();
}; // class CutClip

std::ostream & operator<< (std::ostream & os, CutClip const & cc) // {{{
{
    cc._clipper->Print(os);
    return os;
} // }}}




inline CutClip::CutClip() // {{{
    : _clip_clr      (String("peacock")),
      _clip_opac     (1.0),
      _back_clr      (String("green")),
      _cut_clr       (String("red")),
      _cut_opac      (1.0),
      _cpart_clr     (String("yellow")),
      _cpart_opac    (1.0),
      _cpart_wire    (false),
      _plane         (NULL),
      _clipper       (NULL),
      _clip_mapper   (NULL),
      _back_prop     (NULL),
      _clip_actor    (NULL),
      _cut_edges     (NULL),
      _cut_strips    (NULL),
      _cut_poly      (NULL),
      _cut_triangles (NULL),
      _cut_mapper    (NULL),
      _cut_actor     (NULL),
      _cpart_mapper  (NULL),
      _cpart_actor   (NULL)
{
} // }}}

inline CutClip::~CutClip() // {{{
{
    _clean_up();
} // }}}

inline void CutClip::Generate (double x0, double y0, double z0, double nx, double ny, double nz, vtkAlgorithmOutput * OutPort) // {{{
{
    // Clean allocated resources
    _clean_up();

    // Clipper
    _plane       = vtkPlane          :: New();
    _clipper     = vtkClipPolyData   :: New();
    _clip_mapper = vtkPolyDataMapper :: New();
    _back_prop   = vtkProperty       :: New();
    _clip_actor  = vtkActor          :: New();
    _plane       -> SetOrigin(x0, y0, z0);
    _plane       -> SetNormal(nx, ny, nz);
    _clipper     -> SetInputConnection      (OutPort);
    _clipper     -> SetClipFunction         (_plane);
    _clipper     -> GenerateClipScalarsOn   ();
    _clipper     -> GenerateClippedOutputOn ();
    _clipper     -> SetValue                (0); //(0.5);
    _clip_mapper -> SetInputConnection      (_clipper->GetOutputPort());
    _clip_mapper -> ScalarVisibilityOff     ();
    _back_prop   -> SetDiffuseColor         (CLR[_back_clr.GetSTL()].C);
    _clip_actor  -> SetMapper               (_clip_mapper);
    _clip_actor  -> GetProperty             ()->SetColor(CLR[_clip_clr.GetSTL()].C);
    _clip_actor  -> GetProperty             ()->SetOpacity(_clip_opac);
    _clip_actor  -> SetBackfaceProperty     (_back_prop);

    // Cutter
    _cut_edges     = vtkCutter         :: New();
    _cut_strips    = vtkStripper       :: New();
    _cut_poly      = vtkPolyData       :: New();
    _cut_triangles = vtkTriangleFilter :: New();
    _cut_mapper    = vtkPolyDataMapper :: New();
    _cut_actor     = vtkActor          :: New();
    _cut_edges     -> SetInputConnection   (OutPort);
    _cut_edges     -> SetCutFunction       (_plane);
    _cut_edges     -> GenerateCutScalarsOn ();
    _cut_edges     -> SetValue             (0, 0); //0.5);
    _cut_strips    -> SetInputConnection   (_cut_edges->GetOutputPort());
    _cut_strips    -> Update               ();
    _cut_poly      -> SetPoints            (_cut_strips->GetOutput()->GetPoints());
    _cut_poly      -> SetPolys             (_cut_strips->GetOutput()->GetLines ());
    _cut_triangles -> SetInput             (_cut_poly);
    _cut_mapper    -> SetInput             (_cut_poly);
    _cut_mapper    -> SetInputConnection   (_cut_triangles->GetOutputPort());
    _cut_actor     -> SetMapper            (_cut_mapper);
    _cut_actor     -> GetProperty          ()->SetColor(CLR[_cut_clr.GetSTL()].C);
    _cut_actor     -> GetProperty          ()->SetOpacity(_cut_opac);

    // Clipped part
    _cpart_mapper = vtkPolyDataMapper ::New();
    _cpart_actor  = vtkActor          ::New();
    _cpart_mapper -> SetInput            (_clipper->GetClippedOutput());
    _cpart_mapper -> ScalarVisibilityOff ();
    _cpart_actor  -> SetMapper           (_cpart_mapper);
    _cpart_actor  -> GetProperty         ()->SetColor(CLR[_cpart_clr.GetSTL()].C);
    _cpart_actor  -> GetProperty         ()->SetOpacity(_cpart_opac);
    if (_cpart_wire)
    {
        _cpart_actor->GetProperty()->SetRepresentationToWireframe();
    }

    _clip_mapper ->SetResolveCoincidentTopologyPolygonOffsetParameters(0,1);
    _clip_mapper ->SetResolveCoincidentTopologyToPolygonOffset();
    _cut_mapper  ->SetResolveCoincidentTopologyPolygonOffsetParameters(1,1);
    _cut_mapper  ->SetResolveCoincidentTopologyToPolygonOffset();
    _cpart_mapper->SetResolveCoincidentTopologyPolygonOffsetParameters(1,1);
    _cpart_mapper->SetResolveCoincidentTopologyToPolygonOffset();

} // }}}

inline void CutClip::AddActorsTo(VTKWin & Win) // {{{
{
    Win.AddActor(_clip_actor );
    Win.AddActor(_cut_actor  );
    Win.AddActor(_cpart_actor);
} // }}}

inline void CutClip::DelActorsFrom(VTKWin & Win) // {{{
{
    Win.DelActor(_clip_actor );
    Win.DelActor(_cut_actor  );
    Win.DelActor(_cpart_actor);
} // }}}

inline void CutClip::_clean_up() // {{{
{
    // Clipper
    if (_plane      !=NULL) _plane       -> Delete();
    if (_clipper    !=NULL) _clipper     -> Delete();
    if (_clip_mapper!=NULL) _clip_mapper -> Delete();
    if (_back_prop  !=NULL) _back_prop   -> Delete();
    if (_clip_actor !=NULL) _clip_actor  -> Delete();
    // Cutter
    if (_cut_edges    !=NULL) _cut_edges     -> Delete();
    if (_cut_strips   !=NULL) _cut_strips    -> Delete();
    if (_cut_poly     !=NULL) _cut_poly      -> Delete();
    if (_cut_triangles!=NULL) _cut_triangles -> Delete();
    if (_cut_mapper   !=NULL) _cut_mapper    -> Delete();
    if (_cut_actor    !=NULL) _cut_actor     -> Delete();
    // Clipped part
    if (_cpart_mapper!=NULL) _cpart_mapper -> Delete();
    if (_cpart_actor !=NULL) _cpart_actor  -> Delete();
} // }}}

#endif // VTKWRAP_CUTCLIP_H

// vim:fdm=marker

---