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

  Program:   wxMaracas
  Module:    $RCSfile: wxMaracasIRMViewManager.cxx,v $
  Language:  C++
  Date:      $Date: 2009/04/09 13:58:38 $
  Version:   $Revision: 1.2 $

  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(...){
	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){

	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(...){
	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(...){
	checkInvariant();	


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

}

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

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

	_renderer->RemoveViewProp(data->getProp3D());
	data->changeIsoValue(value);
	_renderer->AddViewProp(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(...){
	if(this->_renderer==NULL){
		throw "Renderer not set";
	}
}

wxMaracasIRMViewManagerData* wxMaracasIRMViewManager::getViewData(int id) throw(...){
    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){
	
	return this->getViewData(propid)->getMaxGreyLevel();

}

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

}

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

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

	_prop3D = prop3Dvect;
	_dataname = dataname;
	_maxgreylevel=-1;
}
wxMaracasIRMViewManagerData::wxMaracasIRMViewManagerData(vtkImageData* imagedata, std::string dataname){

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

	this->changeIsoValue(this->_maxgreylevel);
}
/**
**	changes the isovalue in a prop3D
**/
void wxMaracasIRMViewManagerData::changeIsoValue(int value){	
	

	if(_prop3D!=NULL){
		_prop3D->Delete();
		_polydata->Delete();
		_dataMapper->Delete();
	}

	vtkMarchingCubes *cubesFilter = vtkMarchingCubes::New();
    cubesFilter->SetInput(this->_imagedata);
    cubesFilter->SetValue(0,value);
	cubesFilter->ComputeGradientsOn ();
    cubesFilter->ComputeScalarsOn ();
	cubesFilter->SetNumberOfContours( 1 );
	
	// Unir puntos duplicados y remover primitivas degeneradas
	vtkCleanPolyData *cleanFilter = vtkCleanPolyData::New();
    cleanFilter->SetInput ( cubesFilter->GetOutput() );
	cleanFilter->Update();

	_polydata = vtkPolyData::New();
	_polydata->DeepCopy(cleanFilter->GetOutput());

	cubesFilter->Delete();
	cleanFilter->Delete();


	_dataMapper = vtkPolyDataMapper::New();
	_dataMapper->SetInput(_polydata);

	vtkActor* dataActor = vtkActor::New();
	dataActor->SetMapper(_dataMapper);	
	_prop3D = dataActor;	
	
	
}
int wxMaracasIRMViewManagerData::getMaxGreyLevel(){
	return _maxgreylevel;
}
wxMaracasIRMViewManagerData::~wxMaracasIRMViewManagerData(){
}
/**
**	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){
	vtkActor* actor = (vtkActor*)_prop3D;
	actor->GetProperty()->SetOpacity((double)value/100.0);
}

/**
**	Check if the variables are setted correctly
**/
void wxMaracasIRMViewManagerData::checkInvariant(){

}
/**
**	get the prop3D 
**/
vtkProp3D* wxMaracasIRMViewManagerData::getProp3D(){
	return _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;
}

void wxMaracasIRMViewManagerData::changeColor(double red, double green, double blue){
    vtkActor* actor = (vtkActor*)_prop3D;	
	actor->GetProperty()->SetColor(red,green,blue);
}