pcl_painter2D.h

Go to the documentation of this file.

/*
 * Software License Agreement (BSD License)
 *
 *  Point Cloud Library (PCL) - www.pointclouds.org
 *  Copyright (c) 2012-, Open Perception, Inc.
 *
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above
 *     copyright notice, this list of conditions and the following
 *     disclaimer in the documentation and/or other materials provided
 *     with the distribution.
 *   * Neither the name of the copyright holder(s) nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 *
 */

#ifndef PCL_VISUALUALIZATION_PCL_PAINTER2D_H_
#define PCL_VISUALUALIZATION_PCL_PAINTER2D_H_

#include <iostream>
#include <map>
#include <vector>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkSmartPointer.h>
#include <vtkObjectFactory.h>
#include <vtkContext2D.h>
#include <vtkTransform2D.h>
#include <vtkContextItem.h>
#include <vtkContextView.h>
#include <vtkContextScene.h>
#include <vtkPen.h>
#include <vtkBrush.h>
#include <vtkTextProperty.h>
#include <vtkOpenGLContextDevice2D.h>
#include <vtkPoints2D.h>
#include "vtkCommand.h"

#include <vtkRegressionTestImage.h>

namespace pcl
{
  namespace visualization
  {

    struct Figure2D
    {
      std::vector<float> info_;     //information stored in a general form for every object
      vtkPen *pen_;                 //the corresponding pen and brush for the figure
      vtkBrush *brush_;
      vtkTransform2D *transform_;
      
      Figure2D (std::vector<float> info, vtkPen *p, vtkBrush * b, vtkTransform2D *t)
      {
        this->pen_ = vtkPen::New ();
        this->brush_ = vtkBrush::New ();
        this->transform_ = vtkTransform2D::New();

        this->pen_->DeepCopy (p);
        this->brush_->DeepCopy (b);
        this->transform_->SetMatrix (t->GetMatrix());
        this->info_ = info; //note: it copies :-)
      }

      Figure2D (vtkPen *p, vtkBrush * b, vtkTransform2D *t)
      {
        this->pen_ = vtkPen::New ();
        this->brush_ = vtkBrush::New ();
        this->transform_ = vtkTransform2D::New();

        this->pen_->DeepCopy (p);
        this->brush_->DeepCopy (b);
        this->transform_->SetMatrix (t->GetMatrix());
      }
      
      void applyInternals (vtkContext2D *painter)
      {
        painter->ApplyPen (pen_);
        painter->ApplyBrush (brush_);
        painter->GetDevice ()->SetMatrix (transform_->GetMatrix());
      }
                  
      virtual void draw (vtkContext2D *) {}
    };
    
    struct FPolyLine2D : public Figure2D
    {

      FPolyLine2D (std::vector<float> info, vtkPen *p, vtkBrush * b, vtkTransform2D *t) : Figure2D (info, p, b, t){}

      void draw (vtkContext2D * painter)
      {
        applyInternals(painter);  
        painter->DrawPoly (&info_[0], static_cast<unsigned int> (info_.size ()) / 2);
      }
    };

    struct FPoints2D : public Figure2D
    {

      FPoints2D (std::vector<float> info, vtkPen *p, vtkBrush * b, vtkTransform2D *t) : Figure2D (info, p, b, t) {}

      void draw (vtkContext2D * painter)
      {
        applyInternals(painter);  
        painter->DrawPoints (&info_[0], static_cast<unsigned int> (info_.size ()) / 2);
      }
    };

    struct FQuad2D : public Figure2D
    {

      FQuad2D (std::vector<float> info, vtkPen *p, vtkBrush * b, vtkTransform2D *t) : Figure2D (info, p, b, t) {}

      void draw (vtkContext2D * painter)
      {
        applyInternals(painter);  
        painter->DrawQuad (&info_[0]);
      }
    };
    
    struct FPolygon2D : public Figure2D
    {

      FPolygon2D (std::vector<float> info, vtkPen *p, vtkBrush * b, vtkTransform2D *t) : Figure2D (info, p, b, t){}

      void draw (vtkContext2D * painter)
      {
        applyInternals(painter);  
        painter->DrawPolygon (&info_[0], static_cast<unsigned int> (info_.size ()) / 2);
      }
    };
    
    struct FEllipticArc2D : public Figure2D
    {

      FEllipticArc2D (std::vector<float> info, vtkPen *p, vtkBrush * b, vtkTransform2D *t) : Figure2D (info, p, b, t) {}

