pixelpos_points.cxx

Go to the documentation of this file.

/*
         Copyright 2002-2019 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 "pixelpos_points.h"
 
#include "vtkTransform.h"
#include "vtkDiskSource.h"
#include "vtkTransformPolyDataFilter.h"
#include "vtkPolyDataMapper.h"
#include "vtkActor.h"
#include "vtkProperty.h"
#include "vtkRenderWindow.h"
 
//---------------------------------------------------------------------------
pixelpos_points::~pixelpos_points()
{
        ref_.clear();
        pos_.clear();
}
//---------------------------------------------------------------------------
void pixelpos_points::add_point(int ref, double u, double v)
{
        if (selected_ != -1)
                ((vtkActor*)(ren_->GetActors()->GetItemAsObject(selected_)))->GetProperty()->SetColor(.8,.8,.8);
        selected_ = ren_->GetActors()->GetNumberOfItems();
        if (ref==0) 
        {
                for (auto r:ref_)
                {
                        if (ref<r) ref=r;
                }
                ref++;
        }
        if (verbose_)
                std::cerr << ref << " " << u << " " << v << std::endl;
        ref_.push_back(ref);
        vtkTransform * trans = vtkTransform::New();
        trans->Translate(u,v,0.1);
        pos_.push_back(trans);
        vtkDiskSource * disk = vtkDiskSource::New();
        disk->SetCircumferentialResolution(20);
        disk->SetRadialResolution(3);
        disk->SetOuterRadius(3.);
        disk->SetInnerRadius(2.);
        vtkTransformPolyDataFilter * move = vtkTransformPolyDataFilter::New();
        move->SetInputConnection(disk->GetOutputPort());
        disk->Delete();
        move->SetTransform(trans);
        vtkPolyDataMapper * map = vtkPolyDataMapper::New();
        map->SetInputConnection(move->GetOutputPort());
        move->Delete();
        vtkActor * actor = vtkActor::New();
        actor->SetMapper(map);
        map->Delete();
        actor->GetProperty()->SetColor(1.,0.,0.);
        actor->GetProperty()->SetOpacity(.6);
        actor->DragableOn();
        ren_->AddActor(actor);
        actor->Delete();
}
//---------------------------------------------------------------------------
void pixelpos_points::erase_last_point()
{
        if (ref_.size()>0)
        {
                ref_.erase(ref_.end()-1);
                vtkActor * actor = ren_->GetActors()->GetLastActor();
                ren_->RemoveActor(actor);
                pos_.erase(pos_.end()-1);
                ren_->GetRenderWindow()->Render();
        }
}
//---------------------------------------------------------------------------
void pixelpos_points::erase_selected_point()
{
        if (selected_ != -1)
        {
                ref_.erase(ref_.begin()+selected_-2);
                vtkActor * actor = (vtkActor*)(ren_->GetActors()->GetItemAsObject(selected_));
                ren_->RemoveActor(actor);
                pos_.erase(pos_.begin()+selected_-2);
                ren_->GetRenderWindow()->Render();
                selected_ = ren_->GetActors()->GetNumberOfItems()-2;
                if (selected_>0)
                {
                        vtkActor * act = (vtkActor*)(ren_->GetActors()->GetItemAsObject(selected_));
                        act->GetProperty()->SetColor(1.,0.,0.);
                        ren_->GetRenderWindow()->Render();
                } else
                        selected_ = -1;
        }
}
//---------------------------------------------------------------------------
void pixelpos_points::moa_point(int ref, double u, double v)
{
        std::cerr << ref_[ref] << " " << u << " " << v << std::endl;
        double p1[3];
        pos_[ref]->GetPosition(p1);
        pos_[ref]->Translate(u-p1[0], v-p1[1], 0);
        pos_[ref]->Modified();
}
//---------------------------------------------------------------------------
int pixelpos_points::pick_point(double u, double v)
{
        int ref;
        int n = ref_.size();
        double dmin = 1.e30;
        for (int i=0; i<n; i++)
        {
                double p[3];
                pos_[i]->GetPosition(p);
                double d = sqrt((p[0]-u)*(p[0]-u)+(p[1]-v)*(p[1]-v));
                if (d<dmin)
                {
                        dmin = d;
                        ref = i;
                }
        }
        if (dmin <= 3)
                return ref;
        else
                return -1;
}
//---------------------------------------------------------------------------
int pixelpos_points::select_point(double u, double v)
{
        int ref = this->pick_point(u,v);
        if (ref != -1)
        {
                vtkActor * act;
                act = (vtkActor*)(ren_->GetActors()->GetItemAsObject(selected_));
                act->GetProperty()->SetColor(.8,.8,.8);
                selected_ = ref+2;
                act = (vtkActor*)(ren_->GetActors()->GetItemAsObject(selected_));
                act->GetProperty()->SetColor(1.,0.,0.);
        }
        return ref;
}
//---------------------------------------------------------------------------
void pixelpos_points::add_or_moa_point(double u, double v)
{
        int ref = this->pick_point(u,v);
        if (ref == -1)
                this->add_point(0,u,v);
        else
                this->moa_point(ref,u,v);
        ren_->GetRenderWindow()->Render();
}
//---------------------------------------------------------------------------
void pixelpos_points::export_selected_point()
{
        double p[3];
        pos_[selected_-2]->GetPosition(p);
        std::cout << ref_[selected_-2] << "\t" << p[0] << "\t" << p[1] << std::endl;
}
//---------------------------------------------------------------------------
std::istream& operator>> (std::istream& in, pixelpos_points& l)
{
        int n;
        in >> n;
        if (n>0)
                std::cerr << "importing " << n << " points" << std::endl;
        for (int i=0; i<n; i++)
        {
                int ref;
                double u,v;
                in >> ref >> u >> v;
                l.add_point(ref,u,v);
                std::cerr << ref << " " << u << " " << v << std::endl;
        }
        return in;
}
//---------------------------------------------------------------------------
std::ostream& operator<< (std::ostream& o, const pixelpos_points& l)
{
        o << l.ref_.size() << std::endl;
        for (int i=0; i<l.ref_.size(); i++)
        {
                double p[3];
                l.pos_[i]->GetPosition(p);
                o << l.ref_[i] << "\t" << p[0] << "\t" << p[1] << std::endl;
        }
        return o;
}