a_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 "a_interactor.h"
#include "vtkRenderWindow.h"
#include "vtkRendererCollection.h"
#include "vtkRenderer.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkObjectFactory.h"
#include "vtkCellPicker.h"
#include "vtkLight.h"
#include "vtkLightCollection.h"
#include "vtkMapper.h"
#include "vtkRenderLargeImage.h"
#include "vtkVRMLExporter.h"
#include "vtkTIFFWriter.h"
#include "vtkJPEGWriter.h"
#include "vtkCamera.h"
#include "vtkProperty.h"
 
#include "a_point.h"
 
#include <iostream>
#include <sstream>
#include <iomanip>
 
//vtkCxxRevisionMacro(a_interactor, "$Revision: 1.3 $");
 
//------------------------------------------------------------------------------
a_interactor* a_interactor::New()
{
        // First try to create the object from the vtkObjectFactory
        vtkObject* ret = vtkObjectFactory::CreateInstance("a_interactor");
        if(ret)
                return (a_interactor*)ret;
        // If the factory was unable to create the object, then create it here.
        return new a_interactor;
}
//---------------------------------------------------------------------------
a_interactor::a_interactor()
{
        bg_ = true;
        magnification_ = 1;
        name_ = "noname";
        keep_color_ = false;
        //      JoystickOrTrackball = VTKIS_TRACKBALL;
        //      CameraOrActor = VTKIS_CAMERA;
}
//---------------------------------------------------------------------------
void a_interactor::OnLeftButtonDown()
{
        vtkRenderWindowInteractor * rwi = this->Interactor;
        int ctrl = rwi->GetControlKey();
        int shift = rwi->GetShiftKey();
        vtkRendererCollection * col = rwi->GetRenderWindow()->GetRenderers();
        col->InitTraversal();
        vtkRenderer * ren = col->GetNextItem();
        vtkRenderWindow * renWin = this->GetInteractor()->GetRenderWindow();
        int X,Y;
        int * size = renWin->GetSize();
        rwi->GetEventPosition(X,Y);
        if ((ctrl >= 1)&&(shift >= 1))
        {
                //pick a point and return its coordinates
                float * Zbuffer = renWin->GetZbufferData(0,0,size[0]-1,size[1]-1);
                float Z = Zbuffer[X+Y*size[0]];
                if ((Z!=0)&&(Z!=1))
                {
                        //works only if point is perfectly picked 
                        ren->SetDisplayPoint(X,Y,Z);
                        ren->DisplayToWorld();
                        double * dp = ren->GetWorldPoint();
                        std::cout << dp[0]/dp[3] << " " << dp[1]/dp[3] << " " << dp[2]/dp[3] << std::endl;
                }
                else
                {
                        //look two pixels around
                        for (int i=-2; i<3; i++) {
                                for (int j=-2; j<3; j++) {
                                        Z = Zbuffer[X+i+(Y+j)*size[0]];
                                        if ((Z!=0)&&(Z!=1))
                                        {
                                                ren->SetDisplayPoint(X+i,Y+j,Z);
                                                ren->DisplayToWorld();
                                                double * dp = ren->GetWorldPoint();
                                                std::cout << dp[0]/dp[3] << " " << dp[1]/dp[3] << " " << dp[2]/dp[3] << std::endl;
                                                //std::cout << "( " << i << ", " << j << ")" << std::endl;
                                                return;
                                        }
                                }
                        }
                }
        } 
        else
                vtkInteractorStyleTrackballCamera::OnLeftButtonDown();
}
//---------------------------------------------------------------------------
void a_interactor::OnMiddleButtonDown()
{
                vtkInteractorStyleTrackballCamera::OnRightButtonDown();
}
//---------------------------------------------------------------------------
void a_interactor::OnMiddleButtonUp()
{
                vtkInteractorStyleTrackballCamera::OnRightButtonUp();
}
//---------------------------------------------------------------------------
void a_interactor::OnRightButtonDown()
{
                vtkInteractorStyleTrackballCamera::OnMiddleButtonDown();
}
//---------------------------------------------------------------------------
void a_interactor::OnRightButtonUp()
{
                vtkInteractorStyleTrackballCamera::OnMiddleButtonUp();
}
//---------------------------------------------------------------------------
void a_interactor::OnChar()
{
        vtkRenderWindowInteractor *rwi = this->Interactor;
        char c = rwi->GetKeyCode();
        int ctrl = rwi->GetControlKey();
        vtkRendererCollection * col = rwi->GetRenderWindow()->GetRenderers();
        col->InitTraversal();
        vtkRenderer * ren = col->GetNextItem();
        vtkCamera * cam = ren->GetActiveCamera();
        if ((c=='p')||(c=='P'))
        {
                cam->ParallelProjectionOn();
                std::string name = name_ + std::string(" (parallel)");
                rwi->GetRenderWindow()->SetWindowName(name.c_str());
                rwi->GetRenderWindow()->Render();
        }
        else if ((c=='i')||(c=='I'))
        {
                vtkActorCollection *ac;
                vtkActor *anActor;
                int X,Y;
                rwi->GetEventPosition(X,Y);
                this->FindPokedRenderer(X,Y);
                ac = this->CurrentRenderer->GetActors();
                if (bg_)
                {
                        ren->SetBackground(1.,1.,1.);
                        if (!keep_color_) 
                        {
                                for (ac->InitTraversal(); (anActor = ac->GetNextItem()); )
                                        anActor->GetProperty()->SetColor(0.,0.,0.);
                        }
                }
                else
                {
                        ren->SetBackground(0.,0.,0.);
                        if (!keep_color_) 
                        {
                                for (ac->InitTraversal(); (anActor = ac->GetNextItem()); )
                                        anActor->GetProperty()->SetColor(1.,1.,1.);
                        }
                }
                bg_ = !bg_;
                rwi->GetRenderWindow()->Render();
        }
        else if ((c=='c')||(c=='C'))
        {
                cam->ParallelProjectionOff();
                std::string name = name_ + std::string(" (central)");
                rwi->GetRenderWindow()->SetWindowName(name.c_str());
                rwi->GetRenderWindow()->Render();
        }
        else if ((c=='v')||(c=='V'))
        {
                std::string name = name_ + std::string(".wrl");
                vtkVRMLExporter * writer = vtkVRMLExporter::New();
                writer->SetFileName(name.c_str());
                writer->SetInput(rwi->GetRenderWindow());
                writer->Write();
                writer->Delete();
        }
        else if ((c=='j')||(c=='J'))
        {
                vtkRenderLargeImage * large = vtkRenderLargeImage::New();
                large->SetInput(ren);
                large->SetMagnification(magnification_);
                std::string name = name_ + std::string(".jpg");
                vtkJPEGWriter * writer = vtkJPEGWriter::New();
                writer->SetFileName(name.c_str());
                writer->SetInputConnection(large->GetOutputPort());
                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_);
                std::string name = name_ + std::string(".tif");
                vtkTIFFWriter * writer = vtkTIFFWriter::New();
                writer->SetFileName(name.c_str());
                writer->SetInputConnection(large->GetOutputPort());
                large->Delete();
                writer->Write();
                writer->Delete();
        }
        else if ((c=='m')||(c=='M'))
        {
                double po[3], fo[3];
                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];
                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=='w')||(c=='W'))
        {
                vtkActorCollection *ac;
                vtkActor *anActor, *aPart;
                int X,Y;
                rwi->GetEventPosition(X,Y);
                this->FindPokedRenderer(X,Y);
                ac = this->CurrentRenderer->GetActors();
                for (ac->InitTraversal(); (anActor = ac->GetNextItem()); )
                {
                        anActor->GetProperty()->SetRepresentationToWireframe();
                        anActor->GetProperty()->LightingOff();
                        anActor->SetBackfaceProperty(anActor->GetProperty());
                }
                rwi->Render();
        }
        else if ((c=='s')||(c=='S'))
        {
                vtkActorCollection *ac;
                vtkActor *anActor, *aPart;
                int X,Y;
                rwi->GetEventPosition(X,Y);
                this->FindPokedRenderer(X,Y);
                ac = this->CurrentRenderer->GetActors();
                for (ac->InitTraversal(); (anActor = ac->GetNextItem()); )
                {
                        anActor->GetProperty()->SetRepresentationToSurface();
                        anActor->GetProperty()->LightingOn();
                        anActor->GetMapper()->ScalarVisibilityOn();
                }
                rwi->Render();
        }
        else if ((c=='x')||(c=='X')) 
        {
                double po[3], fo[3];
                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];
                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];
                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=='o')||(c=='O')) 
        {
                double po[3], fo[3];
                cam->GetPosition(po);
                cam->GetFocalPoint(fo);
                a_point p_po(po);
                a_point p_fo(fo);
                a_point dir = (p_fo-p_po).normalise();
                bool moved = false;
                if (fabs(dir.x())<0.2) {dir.x(0.); moved=true;}
                if (fabs(dir.y())<0.2) {dir.y(0.); moved=true;}
                if (fabs(dir.z())<0.2) {dir.z(0.); moved=true;}
                if (moved)
                {
                        dir.normalise();
                        double dist = (p_fo-p_po).norm();
                        a_point np_fo = p_po+dir*dist;
                        std::cerr << "view direction: " << dir << std::endl;
                        cam->SetFocalPoint(np_fo.x(),np_fo.y(),np_fo.z());
                        rwi->Render();
                }
        }
        else if (c=='F')
        {
                double fo[3];
                cam->GetFocalPoint(fo);
                std::cout << fo[0] << " " << fo[1] << " " << fo[2] << std::endl;
        }
        else if (c=='r')
        {
                double r = cam->GetRoll();
                std::cout << r << std::endl;
        }
        else if (c=='f')
        {
                double po[3], fo[3];
                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!='r')&&(c!='R'))
                vtkInteractorStyleTrackballCamera::OnChar();
}
//----------------------------------------------------------------------------
void a_interactor::PrintSelf(ostream& os, vtkIndent indent)
{
        this->Superclass::PrintSelf(os,indent);
        os << indent << "P.Smars" << "\n";
}