      FEllipticArc2D (float x, float y, float rx, float ry, float sa, float ea, vtkPen *p, vtkBrush * b, vtkTransform2D *t) : Figure2D (p, b, t)
      {
        info_.resize (6);
        info_[0] = x;
        info_[1] = y;
        info_[2] = rx;
        info_[3] = ry;
        info_[4] = sa;
        info_[5] = ea;
      }

      void draw (vtkContext2D * painter)
      {
        applyInternals(painter);  
        painter->DrawEllipticArc (info_[0], info_[1], info_[2], info_[3], info_[4], info_[5]);
      }
    };



    class PCLPainter2D: public vtkContextItem
    {
    public:

      //static PCLPainter2D *New();
      
      PCLPainter2D (char const * name = "PCLPainter2D");
      vtkTypeRevisionMacro (PCLPainter2D, vtkContextItem);

      virtual bool 
      Paint (vtkContext2D *painter);

      void 
      addLine (float x1, float y1, float x2, float y2);
      
      void 
      addLine (std::vector<float> p);

      
      void 
      addPoint (float x, float y);
      void 
      addPoints (std::vector<float> points);
      
      
      void 
      addRect (float x, float y, float width, float height);
      
      void 
      addQuad (std::vector<float> p);
      
      void 
      addPolygon (std::vector<float> p);

      
      void 
      addEllipse (float x, float y, float rx, float ry);
      
      void 
      addCircle (float x, float y, float r);
      
      void 
      addEllipticArc (float x, float y, float rx, float ry, float start_angle, float end_angle);
      
      void 
      addArc (float x, float y, float r, float start_angle, float end_angle);


      void 
      translatePen (double x, double y);
      
      void 
      rotatePen(double angle);
      
      void 
      scalePen(double x, double y);
      
      void 
      setTransform(vtkMatrix3x3 *matrix);
      
      vtkMatrix3x3 * 
      getTransform();
      
      void 
      clearTransform();
      
       void
       clearFigures();

      void setPenColor (unsigned char r, unsigned char g, unsigned char b, unsigned char a);
      void setPenWidth (float w);
      void setPenType (int type);

      unsigned char* getPenColor ();
      float getPenWidth ();
      int getPenType ();
      void setPen (vtkPen *pen);
      vtkPen* getPen ();

      void setBrush (vtkBrush *brush);
      vtkBrush* getBrush ();
      void setBrushColor (unsigned char r, unsigned char g, unsigned char b, unsigned char a);
      unsigned char* getBrushColor ();

      void
      setBackgroundColor (const double r, const double g, const double b);

      void
      setBackgroundColor (const double color[3]);

      double *
      getBackgroundColor ();


      void
      setWindowSize (int w, int h);

      int *
      getWindowSize ();

      void display ();
      
      void spinOnce ( const int spin_time = 0 );
        
      void spin ();

    private:
      //std::map< int, std::vector< std::vector<float> > > figures_; //FIG_TYPE -> vector<array>

      //All the figures drawn till now gets stored here
      std::vector<Figure2D *> figures_;
    
      //state variables of the class
      vtkPen *current_pen_;
      vtkBrush *current_brush_;
      vtkTransform2D *current_transform_;
      int win_width_, win_height_;
      double bkg_color_[3];

      vtkContextView *view_;
      
      //####event callback class####
        struct ExitMainLoopTimerCallback : public vtkCommand
        {
          static ExitMainLoopTimerCallback* New ()
          {
            return (new ExitMainLoopTimerCallback);
          }
          virtual void 
          Execute (vtkObject* vtkNotUsed (caller), unsigned long event_id, void* call_data)
          {
            if (event_id != vtkCommand::TimerEvent)
              return;
            int timer_id = *(reinterpret_cast<int*> (call_data));

            if (timer_id != right_timer_id)
              return;

            // Stop vtk loop and send notification to app to wake it up
#if ((VTK_MAJOR_VERSION == 5) && (VTK_MINOR_VERSION <= 4))
            interactor->stopLoop ();
#else
            interactor->TerminateApp ();
#endif
          }
          int right_timer_id;
#if ((VTK_MAJOR_VERSION == 5) && (VTK_MINOR_VERSION <= 4))
          PCLVisualizerInteractor *interactor;
#else
          vtkRenderWindowInteractor *interactor;
#endif
        };
        
        vtkSmartPointer<ExitMainLoopTimerCallback> exit_loop_timer_;
    };

  }
}

#endif  /* PCL_VISUALUALIZATION_PCL_PAINTER2D_H_ */