CutModelManager.cxx

Go to the documentation of this file.

/*=========================================================================

Program:   wxMaracas
Module:    $RCSfile: CutModelManager.cxx,v $
Language:  C++
Date:      $Date: 2010/03/04 15:09:57 $
Version:   $Revision: 1.8 $

Copyright: (c) 2002, 2003
License:

This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#include "CutModelManager.h"

//Machete
#include "CutModelMainPanel.h"

CutModelManager::CutModelManager(std::string path){
        _path = path;
        _img = NULL;
        _img2 = NULL;
        _interactor = NULL;     
        _render = NULL;
        _currentaction=0;

}
CutModelManager::~CutModelManager(){
        std::string files = _path;
        files+="/infounrd_0_fig_0.info";        
        remove(files.c_str());  
        _vectordata.clear();
        _img = NULL;
        _img2 = NULL;
        _interactor = NULL;     
        _render = NULL;
}


vtkImageData* CutModelManager::getImageData(){
        return _img2;
}

void CutModelManager::setImageData(vtkImageData* img){
        int type = CutModelMainPanel::getInstance()->GetType();
        if( type == 0)
        {
                _img = img;

                if(_img2!=NULL){
                        _img2->Delete();
                }
                _img2 = vtkImageData::New();
                _img2->SetExtent(_img->GetExtent());
                _img2->SetSpacing(_img->GetSpacing());
                _img2->AllocateScalars();

                _img2->DeepCopy(_img);
        }
        else
        {
                _img2 = img;

                if(_img!=NULL){
                        _img->Delete();
                }
                _img = vtkImageData::New();
                _img->SetExtent(_img2->GetExtent());
                _img->SetSpacing(_img2->GetSpacing());
                _img->AllocateScalars();

                _img->DeepCopy(_img2);
        }
}

void CutModelManager::setInteractor(vtkRenderWindowInteractor* interactor){
        _interactor = interactor;
}

void CutModelManager::setRenderer(vtkRenderer* renderer){
        _render = renderer;
}

void CutModelManager::onAddCutModel(int id, vtkCommand* observer) throw( CutModelException){
        checkInvariant();


        CutModelData* data = new CutModelData(id,_interactor, observer, _img);
        _vectordata.push_back(data);

        _render->AddActor(data->getActor());

        //_render->UpdateCamera();
        _render->Render();
}

void CutModelManager::checkInvariant() throw( CutModelException){
        if(_img==NULL){
                throw CutModelException("The image is not set");
        }
        if(_img2==NULL){
                throw CutModelException("The image is not set");
        }
        if(_interactor==NULL){
                throw CutModelException("Interactor not set");
        }
        if(_render==NULL){
                throw CutModelException("Render not set");
        }
}

double* CutModelManager::getImageRange()throw( CutModelException){
        checkInvariant();
        return _img->GetScalarRange();
}

void CutModelManager::changeOpacity(int id,int opacity)throw( CutModelException){
        checkInvariant();
        CutModelData* current = getCutModelData(id);
        current->changeOpacity(opacity);
}

void CutModelManager::ShowViewBox(int id,bool check)throw( CutModelException){
        checkInvariant();
        CutModelData* current = getCutModelData(id);
        current->ShowViewBox(check);
}

void CutModelManager::ChangeShape(int id,int selection)throw( CutModelException){
        checkInvariant();
        CutModelData* current = getCutModelData(id);
        current->ChangeShape(selection);                        
        _render->Render();
}

CutModelData* CutModelManager::getCutModelData(int id)throw( CutModelException){

        CutModelData* current = NULL;
        for(int i= 0; i < _vectordata.size();i++){
                CutModelData* temp = _vectordata[i];
                std::cout<<"id in CutModelManager:: "<<id<<std::endl;
                std::cout<<"vectordataid in CutModelManager:: "<<temp->getId()<<std::endl;

                if(temp->getId() == id){
                        current =  temp;
                }
        }
        if(current ==NULL){

                throw CutModelException("Data not found");
        }
        return current;
}

void CutModelManager::updateActorDirection(int id)throw( CutModelException){
        checkInvariant();
        CutModelData* current = getCutModelData(id);
        current->udapteActorDirection();

}

void CutModelManager::changeColor(int id,double r,double g,double b)throw( CutModelException){

        checkInvariant();
        CutModelData* current = getCutModelData(id);
        current->changeColor(r,g,b);
        _render->Render();
}
void CutModelManager::RemoveActor(int id)throw( CutModelException){

        checkInvariant();

        CutModelData* current = getCutModelData(id);
        for(int i = 0; i < _vectordata.size()-1;i++){
                if(_vectordata[i]->getId()==id){                                
                        for(int j = i; j < _vectordata.size()-1;j++){
                                _vectordata[j]=_vectordata[j+1];
                        }
                        i = _vectordata.size();
                }
        }
        _render->RemoveViewProp(current->getActor());           
        //_render->RemoveViewProp(current->get
        delete current;
        _vectordata.pop_back();
        _render->Render();

}

void CutModelManager::ExecuteCut(int id, double* range, bool isinside)throw( CutModelException){
        checkInvariant();

        CutModelData* current = getCutModelData(id);
        current->ExecuteCut(range, isinside,_img2);


        /*
        Setting extra information for the undo
        */
        CutModelSaveBinInfo* undoaction = this->AddActionUndo(id, CUTMODEL_CUT);
        undoaction->setRange(range);
        undoaction->setIsInside(isinside);

}

