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

  Program:   wxMaracas
  Module:    $RCSfile: wxMaracasIRMViewManager.cxx,v $
  Language:  C++
  Date:      $Date: 2009/05/04 07:35:42 $
  Version:   $Revision: 1.4 $

  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 "wxMaracasIRMViewManager.h"

/**
**	Start of the manager class
**/
wxMaracasIRMViewManager::wxMaracasIRMViewManager(){
	_renderer = NULL;
	_idCount=0;
}
wxMaracasIRMViewManager::~wxMaracasIRMViewManager(){
}

/**
**	Sets the renderer to manage the prop3D from the view
**/
void wxMaracasIRMViewManager::setRenderer(vtkRenderer*  renderer){
	_renderer = renderer;
}
/**
**	Adds a prop3D to the manager and returns the identifier
**/
int wxMaracasIRMViewManager::addProp3D(vtkProp3D* prop3D, std::string dataname)  throw(char*){
	checkInvariant();
	if(prop3D != NULL){
		wxMaracasIRMViewManagerData* data = new wxMaracasIRMViewManagerData(prop3D, dataname);
		prop3Dvect.push_back(data);		
		_renderer->AddActor(data->getProp3D());
		data->setId(_idCount);
		_idCount++;
		return data->getId();
	}else{
		throw "Check vtkProp3D file or input";
	}
	return -1;
}
int wxMaracasIRMViewManager::addPropMHD(vtkImageData* imagedata, std::string dataname) throw(char*){

	checkInvariant();
	if(imagedata != NULL){
		wxMaracasIRMViewManagerData* data = new wxMaracasIRMViewManagerData(imagedata, dataname);
		prop3Dvect.push_back(data);		
		_renderer->AddActor(data->getProp3D());
		data->setId(_idCount);
		_idCount++;
		return data->getId();
	}else{
		throw "Check ImageData file or input";
	}
	return -1;

}
/**
**	adds or removes an actor depending of the bool value
**/
void wxMaracasIRMViewManager::addRemoveActor(int propid, bool addremove)  throw(char*){
	checkInvariant();
	
	wxMaracasIRMViewManagerData* data = this->getViewData(propid);		
	if(data->getProp3D()!=NULL){
		if(addremove){
			_renderer->AddViewProp(data->getProp3D());
		}else{
			_renderer->RemoveViewProp(data->getProp3D());
		}
		_renderer->Render();
	}
	
}
/**
**	Changes the opacity in a prop3D
**/
void wxMaracasIRMViewManager::changeOpacity(int propid, int value)  throw(char*){
	checkInvariant();	


	this->getViewData(propid)->changeOpacity(value);
	
	_renderer->Render();

}

/**
**	changes the isovalue in a prop3D
**/
void wxMaracasIRMViewManager::changeIsoValue(int propid, double value )throw(char*){
	checkInvariant();	

	wxMaracasIRMViewManagerData* data = this->getViewData(propid);		

	//_renderer->RemoveActor(data->getProp3D());
	data->changeIsoValue(value);
	//_renderer->AddActor(data->getProp3D());

	_renderer->Render();
}

vtkProp3D* wxMaracasIRMViewManager:: getProp3D(std::string filename){
	if(filename.compare("")!= 0){
		vtkSTLReader *STLReader=vtkSTLReader::New();
		STLReader->SetFileName(filename.c_str());
		STLReader->Update();
		vtkPolyDataMapper* dataMapper = vtkPolyDataMapper::New();
		dataMapper->SetInput(STLReader->GetOutput());
		
		vtkActor* dataActor = vtkActor::New();
		dataActor->SetMapper(dataMapper);	
		dataActor->GetProperty()->SetOpacity(1);
		
		return dataActor;
	}	
	return NULL;
}

vtkImageData* wxMaracasIRMViewManager::getImageData(std::string filename){
	if(filename.compare("")!= 0){	
		
		
		vtkMetaImageReader* reader =  vtkMetaImageReader::New();	
		reader->SetFileName(filename.c_str());
		reader->Update();
		vtkImageData* img = reader->GetOutput();
		//reader->Delete();
		return img;
	}	
	return NULL;
}

void wxMaracasIRMViewManager::checkInvariant()  throw(char*){
	if(this->_renderer==NULL){
		throw "Renderer not set";
	}
}

wxMaracasIRMViewManagerData* wxMaracasIRMViewManager::getViewData(int id) throw(char*){
    int i;
	for(i = 0; i < prop3Dvect.size();i++){
		if(prop3Dvect[i]->getId() == id){
			return prop3Dvect[i];
		}
	}
	throw "id not found in the data";

	return NULL;
}

int wxMaracasIRMViewManager::getMaxIsoValue(int propid) throw(char*){
	
	return this->getViewData(propid)->getMaxGreyLevel();

}

void wxMaracasIRMViewManager::changeColor(int propid, double red, double green, double blue) throw(char*){
	checkInvariant();	
	this->getViewData(propid)->changeColor(red, green, blue);

	_renderer->Render();
}

