a_subpixel_interactor.h

Go to the documentation of this file.

/*
         Copyright 2010-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/>.
         */
#ifndef _A_SUBPIXEL_INTERACTOR_H_
#define _A_SUBPIXEL_INTERACTOR_H_
 
#include "pixelpos_points.h"
 
#include "vtkInteractorStyleTrackballCamera.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkRendererCollection.h"
#include "vtkRenderer.h"
#include "vtkPolyDataMapper2D.h"
#include "vtkObjectFactory.h"
#include "vtkCellPicker.h"
#include "vtkPoints.h"
#include "vtkImageReader2.h"
#include "vtkImageClip.h"
#include "vtkImageData.h"
#include "vtkPointData.h"
#include "vtkTransform.h"
#include "vtkImageShiftScale.h"
#include <iostream>
#include <iomanip>
#include <vector>
 
class VTKINTERACTIONSTYLE_EXPORT a_subpixel_interactor : public vtkInteractorStyleTrackballCamera
                                                                                                                                                                                                                                 //class VTK_RENDERING_EXPORT a_subpixel_interactor : public vtkInteractorStyleTrackballCamera
{
        public:
                static a_subpixel_interactor *New();
                vtkTypeMacro(a_subpixel_interactor,vtkInteractorStyleTrackballCamera);
 
                a_subpixel_interactor();
                void set(vtkPoints * points, vtkImageClip * clip, int maxu, int maxv) 
                {
                        points_ = points; clip_ = clip;
                        maxu_ = maxu; maxv_ = maxv;
                }
                void setpos(pixelpos_points * pos) {pos_ = pos;}
                void setscale(vtkImageShiftScale * scale, double scale0) {scale_ = scale; scale0_ = scale0;}
                virtual ~a_subpixel_interactor() {/*this->InteractionPicker->Delete();*/}
                void SetImage(vtkImageReader2 * image) {image_ = image;}
                virtual void OnLeftButtonDown() override;
                virtual void OnLeftButtonUp() override;
                virtual void OnRightButtonDown() override;
                virtual void OnRightButtonUp() override;
                virtual void OnChar() override;
        protected:
                pixelpos_points *       pos_;
                vtkRenderer *           ren_;
                vtkImageReader2 *       image_;
                bool                    initialised_;
                bool                    started_;
                bool                    window_started_;
                bool                    change_pos_;
                bool                    selection_;
                vtkImageClip *          clip_;
                vtkPoints *             points_;
                vtkImageShiftScale *    scale_;
                double                  scale0_;
                int                     maxu_;
                int                     maxv_;
                int                     fxmin_;
                int                     fymin_;
                void reset();
                void resetlight();
                void clipmove(int u, int v);
};
//------------------------------------------------------------------------------
a_subpixel_interactor* a_subpixel_interactor::New()
{
        // First try to create the object from the vtkObjectFactory
        vtkObject* ret = vtkObjectFactory::CreateInstance("a_subpixel_interactor");
        if(ret)
                return (a_subpixel_interactor*)ret;
        // If the factory was unable to create the object, then create it here.
        return new a_subpixel_interactor;
}
//---------------------------------------------------------------------------
void a_subpixel_interactor::reset()
{
        vtkRenderWindow * renWin = this->GetInteractor()->GetRenderWindow();
        vtkRendererCollection * rens = renWin->GetRenderers();
        rens->InitTraversal();
        ren_ = rens->GetNextItem();
        initialised_ = true;
}
//---------------------------------------------------------------------------
a_subpixel_interactor::a_subpixel_interactor()
{
        initialised_ = false;
        started_ = false;
        window_started_ = false;
        change_pos_ = false;
        fxmin_ = -1;
}
//---------------------------------------------------------------------------
void a_subpixel_interactor::OnLeftButtonDown()
{
        vtkRenderWindowInteractor *rwi = this->Interactor;
        int ctrl = rwi->GetControlKey();
        int shift = rwi->GetShiftKey();
        if ((ctrl == 0 )&&(shift == 0))
        {
                started_ = true;
                change_pos_ = false;
        }
        else if ((ctrl == 1)&&(shift == 1))
        {
                started_ = true;
                change_pos_ = true;
        }
        else
                vtkInteractorStyleTrackballCamera::OnLeftButtonDown();
}
//---------------------------------------------------------------------------
void a_subpixel_interactor::OnLeftButtonUp()
{
        if (started_)
        {
                vtkRenderWindowInteractor *rwi = this->Interactor;
                int X,Y;
                rwi->GetEventPosition(X,Y);
                started_ = false;
                if (!initialised_) reset();
                float Z = ren_->GetZ(X,Y);
                if ((Z!=0)&&(Z!=1)) //point on the image
                {
                        ren_->SetDisplayPoint(X,Y,Z);
                        ren_->DisplayToWorld();
                        double * dp = ren_->GetWorldPoint();
                        for (int k = 0; k < 3; k++)     dp[k] /= dp[3];
                        if (change_pos_)
                                this->clipmove(int(dp[0]),int(dp[1]));
                        else
                                pos_->add_or_moa_point(dp[0],dp[1]);
                }
        }
        else
                vtkInteractorStyleTrackballCamera::OnLeftButtonUp();
}
//---------------------------------------------------------------------------
void a_subpixel_interactor::OnRightButtonDown()
{
        vtkRenderWindowInteractor *rwi = this->Interactor;
        int ctrl = rwi->GetControlKey();
        int shift = rwi->GetShiftKey();
        if ((ctrl == 0)&&(shift == 0))
                selection_ = true;
        if ((ctrl > 1)&&(shift < 1))
                window_started_ = true;
        else
                vtkInteractorStyleTrackballCamera::OnRightButtonDown();
}
//---------------------------------------------------------------------------
void a_subpixel_interactor::OnRightButtonUp()
{
        if (selection_)
        {
                vtkRenderWindowInteractor *rwi = this->Interactor;
                int X,Y;
                rwi->GetEventPosition(X,Y);
                if (!initialised_) reset();
                float Z = ren_->GetZ(X,Y);
                if ((Z!=0)&&(Z!=1)) //point on the image
                {
                        ren_->SetDisplayPoint(X,Y,Z);
                        ren_->DisplayToWorld();
                        double * dp = ren_->GetWorldPoint();
                        for (int k = 0; k < 3; k++)     dp[k] /= dp[3];
                        pos_->select_point(dp[0],dp[1]);
                }
                selection_ = false;
        }
        if (window_started_)
        {
                vtkRenderWindowInteractor *rwi = this->Interactor;
                int X,Y;
                rwi->GetEventPosition(X,Y);
                window_started_ = false;
                if (!initialised_) reset();
                float Z = ren_->GetZ(X,Y);
                if ((Z!=0)&&(Z!=1)) //point on the image
                {
                        ren_->SetDisplayPoint(X,Y,Z);
                        ren_->DisplayToWorld();
                        double * dp = ren_->GetWorldPoint();
                        for (int k = 0; k < 3; k++)     dp[k] /= dp[3];
                        int u = int(dp[0]+.5);
                        int v = int(dp[1]+.5);
                        if (fxmin_==-1)
                        {
                                fxmin_ = u;
                                fymin_ = v;
                        }
                        else
                        {
                                int fxmax, fymax;
                                if (u<fxmin_)
                                {
                                        fxmax = fxmin_;
                                        fxmin_ = u;
                                }
                                else
                                        fxmax = u;
                                if (v<fymin_)
                                {
                                        fymax = fymin_;
                                        fymin_ = v;
                                }
                                else
                                        fymax = v;
                                vtkDataArray * scal = image_->GetOutput()->GetPointData()->GetScalars();
                                int extent[6];
                                image_->GetOutput()->GetExtent(extent);
                                int maxx = extent[1]-extent[0]+1;
                                double xmoy = 0;
                                double ymoy = 0;
                                double p = 0;
                                for (int y = fymin_; y <= fymax; y++) 
                                {
                                        for (int x = fxmin_; x <= fxmax; x++) 
                                        {
                                                double val[3];
                                                scal->GetTuple(x+y*maxx,val);
                                                double val2 = 255.-(val[0]+val[0]+val[0])/3.;
                                                p += val2;
                                                xmoy += x*val2;
                                                ymoy += y*val2;
                                        }
                                }
                                xmoy /= p;
                                ymoy /= p;
                                pos_->add_or_moa_point(xmoy,ymoy);
                                fxmin_ = -1;
                        }
                }
        }
        else
                vtkInteractorStyleTrackballCamera::OnRightButtonUp();
}
//---------------------------------------------------------------------------
void a_subpixel_interactor::OnChar()
{
        vtkRenderWindowInteractor *rwi = this->GetInteractor();
        char c = rwi->GetKeyCode();
        if ((c=='e')||(c=='E'))
                pos_->erase_selected_point();
        else if ((c=='x')||(c=='X'))
                pos_->export_selected_point();
        else if (c=='0')
                this->resetlight();
        else if (c=='2')
        {
                double scale = scale_->GetScale();
                if (scale < scale0_*10)
                {
                        scale_->SetScale(scale*1.05);
                        if (!initialised_) reset();
                        ren_->GetRenderWindow()->Render();
                }
        }
        else if (c=='1')
        {
                double scale = scale_->GetScale();
                if (scale > scale0_/10)
                {
                        scale_->SetScale(scale/1.05);
                        if (!initialised_) reset();
                        ren_->GetRenderWindow()->Render();
                }
        }
        else if (c=='5')
        {
                double shift = scale_->GetShift();
                if (shift <  256./scale0_)
                {
                        scale_->SetShift(shift+10./scale0_);
                        if (!initialised_) reset();
                        ren_->GetRenderWindow()->Render();
                }
        }
        else if (c=='4')
        {
                double shift = scale_->GetShift();
                if (shift > -256./scale0_)
                {
                        scale_->SetShift(shift-10./scale0_);
                        if (!initialised_) reset();
                        ren_->GetRenderWindow()->Render();
                }
        }
 
        //      else if ((c!='o')&&(c!='q')&&(c!='O')&&(c!='Q')&&(c!='r')&&(c!='R'))
        else if ((c!='o')&&(c!='O')&&(c!='r')&&(c!='R')&&(c!='f')&&(c!='F'))
                vtkInteractorStyleTrackballCamera::OnChar();
}
//---------------------------------------------------------------------------
void a_subpixel_interactor::resetlight()
{
        scale_->SetShift(0.);
        scale_->SetScale(scale0_);
        ren_->GetRenderWindow()->Render();
}
//---------------------------------------------------------------------------
void a_subpixel_interactor::clipmove(int u, int v)
{
        int ext[6];
        clip_->GetOutputWholeExtent(ext);
        clip_->Modified();
        int dimu = (int)((ext[1]-ext[0]+1.)/2.);
        int dimv = (int)((ext[3]-ext[2]+1.)/2.);
        if (u<dimu) u = dimu;
        if (v<dimv) v = dimv;
        if (u>maxu_-dimu) u = maxu_-dimu;
        if (v>maxv_-dimv) v = maxv_-dimv;
        int du = (int)(u-(ext[0]+ext[1]+1.)/2);
        int dv = (int)(v-(ext[2]+ext[3]+1.)/2);
        ext[0] += du;
        ext[1] += du;
        ext[2] += dv;
        ext[3] += dv;
        clip_->SetOutputWholeExtent(ext);
        float x[4][3]={{static_cast<float>(ext[0]),static_cast<float>(ext[2]),0.f}, 
                {static_cast<float>(ext[1]),static_cast<float>(ext[2]),0.f}, 
                {static_cast<float>(ext[1]),static_cast<float>(ext[3]),0.f}, 
                {static_cast<float>(ext[0]),static_cast<float>(ext[3]),0.f}};
        for (int i=0; i<4; i++) points_->SetPoint(i,x[i]);
        points_->Modified();
        ren_->GetRenderWindow()->Render();
}
 
#endif