vtkImageData* CutModelManager::GetResultImage(){
        checkInvariant();
        return _img2;
}

void CutModelManager::RefreshActor(int id){
        checkInvariant();
        CutModelData* current = getCutModelData(id);    
        _render->RemoveActor(current->getActor());
        _render->AddActor(current->getActor()); 
        current->RefreshViewBox();
        _render->Render();
}

void CutModelManager::SaveCutModelData(std::string filename)throw( CutModelException){  


        throw CutModelException("not implemented");




}



void CutModelManager::LoadCutModelData(std::string filename)throw( CutModelException){

        throw CutModelException("not implemented");

}

CutModelSaveBinInfo* CutModelManager::AddActionUndo(int idc, UNDOTYPE type)throw( CutModelException){

        for(int i = _undoredo.size()-1; i > _currentaction;i--){
                delete _undoredo[i];
                _undoredo.pop_back();           
        }

        CutModelSaveBinInfo* cutmodel = new CutModelSaveBinInfo(idc, _currentaction, type, _path);
        if(type == CUTMODEL_CUT){
                cutmodel->saveMatrix4x4(this->getCutModelData(idc)->getCurrentMatrix()->GetMatrix());
                cutmodel->setCurrentShape(this->getCutModelData(idc)->getCurrentShape());
        }

        _undoredo.push_back(cutmodel);

        _currentaction++;// = _undoredo.size();
        //std::cout<<"current index "<<_currentaction;

        return cutmodel;
}

int CutModelManager::Undo()     throw( CutModelException){
        //&& _currentaction < _undoredo.size()
        if(_currentaction > 0){
                int tempaction = _currentaction-1;
                CutModelSaveBinInfo* currentundo = _undoredo[tempaction];
                CutModelData* currentmodel;

                if(currentundo->getActionType()==CUTMODEL_CUT){
                        //Undo the cut
                        vtkTransform* transform = currentundo->getTransformFromMatrixFile();

                        currentmodel = getCutModelData(currentundo->getId());

                        currentmodel->setTransform(transform, _img2);

                        currentmodel->setCurrentShape(currentundo->getCurrentShape());

                        currentmodel->ExecuteUnCut(currentundo->getIsInside(), _img, _img2);

                }
                //Every thing ok
                _currentaction--;
                return 0;
        }
        return -1;
}