void wxMaracasIRMViewManager::deleteActor(int propid) throw (char *){
	checkInvariant();	

	this->addRemoveActor(propid, false);

	int i,n;
	bool exit = false;
	for(i = 0; i < prop3Dvect.size()&&!exit;i++){
		if(prop3Dvect[i]->getId() == propid){			
			n=i;
			exit = true;
		}
	}
	if(exit){
		wxMaracasIRMViewManagerData* data = prop3Dvect[n];			
		int j;
		for(j = i; j < prop3Dvect.size()-1;j++){
			prop3Dvect[j] = prop3Dvect[j+1];
		}		
		delete data;
		prop3Dvect.pop_back();
	}else{
		throw "id not found in the data";
	}

	
	
    
}

/********************************************************************************************
** Start of data viewmanagerData
*********************************************************************************************/

wxMaracasIRMViewManagerData::wxMaracasIRMViewManagerData(vtkProp3D* prop3Dvect, std::string dataname){

	_prop3D = prop3Dvect;	
	_dataname = dataname;
	_maxgreylevel=-1;

	_cubesFilter=NULL;
	_cleanFilter=NULL;	
	_dataMapper=NULL;
}
wxMaracasIRMViewManagerData::wxMaracasIRMViewManagerData(vtkImageData* imagedata, std::string dataname){

	this->setVtkImageData(imagedata);
	_dataname = dataname;
	
	_maxgreylevel = getMaxLevel(imagedata);
	_prop3D=NULL;			

	_cubesFilter = vtkMarchingCubes::New();
	_cleanFilter = vtkCleanPolyData::New();		
	_dataMapper = vtkPolyDataMapper::New();
	vtkActor* dataActor = vtkActor::New();
	
	_cubesFilter->SetInput(this->_imagedata);
	_cubesFilter->ComputeGradientsOn ();
	_cubesFilter->ComputeScalarsOn ();
	_cubesFilter->SetNumberOfContours( 1 );
	_cleanFilter->SetInput ( _cubesFilter->GetOutput() );
	_dataMapper->SetInput(_cleanFilter->GetOutput());
	_dataMapper->ScalarVisibilityOff();
	_dataMapper->ImmediateModeRenderingOn();
	dataActor->SetMapper(_dataMapper);	

	this->_prop3D = dataActor;

	this->changeIsoValue(this->_maxgreylevel);	


}
/**
**	changes the isovalue in a prop3D
**/
void wxMaracasIRMViewManagerData::changeIsoValue(double value){	
		
   
    _cubesFilter->SetValue(0,value);		
	_cubesFilter->Update();    
	_cleanFilter->Update();
	_dataMapper->Update();	
	
	
	
}
int wxMaracasIRMViewManagerData::getMaxGreyLevel(){
	return _maxgreylevel;
}
wxMaracasIRMViewManagerData::~wxMaracasIRMViewManagerData(){	
	if(_cubesFilter!=NULL){
		_cubesFilter->Delete();
		_cleanFilter->Delete();
		_dataMapper->Delete();
	}
	_prop3D->Delete();	
}
/**
**	Adds a prop3D to the world of the application
**/
/**
	** Get's the max grey level of the image
	**/
int wxMaracasIRMViewManagerData::getMaxLevel(vtkImageData* img){

	int ext[6], i, j, k,max=0;
	img->GetExtent(ext);

	for(i = ext[0]; i < ext[1];i++){
		for(j = ext[2]; j < ext[3];j++){
			for(k = ext[4]; k < ext[5];k++){
                unsigned short* ptr = (unsigned short*)img->GetScalarPointer(i,j,k);
				int temp = (int)*ptr;
				if(temp > max){
                    max = temp;
				}
			}
		}
	}
	return max;


}
void wxMaracasIRMViewManagerData::setVtkImageData(vtkImageData* imagedata){
	_imagedata = imagedata;
}
/**
**	Adds a prop3D to the world of the application
**/
void wxMaracasIRMViewManagerData::setProp3D(vtkProp3D* prop3D){
	_prop3D = prop3D;
}
/**
**	Changes the opacity in a prop3D
**/
void wxMaracasIRMViewManagerData::changeOpacity(int value){
	std::cout<<"chage op"<<value<<std::endl;
	vtkActor* actor = (vtkActor*)this->_prop3D;	
	actor->GetProperty()->SetOpacity((double)value/100.0);

	

}
void wxMaracasIRMViewManagerData::changeColor(double red, double green, double blue){
	std::cout<<"chage col"<<red<<green<<blue<<std::endl;
    vtkActor* actor = (vtkActor*)this->_prop3D;	
	actor->GetProperty()->SetColor(red,green,blue);	
}
/**
**	Check if the variables are setted correctly
**/
void wxMaracasIRMViewManagerData::checkInvariant(){

}
/**
**	get the prop3D 
**/
vtkProp3D* wxMaracasIRMViewManagerData::getProp3D(){
	return this->_prop3D;
}
/**
**	return the id from the daat
**/
int wxMaracasIRMViewManagerData::getId(){
	return _id;
}
/**
**	set data id
**/
void wxMaracasIRMViewManagerData::setId(int propid){
	_id = propid;
}

/**
**	Get the filanme
**/
std::string wxMaracasIRMViewManagerData::getDataname(){
	return _dataname;
}
/**
** Set the filanme
**/
void wxMaracasIRMViewManagerData::setDataname(std::string dataname){
	_dataname = dataname;
}