view_tri_interactor.cxx

Go to the documentation of this file.

/*
         Copyright 2008-2020 Pierre SMARS (smars@yuntech.edu.tw)
         This program 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.
 
         This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
         */
 
#include "view_tri_interactor.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkRendererCollection.h"
#include "vtkCellArray.h"
#include "vtkPointData.h"
#include "vtkCellData.h"
#include "vtkPolyData.h"
#include "vtkShortArray.h"
#include "vtkLight.h"
#include "vtkLightCollection.h"
#include "vtkProperty.h"
#include "vtkPolyDataMapper2D.h"
#include "vtkMapper.h"
#include "vtkProperty2D.h"
#include "vtkObjectFactory.h"
#include "vtkCamera.h"
#include "vtkRenderLargeImage.h"
#include "vtkVRMLExporter.h"
#include "vtkTIFFWriter.h"
#include "vtkJPEGWriter.h"
#include "vtkRIBExporter.h"
#include "vtkLookupTable.h"
#include "g_point.h"
 
#include "vtkCallbackCommand.h"
#include "vtkCommand.h"
 
#include <iostream>
#include <sstream>
#include <iomanip>
 
//vtkCxxRevisionMacro(view_tri_interactor, "$Revision: 1.3 $");
 
//------------------------------------------------------------------------------
view_tri_interactor* view_tri_interactor::New()
{
        // First try to create the object from the vtkObjectFactory
        vtkObject* ret = vtkObjectFactory::CreateInstance("view_tri_interactor");
        if(ret)
                return (view_tri_interactor*)ret;
        // If the factory was unable to create the object, then create it here.
        return new view_tri_interactor;
}
//---------------------------------------------------------------------------
view_tri_interactor::view_tri_interactor()
{
        initialised_ = false;
        ren_ = 0;
        n_ = 0;
        bg_ = true;
        is_changed_  = false;
        delete_mode_ = false;
        locator_ = vtkCellLocator::New();
        magnification_ = 1;
        size_ = 0;
        black_wire_ = false;
        flat_ = false;
}
//---------------------------------------------------------------------------
view_tri_interactor::~view_tri_interactor()
{
        actor_->Delete();
        locator_->Delete();
}
//---------------------------------------------------------------------------
void view_tri_interactor::reset()
{
        renWin_ = this->GetInteractor()->GetRenderWindow();
        vtkRendererCollection * rens = renWin_->GetRenderers();
        rens->InitTraversal();
        ren_ = rens->GetNextItem();
        vtkIdType pt[2];
        points_ = vtkPoints::New();
        pt[0] = points_->InsertNextPoint(0,0,0);
        pt[1] = points_->InsertNextPoint(1,0,0);
        vtkCellArray * lines = vtkCellArray::New();
        lines->InsertNextCell(2,pt);
        vtkPolyData * data = vtkPolyData::New();
        data->SetPoints(points_);
        points_->Delete();
        data->SetLines(lines);
        lines->Delete();
        vtkPolyDataMapper2D * map = vtkPolyDataMapper2D::New();
        map->SetInputData(data);
        data->Delete();
        actor_ = vtkActor2D::New();
        actor_->SetMapper(map);
        map->Delete();
        actor_->GetProperty()->SetColor(1,0.5,0.5);
        vtkLight * light = vtkLight::New();
        light->PositionalOff();
        light->SetLightTypeToCameraLight();
        ren_->GetLights()->InitTraversal();
        ren_->GetLights()->GetNextItem()->SwitchOff();
        ren_->AddLight(light);
        size_ = renWin_->GetSize();
        //      this->GetInteractor()->LightFollowCameraOff();
        initialised_ = true;
}
//---------------------------------------------------------------------------
void view_tri_interactor::OnLeftButtonDown()
{
        if (!initialised_) reset();
        vtkRenderWindowInteractor * rwi = this->Interactor;
        int ctrl = rwi->GetControlKey();
        int shift = rwi->GetShiftKey();
        int X,Y;
        rwi->GetEventPosition(X,Y);
        if (((ctrl >= 1)&&(shift >= 1))||(n_==1))
        {
                if (n_==0)
                {
                        Zbuffer_ = renWin_->GetZbufferData(0,0,size_[0]-1,size_[1]-1);
                        //a copy of the Zbuffer data is made when a line process starts
                        //this copy will then be used to compute the 3D position of point
                        //a better solution should be found
                }
                //              float Z = ren_->GetZ(X,Y);
                float Z = Zbuffer_[X+Y*size_[0]];
                if ((Z!=0)&&(Z!=1))
                {
                        ren_->SetDisplayPoint(X,Y,Z);
                        ren_->DisplayToWorld();
                        double * dp = ren_->GetWorldPoint();
                        if (delete_mode_)
                        {
                                is_changed_ = true;
                                //world coordinates of the select point
                                double x[3];
                                for (short i = 0; i < 3; i++) x[i] = dp[i]/dp[3];
                                //find the closest cell
                                vtkIdType cellId;
                                int subId;
                                double dist2;
                                locator_->FindClosestPoint(x,x,cellId,subId,dist2);
                                vtkDataArray * scalars = geometry_->GetCellData()->GetScalars();
                                int val = (int)scalars->GetTuple1(cellId);
                                if (val==1)
                                {
                                        scalars->SetTuple1(cellId,0);
                                        std::cerr << cellId << " 0" << std::endl;
                                }
                                else
                                {
                                        scalars->SetTuple1(cellId,1);
                                        std::cerr << cellId << " 1" << std::endl;
                                }
                                scalars->Modified();
                                rwi->GetRenderWindow()->Render();
                        }
                        else
                        {
                                n_++;
                                std::cout << "point " << n_ << " : ";
                                for (short k=0; k<3; k++)
                                {
                                        x_[3*(n_-1)+k] = dp[k] / dp[3];
                                        std::cout << x_[3*(n_-1)+k] << " ";
                                }
                                std::cout << std::endl;
                                if (n_==2)
                                {
                                        n_ = 0;
                                        g_point a(x_[0],x_[1],x_[2]);
                                        g_point b(x_[3],x_[4],x_[5]);
                                        g_point  c= b-a;
                                        ((g_point)(b-a)).print(std::cout);
                                        delete[] Zbuffer_;
                                        ren_->RemoveActor2D(actor_);
                                        renWin_->Render();
                                }
                                else
                                {
                                        float x2d[] = {static_cast<float>(X),static_cast<float>(Y),0.f};
                                        points_->SetPoint(0,x2d);
                                        ren_->AddActor2D(actor_);
                                        renWin_->Render();
                                }
                        }
                }
        }
        else
                vtkInteractorStyleTrackballCamera::OnLeftButtonDown();
}
//---------------------------------------------------------------------------
void view_tri_interactor::OnLeftButtonUp()
{
        vtkRenderWindowInteractor *rwi = this->Interactor;
        int ctrl = rwi->GetControlKey();
        int shift = rwi->GetShiftKey();
        if (((ctrl < 1)||(shift <1))&&(n_ != 1))
                vtkInteractorStyleTrackballCamera::OnLeftButtonUp();
        /*      vtkActor * actor = ren_->GetActors()->GetLastActor();
                        actor->SetBackfaceProperty(actor->GetProperty());
                        */
}
//---------------------------------------------------------------------------
void view_tri_interactor::OnMiddleButtonDown()
{
    vtkInteractorStyleTrackballCamera::OnRightButtonDown();
}
//---------------------------------------------------------------------------
void view_tri_interactor::OnMiddleButtonUp()
{
    vtkInteractorStyleTrackballCamera::OnRightButtonUp();
}
//---------------------------------------------------------------------------
void view_tri_interactor::OnRightButtonDown()
{
    vtkInteractorStyleTrackballCamera::OnMiddleButtonDown();
}
//---------------------------------------------------------------------------
void view_tri_interactor::OnRightButtonUp()
{
    vtkInteractorStyleTrackballCamera::OnMiddleButtonUp();
}
//---------------------------------------------------------------------------
void view_tri_interactor::OnMouseMove()
{
        vtkRenderWindowInteractor *rwi = this->Interactor;
        int X,Y;
        rwi->GetEventPosition(X,Y);
        if (n_ == 1)
        {
                float x2d[] = {static_cast<float>(X),static_cast<float>(Y),0.f};
                points_->SetPoint(1,x2d);
                renWin_->Render();
        }
        else
                vtkInteractorStyleTrackballCamera::OnMouseMove();
}
//---------------------------------------------------------------------------
void view_tri_interactor::OnChar()
{
        if (!initialised_) reset();
        vtkRenderWindowInteractor *rwi = this->GetInteractor();
        char c = rwi->GetKeyCode();
        vtkRendererCollection * col = rwi->GetRenderWindow()->GetRenderers();
        col->InitTraversal();
        vtkCamera * cam = col->GetNextItem()->GetActiveCamera();
        if (ren_==0)
        {
                vtkRendererCollection * col = rwi->GetRenderWindow()->GetRenderers();
                col->InitTraversal();
                ren_ = col->GetNextItem();
        }
        if ((c=='o')||(c=='O')) {}
        else if ((c=='p')||(c=='P'))
        {
                cam->ParallelProjectionOn();
                rwi->GetRenderWindow()->SetWindowName("view_tri (parallel)");
                rwi->GetRenderWindow()->Render();
        }
        else if ((c=='c')||(c=='C'))
        {
                cam->ParallelProjectionOff();
                rwi->GetRenderWindow()->SetWindowName("view_tri (central)");
                rwi->GetRenderWindow()->Render();
        }
        else if ((c=='i')||(c=='I'))
        {
                vtkActor *anActor = ren_->GetActors()->GetLastActor();
                if (bg_)
                {
                        ren_->SetBackground(1.,1.,1.);
                        if (black_wire_)
                        {
                                if (flat_||(anActor->GetProperty()->GetRepresentation()==VTK_WIREFRAME))
                                        anActor->GetProperty()->SetColor(0.,0.,0.);
                                anActor->SetBackfaceProperty(anActor->GetProperty());
                        }
                }
                else
                {
                        ren_->SetBackground(0.,0.,0.);
                        if (black_wire_)
                        {
                                anActor->GetProperty()->SetColor(1.,1.,1.);
                                anActor->SetBackfaceProperty(anActor->GetProperty());
                        }
                }
                bg_ = !bg_;
                rwi->GetRenderWindow()->Render();
        }
        else if ((c=='n')||(c=='N'))
        {
                static double dp0[] = {0.,0.,0.,0.};
                int X,Y;
                rwi->GetEventPosition(X,Y);
                float Z = ren_->GetZ(X,Y);
                if ((Z!=0)&&(Z!=1))
                {
                        ren_->SetDisplayPoint(X,Y,Z);
                        ren_->DisplayToWorld();
                        double * dp = ren_->GetWorldPoint();
                        if ((dp[0]==dp0[0])&&(dp[1]==dp0[1])&&(dp[2]==dp0[2])&&(dp[3]==dp0[3]))
                                std::cout << std::endl;
                        else
                        {
                                for (short i=0; i<3; i++) std::cout << dp[i]/dp[3] << " ";
                                std::cout << std::flush;
                        }
                        for (short i=0; i<4; i++) dp0[i] = dp[i];
                }
 
        }
        else if ((c=='e')||(c=='E'))
        {
                delete_mode_ = !delete_mode_;
                if (delete_mode_)
                {
                        std::cerr << "delete mode: on" << std::endl;
                        vtkDataArray * scalars = vtkShortArray::New();
                        scalars->SetNumberOfTuples(geometry_->GetNumberOfCells());
                        scalars->SetNumberOfComponents(1);
                        scalars->FillComponent(0,1);
                        geometry_->GetCellData()->SetScalars(scalars);
                        scalars->Delete();
                        //vtk6                          geometry_->Update();
                        vtkLookupTable * lut = vtkLookupTable::New();
                        lut->SetNumberOfTableValues(2);
                        lut->SetTableValue(0,.85,.08,.08,1.);
                        lut->SetTableValue(1,1.,1.,1.,1.);
                        vtkMapper * map = ren_->GetActors()->GetLastActor()->GetMapper();
                        map->SetScalarModeToUseCellData();
                        map->SetScalarRange(0.,1.);
                        map->ScalarVisibilityOn();
                        map->SetLookupTable(lut);
                        map->Update();
                        lut->Delete();
                        locator_->SetDataSet(geometry_);
                        locator_->BuildLocator();
                }
                else
                {
                        std::cerr << "delete mode: off" << std::endl;
                        vtkMapper * map = ren_->GetActors()->GetLastActor()->GetMapper();
                        map->SetScalarModeToUsePointData();
                        map->Update();
                }
                rwi->GetRenderWindow()->Render();
        }
        else if ((c=='m')||(c=='M'))
        {
                double po[3], fo[3];
                vtkCamera * cam = ren_->GetActiveCamera();
                cam->GetPosition(po);
                cam->GetFocalPoint(fo);
                vtkLightCollection * lights = ren_->GetLights();
                lights->InitTraversal();
                vtkLight * light = lights->GetNextItem();
                light->SetPosition(po);
                light->SetFocalPoint(fo);
                light->SetIntensity(1);
                ren_->LightFollowCameraOn();
                rwi->Render();
        }
        else if ((c=='b')||(c=='B'))
        {
                double po[3], fo[3];
                vtkCamera * cam = ren_->GetActiveCamera();
                cam->GetPosition(po);
                cam->GetFocalPoint(fo);
                vtkLightCollection * lights = ren_->GetLights();
                lights->InitTraversal();
                vtkLight * light = lights->GetNextItem();
                light->SetPosition(po);
                light->SetFocalPoint(fo);
                light->SetIntensity(1);
                ren_->LightFollowCameraOn();
                rwi->Render();
                ren_->LightFollowCameraOff();
        }
        else if ((c=='x')||(c=='X'))
        {
                double po[3], fo[3];
                vtkCamera * cam = ren_->GetActiveCamera();
                cam->GetPosition(po);
                cam->GetFocalPoint(fo);
                a_point p_po(po);
                a_point p_fo(fo);
                a_point dir(1.,0.,0.);
                if (c=='X')
                        dir.x(-1.);
                double dist = (p_fo-p_po).norm();
                a_point np_po = p_fo-dir*dist;
                cam->SetPosition(np_po.x(),np_po.y(),np_po.z());
                cam->SetViewUp(0.,0.,1.);
                rwi->Render();
        }
        else if ((c=='y')||(c=='Y'))
        {
                double po[3], fo[3];
                vtkCamera * cam = ren_->GetActiveCamera();
                cam->GetPosition(po);
                cam->GetFocalPoint(fo);
                a_point p_po(po);
                a_point p_fo(fo);
                a_point dir(0.,1.,0.);
                if (c=='Y')
                        dir.y(-1.);
                double dist = (p_fo-p_po).norm();
                a_point np_po = p_fo-dir*dist;
                cam->SetPosition(np_po.x(),np_po.y(),np_po.z());
                cam->SetViewUp(0.,0.,1.);
                rwi->Render();
        }
        else if ((c=='z')||(c=='Z'))
        {
                double po[3], fo[3];
                vtkCamera * cam = ren_->GetActiveCamera();
                cam->GetPosition(po);
                cam->GetFocalPoint(fo);
                a_point p_po(po);
                a_point p_fo(fo);
                a_point dir(0.,0.,1.);
                if (c=='Z')
                        dir.z(-1.);
                double dist = (p_fo-p_po).norm();
                a_point np_po = p_fo-dir*dist;
                cam->SetPosition(np_po.x(),np_po.y(),np_po.z());
                cam->SetViewUp(1.,0.,0.);
                rwi->Render();
        }
        else if ((c=='w')||(c=='W'))
        {
                vtkActor *anActor = ren_->GetActors()->GetLastActor();
                anActor->GetProperty()->SetRepresentationToWireframe();
                if (!flat_ && black_wire_ && ren_->GetBackground()[0]==1.)
                        anActor->GetProperty()->SetColor(0.,0.,0.);
                anActor->GetProperty()->LightingOff();
                anActor->SetBackfaceProperty(anActor->GetProperty());
                rwi->Render();
        }
        else if ((c=='s')||(c=='S'))
        {
                vtkActor *anActor = ren_->GetActors()->GetLastActor();
                anActor->GetProperty()->SetRepresentationToSurface();
                if (!flat_ && black_wire_)
                        anActor->GetProperty()->SetColor(1.,1.,1.);
                anActor->GetProperty()->LightingOn();
                anActor->GetMapper()->ScalarVisibilityOn();
                rwi->Render();
        }
        else if ((c=='v')||(c=='V'))
        {
                vtkVRMLExporter * writer = vtkVRMLExporter::New();
                writer->SetFileName("view_tri.wrl");
                writer->SetInput(rwi->GetRenderWindow());
                writer->Write();
                writer->Delete();
        }
        else if ((c=='j')||(c=='J'))
        {
                vtkRenderLargeImage * large = vtkRenderLargeImage::New();
                large->SetInput(ren_);
                large->SetMagnification(magnification_);
                vtkJPEGWriter * writer = vtkJPEGWriter::New();
                writer->SetFileName("view_tri.jpg");
                writer->SetInputConnection(large->GetOutputPort());
                //writer->SetInput(grab->GetOutput());
                writer->SetQuality(100);//between 0 and 100
                large->Delete();
                writer->Write();
                writer->Delete();
        }
        else if ((c=='t')||(c=='T'))
        {
                vtkRenderLargeImage * large = vtkRenderLargeImage::New();
                large->SetInput(ren_);
                large->SetMagnification(magnification_);
                vtkTIFFWriter * writer = vtkTIFFWriter::New();
                writer->SetFileName("view_tri.tif");
                writer->SetInputConnection(large->GetOutputPort());
                large->Delete();
                writer->Write();
                writer->Delete();
        }
        else if (c=='r')
  {
    double r = cam->GetRoll();
    std::cout << r << std::endl;
  }
        else if (c=='R')
        {
                vtkRIBExporter * rib = vtkRIBExporter::New();
                rib->SetInput(rwi->GetRenderWindow());
                rib->SetFilePrefix("view_tri");
                rib->Write();
                rib->Delete();
        }
        else if ((c=='f')||(c=='F'))
        {
                double po[3], fo[3];
                vtkCamera * cam = ren_->GetActiveCamera();
                cam->GetPosition(po);
                cam->GetFocalPoint(fo);
                std::cout << po[0] << " " << po[1] << " " << po[2] << " ";
                std::cout << fo[0] << " " << fo[1] << " " << fo[2] << std::endl;
        }
        else if ((c=='q')||(c=='Q'))
        {
                //std::cout << "exit triangles" << std::endl;
                vtkInteractorStyleTrackballCamera::OnChar();
        }
        else if ((c!='r')&&(c!='R'))
                vtkInteractorStyleTrackballCamera::OnChar();
}
//----------------------------------------------------------------------------
void view_tri_interactor::PrintSelf(ostream& os, vtkIndent indent)
{
        this->Superclass::PrintSelf(os,indent);
        os << indent << "P.Smars" << "\n";
}