int CutModelManager::Redo()     throw( CutModelException){

        if(_currentaction >= 0 && _currentaction < _undoredo.size()){

                CutModelSaveBinInfo* currentundo = _undoredo[_currentaction];
                CutModelData* currentmodel;

                if(currentundo->getActionType()==CUTMODEL_CUT){
                        //Redo the cut
                        vtkTransform* transform = currentundo->getTransformFromMatrixFile();
                        currentmodel = getCutModelData(currentundo->getId());
                        currentmodel->setTransform(transform, _img2);
                        currentmodel->setCurrentShape(currentundo->getCurrentShape());
                        currentmodel->ExecuteCut(currentundo->getRange(), currentundo->getIsInside(), _img2);
                }

                _currentaction++;

                return 0;
        }
        return -1;
}

void CutModelManager::ParallelProjectionOn(){
        _render->GetActiveCamera()->ParallelProjectionOn();
}

void CutModelManager::ParallelProjectionOff(){
        _render->GetActiveCamera()->ParallelProjectionOff();
}


//RaC
void CutModelManager::UpdatePolygon(bool mode)
{
        if(mode)
        {
                cutterstyle->Delete();
                cutterstyle = vtkInteractorStyleCutter::New();

                cutterstyle->SetInteractor ( _interactor );
                _interactor ->SetInteractorStyle( cutterstyle );
        }
        else
        {
                cutterstyle->VisibilityOff();

                loop = vtkImplicitSelectionLoop::New();
                mapper = vtkPolyDataMapper::New();
                if(cutterstyle->Finished())
                {
                        if(actor3D != NULL)
                        {
                                _render->RemoveActor(actor3D);
                        }

                        loop->SetLoop( cutterstyle->GetLoopPoints() );
                        loop->SetNormal( cutterstyle->GetDirection());


                        int numPoints = cutterstyle->GetLoopPoints()->GetNumberOfPoints();
                        contourDirection = cutterstyle->GetDirection();

                        contourPoints = cutterstyle->GetLoopPoints();

                        _polygonCutter = new CutModelPolygon();

                        cout<<"RaC ContourDrawer::Update Printing points"<<endl;
                        for(int t=0;t<numPoints;t++)
                        {
                                double point[3];
                                cutterstyle->GetLoopPoints()->GetPoint(t,point);
                                cout<<"Initial Point:"<<t<<" XX:"<<point[0]<<" YY:"<<point[1]<<" ZZ:"<<point[2]<<endl;
                        }
                        cout<<endl;

                        sample = vtkSampleFunction::New();

                        sample->SetImplicitFunction(loop);
                        sample->CappingOn();                    

                        contour = vtkContourFilter::New();
                        contour->SetInput((vtkDataObject *)sample->GetOutput());
                        contour->SetValue(0,1);

                        actor = contour->GetOutput();

                        actor3D = vtkActor::New();                      
                        mapper->SetInput(actor);                         
                        mapper->SetScalarModeToUseCellData();
                        actor3D->SetMapper( mapper);
                        _render->AddActor(actor3D);                     
                }               

                interactorstyle->SetInteractor (  _interactor );
                _interactor->SetInteractorStyle( interactorstyle );
        } 

        _interactor->Render();
        _render->ResetCameraClippingRange();
}
void CutModelManager::ExecuteCutPolygon(bool inOutCut){

        _polygonCutter->setInImage(_img2);
        _polygonCutter->setPoints(contourPoints);
        _polygonCutter->setDirection(contourDirection);
        _polygonCutter->processOutImage(inOutCut);
}

void CutModelManager::InitializePolygonInteractorStyle(){

        cutterstyle = vtkInteractorStyleCutter::New();          
        interactorstyle = vtkInteractorStyleTrackballCamera ::New();
        interactorstyle->SetInteractor (  _interactor );
        _interactor->SetInteractorStyle( interactorstyle );
}