//----------------------------------------------------------------------------------------------------------------
#include "wxContourMainFrame.h"
+
+
//----------------------------------------------------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------------------------------------------------
#include "ConceptDataWrap.h"
#include <manualContour.h>
-#include "ImageSourceThing.h"
-#include "vtkImageData.h"
-#include "wxContour_ActionCommandsID.h"
+//#include "ImageSourceThing.h"
+//#include "wxContour_ActionCommandsID.h"
+//#include "OutlineModelBuilder.h"
+//#include "wxContourEventHandler.h"
//----------------------------------------------------------------------------------------------------------------
// Class implementation
//------------------------------------------------------------------------------------------------------------
// Constructors & Destructors
//------------------------------------------------------------------------------------------------------------
+
+wxContourMainFrame* wxContourMainFrame:: instance = NULL;
+char wxContourMainFrame::COPY = 'C';
wxContourMainFrame :: wxContourMainFrame(wxWindow* parent, wxWindowID id,const wxString& title,const wxPoint& pos,const wxSize& size,long style)
//: wxPanel(parent, id, title, pos, size, style)
m_mgr.SetManagedWindow(this);
_creatingContoursActive = false;
_theViewPanel = NULL;
- _modelManager = NULL;
+// _modelManager = NULL;
+ _instantPanel = NULL;
+ _buttonsBar = NULL;
+ _gridPanel = NULL;
+ _drawToolsPanel = NULL;
+ _operationsToolsPanel = NULL;
+ _autoFormsPanel = NULL;
+ _standardToolsPanel = NULL;
+ _editionToolsPanel = NULL;
+ _listViewPanel = NULL;
+ _sceneManager = NULL;
+ //_actualInstant = NULL;
+ _numberOfVariablesStatistics = 6+1;
+
+ // set up default notebook style
+ m_notebook_style =wxAUI_NB_TAB_SPLIT | wxAUI_NB_TAB_EXTERNAL_MOVE | wxNO_BORDER;
+ m_notebook_theme = 0;
+ //wxContour_ActionCommandsID a;
+
+ }
+
+wxContourMainFrame :: wxContourMainFrame(wxWindow* parent, wxWindowID id,const wxString& title,const wxPoint& pos,const wxSize& size,std::vector<vtkImageData*> images, long style)
+ : wxPanel(parent, id, pos, size, style)
+ {
+ m_mgr.SetManagedWindow(this);
+ _creatingContoursActive = false;
+ _theViewPanel = NULL;
+// _modelManager = NULL;
_instantPanel = NULL;
_buttonsBar = NULL;
_gridPanel = NULL;
_editionToolsPanel = NULL;
_listViewPanel = NULL;
_sceneManager = NULL;
- _actualInstant = NULL;
+ //_actualInstant = NULL;
// set up default notebook style
m_notebook_style =wxAUI_NB_TAB_SPLIT | wxAUI_NB_TAB_EXTERNAL_MOVE | wxNO_BORDER;
m_notebook_theme = 0;
- wxContour_ActionCommandsID a;
+ //wxContour_ActionCommandsID a;
+ _numberOfVariablesStatistics = 6+1;
+
+
+ _performingOperation = new PerformingOperation();
+//JCP 17 - 10 - 2008
+
+ inredo = 0;
+ inundo = 0;
+
+ kernelManager = new KernelManagerContour(images);
+ //kernelManager->setVectImages(images);
+ //kernelManager->initializeEnvironment();
+
+ //vtkImageData* selectedimage = kernelManager->getVectImages()[0];
+
+//-------------------------------------------------------------
+
+ /*frame = new wxContourMainFrame(_builder->getImSourceEnv(), _builder->getImSectionEnv(), _builder->getAxesEnv(), _builder->getContourEnv(),NULL, wxID_ANY, wxT("ROI Application Sample"), wxPoint(50,50), wxSize(800, 600));
+ frame->Show(TRUE);*/
+
+ //Creating the evtHandler of the panels
+ //wxContourEventHandler * eventHandler = new wxContourEventHandler();
+
+ //Creating the window that will show the panels
+
+ //Getting the parent for the panels ( using aui )
+ wxAuiNotebook * notebook = this->createNotebook();
+
+ //JCP 17 - 11 - 08
+ //wxInstantChooserPanel * instantPanel = new wxInstantChooserPanel( notebook, "Instant Chooser", true);
+ //JCP 17 - 11 - 08
+ std::vector<std::string> conceptNameVect;
+ std::vector<int> conceptSizeVect;
+
+
+
+ _instantPanel = new wxInstantChooserPanel( notebook, "Instant Chooser", true, false, "c" );
+ _theViewPanel = new wxContourViewPanel( kernelManager->getSourceImage(), notebook );
+
+
+
+ kernelManager->getConceptsInformation(conceptNameVect, conceptSizeVect);
+ _instantPanel->addConcepts(conceptNameVect, conceptSizeVect);
+
+
+ double val = _theViewPanel->getCurrentDeep();
+ _instantPanel->setConceptValue( "Axe Depth", (int)val );
+ //JCP _instantPanel->setConceptValue("time", num de imagenes);
+ ConceptDataWrap * data = _instantPanel->getConceptDataOf( "Axe Depth" );
+ //*******************changeInstant();
+ _theViewPanel->setVerticalConcept( "Axe Depth", data->getMinValue(), data->getMaxValue(), data->getMinShowedValue(), data->getMaxShowedValue(), data->getActualValue() );
+
+ //eventHandler->setModelManager( kernelManager->getOutlineModelManager() );
+ //eventHandler->setViewPanel( _theViewPanel );
+ //_theViewPanel->initializeScenceManager();
+ //eventHandler->setInstantChooserPanel( _instantPanel );
+
+ //bool successConfiuration = eventHandler->configureEventsHandling();
+
+ //successConfiuration &= this->configurePanels( notebook );
+ this->configurePanels( notebook );
+
+ interfMainPanel* pannew = interfMainPanel::getInstance(parent);//, eventHandler);
+
+//JCP 17 -10 - 2008
+
+
+ }
+
+
+ wxContourMainFrame* wxContourMainFrame :: getInstance(wxWindow* parent, wxWindowID id,const wxString& title,const wxPoint& pos,const wxSize& size,std::vector<vtkImageData*> images, long style ){
+ if(instance == NULL){
+ instance = new wxContourMainFrame(parent, id, title, pos, size, images, style);
+ }
+ return instance;
+ }
+
+ std::vector<vtkImageData*> wxContourMainFrame ::getVectImages(){
+ return kernelManager->getVectImages();
+ }
+ wxContourMainFrame* wxContourMainFrame :: getInstance(){
+ return instance;
+
}
wxContourMainFrame :: ~wxContourMainFrame()
//------------------------------------------------------------------------------------------------------------
- void wxContourMainFrame :: setViewPanel( wxContourViewPanel * theViewPanel )
- {
- _theViewPanel = theViewPanel;
- }
-
+
void wxContourMainFrame :: setInstantChooserPanel( wxInstantChooserPanel * theInstantChooserPanel )
{
_instantPanel = theInstantChooserPanel;
_listViewPanel = theListViewPanel;
}
+
+
+void wxContourMainFrame::onCreateContourSpline( ){
+
+ //JCP 20-10-08 Undo redo implementation
+ saveState();
+ //JCP 20-10-08 Undo redo implementation
+ createContour( 1 );
+
+}
+void wxContourMainFrame::onCreateContourRectangle( ){
+ //JCP 20-10-08 Undo redo implementation
+ saveState();
+ //JCP 20-10-08 Undo redo implementation
+ createContour( 2 );
+}
+void wxContourMainFrame::onCreateContourCircle( ){
+ //JCP 20-10-08 Undo redo implementation
+ saveState();
+ //JCP 20-10-08 Undo redo implementation
+ createContour( 3 );
+}
+//------------------------------------------------------------------------------------------------------------
+
+void wxContourMainFrame :: onCreateContourBullEye(wxPanel* panel )
+{
+ //Creating the manualContourModel and including in the model
+ manualContourModel * manModelContour = factoryManualContourModel(panel );
+
+ std::vector<int> instantVector;
+ _instantPanel->getInstant( instantVector );
+ std::string theName = kernelManager->createOutline(manModelContour, instantVector);
+
+ /*std::vector<int> instantVector;
+ _instantPanel->getInstant( instantVector );
+ std::string theName;
+ theName= _modelManager->createOutline( manModelContour, instantVector );*/
+ bool addedModel = theName.compare("") != 0;//??
+
+ if( addedModel )
+ {
+ double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
+ _theViewPanel->getSpacing(spc);
+ //Adding the manualContourControler to interface objects structure
+ //Adding the manualViewContour to interface objects structure
+ //_theViewPanel->getSceneManager()->setControlActiveStateOfALL( false );//This call is being done here because if the ROI is created underneath the previously created ROIS will still be active.
+ _theViewPanel->getSceneManager()->configureViewControlTo( theName, manModelContour,spc , 4) ;
+ }
+}
+void wxContourMainFrame :: createContour( int typeContour )
+{
+ //Creating the manualContourModel and including in the model
+ manualContourModel * manModelContour = kernelManager->factoryManualContourModel(typeContour);
+
+
+ std::vector<int> instantVector;
+ _instantPanel->getInstant( instantVector );
+ std::string theName = kernelManager->createOutline(manModelContour, instantVector);
+
+ /*std::vector<int> instantVector;
+ _instantPanel->getInstant( instantVector );
+ std::string theName;
+ theName= _modelManager->createOutline( manModelContour, instantVector );*/
+ bool addedModel = theName.compare("") != 0;//??
+ if( addedModel )
+ {
+ double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
+ _theViewPanel->getSpacing(spc);
+ //Adding the manualContourControler to interface objects structure
+ //Adding the manualViewContour to interface objects structure
+ //_sceneManager->setControlActiveStateOfALL( false );//This call is being done here because if the ROI is created underneath the previously created ROIS will still be active.
+ _theViewPanel->getSceneManager()->configureViewControlTo( theName, manModelContour,spc , typeContour) ;
+ }
+
+}
+manualContourModel * wxContourMainFrame::factoryManualContourModel(wxPanel* panel){
+
+ manualContourModelBullEye *manModelContourBullEye = new manualContourModelBullEye();
+ manualContourModel *manModelContour=NULL;
+ manModelContour = manModelContourBullEye;
+ if (panel!=NULL){
+ int iCrown,sizeCrowns,iSector,sizeSectors;
+ double radioA,radioB,ang,angDelta ;
+ sizeCrowns = ((PanelBullEyeOptions*)panel)->GetNumberOfCrowns();
+ for ( iCrown=0 ; iCrown<sizeCrowns ; iCrown++ )
+ {
+ sizeSectors = ((PanelBullEyeOptions*)panel)->GetNumberOfSections(iCrown);
+ radioB = ((PanelBullEyeOptions*)panel)->GetRadioOfCrown(iCrown);
+ if (iCrown==sizeCrowns-1)
+ {
+ radioA = 0;
+ } else {
+ radioA = ((PanelBullEyeOptions*)panel)->GetRadioOfCrown(iCrown+1);
+ }
+ radioA=radioA/100.0;
+ radioB=radioB/100.0;
+ for ( iSector=0 ; iSector<sizeSectors ; iSector++ )
+ {
+ ang = ((PanelBullEyeOptions*)panel)->GetAngOfCrownSection(iCrown,iSector);
+ angDelta= ((PanelBullEyeOptions*)panel)->GetAngDeltaOfCrownSection(iCrown);
+ manModelContourBullEye->AddSector(radioA,radioB,ang,angDelta);
+ } // for iSector
+ } // for iCrown
+ } // if _panelBullEyeOptions
+
+ return manModelContour;
+}
+void wxContourMainFrame :: saveState(){
+
+ std::string temp = kernelManager->saveState();
+ saveFileWithContours(temp);
+}
+
+void wxContourMainFrame::onDeleteContour(){
+ //JCP 20-10-08 Undo redo implementation
+ saveState();
+ //JCP 20-10-08 Undo redo implementation
+
+ std::vector<std::string> lstKeyNameToBeErase;
+ lstKeyNameToBeErase = _theViewPanel->getSceneManager()->getSelectedObjects();
+ deleteContours( lstKeyNameToBeErase );
+/*JCP 19 - 11 - 08
+ int i,size=_sceneManager->getSelectedObjects().size();
+ for(i=0;i<size;i++)
+ {
+ std::string keyName = _sceneManager->getSelectedObjects()[i];
+ int ispartofstaticlist = this->_modelManager->IsPartOfStaticList( keyName );
+ if ( ispartofstaticlist>=0 )
+ {
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+ Instant instant(&tempVector);
+ this->_modelManager->ChangeContourOfList(keyName, &instant);
+ }
+ }
+
+ std::vector<std::string> lstKeyName;
+ std::vector<std::string> lstKeyNameActualSlice;
+ std::vector<std::string> lstKeyNameToBeErase;
+
+ lstKeyNameToBeErase = _sceneManager->getSelectedObjects();
+ lstKeyNameActualSlice = _sceneManager->GetlstContoursNameActualSlice();
+ int k,kSize=lstKeyNameToBeErase.size();
+ int j,jSize=lstKeyNameActualSlice.size();
+ bool ok;
+ for (k=0;k<kSize; k++)
+ {
+ ok=false;
+ for (j=0;j<jSize; j++)
+ {
+ if (lstKeyNameToBeErase[k]==lstKeyNameActualSlice[j])
+ {
+ ok=true;
+ }
+ } // for j
+ if (ok==true)
+ {
+ lstKeyName.push_back( lstKeyNameToBeErase[k] );
+ } // if ok
+ } // for k
+
+ deleteContours( lstKeyName );
+JCP 19 - 11 - 08*/
+}
+
+void wxContourMainFrame :: deleteContours( std::vector<std::string> keyNamesVector )
+{
+ int i,size=keyNamesVector.size();
+ for (i=0;i<size;i++)
+ {
+ deleteContour( keyNamesVector[i] );
+ }
+}
+
+void wxContourMainFrame :: deleteContour( std::string theKeyName ){
+ /*manualContourModel * cModel;
+ manualViewBaseContour * cViewer;
+ manualContourBaseControler * cControler;
+
+ ContourWrap_ViewControl *conwrapviewControl = _theViewPanel->getSceneManager()->getContourWrap_ViewControlOf( theKeyName );
+ cControler = conwrapviewControl->getControler();*/
+
+ //JCP 21 - 11 - 2008
+ bool isedit = _theViewPanel->isEditableCControler(theKeyName);
+ bool ispartofstaticlst = kernelManager->IsPartOfStaticList(theKeyName);
+
+ if (isedit && ispartofstaticlst)
+ {
+ _theViewPanel->removeFromScene(theKeyName);
+
+ kernelManager->deleteCModel(theKeyName);
+ //_theViewPanel->getSceneManager()->removeFromScene( theKeyName );
+ //cViewer = conwrapviewControl->getViewer();
+ //_theViewPanel->getSceneManager()->removeWrap( theKeyName );
+ //cControler* conwrapviewControl->getControler();
+//EED Borrame
+//FILE *ff = fopen("c:/temp/wxVtkBaseView_SceneManagerStadistics.txt","a+");
+//fprintf(ff,"EED wxContourEventHandler::deleteContours() \n" );
+//fprintf(ff," %s %p\n",keyNamesVector[i].c_str(), cControler );
+//fclose(ff);
+ // delete cModel;
+ // delete cViewer;
+ // delete cControler;
+ } // if editable
+//JCP 21 - 11 - 08
+}
+
+void wxContourMainFrame::onDeleteContoursActSlice(){
+ //JCP 20-10-08 Undo redo implementation
+ saveState();
+ //JCP 20-10-08 Undo redo implementation
+ deleteContours( (std::vector<std::string>)_theViewPanel->getSceneManager()->GetlstContoursNameActualSlice() );
+}
+void wxContourMainFrame::onDeleteAllContours(){
+ //JCP 20-10-08 Undo redo implementation
+ saveState();
+ deleteAllContours();
+}
+void wxContourMainFrame::deleteAllContours(){
+ //JCP 20-10-08 Undo redo implementation
+
+ wxBusyCursor wait;
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+
+//JCP --08-09-2008 When using a diferent interface the _mbarrangeDeleteAll might not be initialize
+// the values in GetStart and GetEnd will then not be initialize also.
+// We use instead the values given when initializing the _deletepanel.
+
+ //int minZ = _mbarrangeDeleteAll->GetStart();
+ //int maxZ = _mbarrangeDeleteAll->GetEnd();
+ int minZ, maxZ;
+
+ minZ = 0;
+ maxZ = _theViewPanel->getSceneManager()->GetImageDataSizeZ();
+
+//JCP --08-09-2008
+
+ _theViewPanel->getSceneManager()->removeSceneContours( );
+ _theViewPanel->getSceneManager()->removeAllOutlines();
+ kernelManager->removeAllOutlines();
+//JCP --08-09-2008
+ /*
+ if ( (minZ==0) && (maxZ==_mbarrangeDeleteAll->GetMax() ))
+ {
+ _theViewPanel->getSceneManager()->removeSceneContours( );
+ _modelManager->removeAllOutlines();
+ _theViewPanel->getSceneManager()->removeAllOutlines();
+
+ } else {
+ for ( z=minZ ; z<=maxZ ; z++)
+ {
+ tempVector[1]=z;
+ Instant instant(&tempVector);
+ std::vector<ContourThing**> lstContourThings = this->_modelManager->getOutlinesAtInstant( &instant );
+
+ sizeLstContourThings = lstContourThings.size();
+ for (ii=0 ; ii<sizeLstContourThings ; ii++)
+ {
+ ContourThing **contourthing = lstContourThings[ii];
+ deleteContour( (*contourthing)->getName() );
+ } //for ii
+ }// for z
+ } // if
+JCP --08-09-2008 */
+}
+
+void wxContourMainFrame::setConceptValue( std::string name, int value ){
+ _instantPanel->setConceptValue(name, value);
+}
+
+ConceptDataWrap* wxContourMainFrame::getLastConceptData(){
+ return _instantPanel->getLastConceptData();
+}
+bool wxContourMainFrame::getIfConceptCheckedAt( std::string name, int pos ){
+ return _instantPanel->getIfConceptCheckedAt( name, pos );
+}
+
+void wxContourMainFrame::changeInstant(){
+ std::vector<int> instantVect;
+ _instantPanel->getInstant( instantVect );
+// Instant * theInstant = new Instant ( &instantVect );
+
+ //Setting the actual instant
+ //_actualInstant = theInstant;
+
+ kernelManager->setInstant(instantVect);
+ //_modelManager->setInstant( _actualInstant );
+
+ updateInstantOutlines();
+ updateInstantImageData();
+ updateInstantAxes();
+
+
+}
+void wxContourMainFrame :: updateInstantOutlines(){
+
+ _theViewPanel->removeSceneContours();
+ _theViewPanel->addNameWrapperToScene();
+
+ //for( int i=0; i<size; i++)
+ //{
+ // _theViewPanel->getSceneManager()->addToScene(namesWrapping[i]->getKeyName(), true, true, true, false, false );
+ //}
+}
+
+int wxContourMainFrame::getNamesWrappingSize(){
+ return kernelManager->getNamesWrappingSize();
+}
+std::string wxContourMainFrame::getNameWrapping(int i){
+ return kernelManager->getNameWrapping(i);
+}
+
+void wxContourMainFrame::updateInstantImageData(){
+ std::vector<int> inst;
+ _instantPanel->getInstant(inst);
+
+ vtkImageData* img = kernelManager->getImageAtInstant(inst);
+ if(img!=NULL){
+ _theViewPanel->changeImage(img);
+ }
+}
+void wxContourMainFrame::updateInstantAxes(){
+}
+
+void wxContourMainFrame::onChangeDeep(int val){
+ _instantPanel->setConceptValue( "Axe Depth", (int)val );
+ changeInstant();
+}
+
+
+void wxContourMainFrame::onCopy(){
+ std::vector<std::string> currentSelection = _theViewPanel->getSelectedObjects();
+
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+ _performingOperation->reset();
+ _performingOperation->setStartCommand( COPY );
+ _performingOperation->setStartOperationInstantVector( tempVector );
+ _performingOperation->setKeyNamesOperationElems( currentSelection );
+}
+void wxContourMainFrame::onPaste(){
+
+
+ char theStartCommand = _performingOperation->getStartCommand();
+ if ( theStartCommand == COPY )
+ {
+ //JCP 20-10-08 Undo redo implementation
+ saveState();
+ //JCP 20-10-08 Undo redo implementation
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+ _performingOperation->setEndOperationInstantVector ( tempVector );
+ std::vector<std::string> elems = _performingOperation->getKeyNamesOperationElems();
+ int i,size = elems.size();
+ for( i=0; i<size; i++ )
+ {
+ createCopyContourOf( elems[i], tempVector, i>0 );
+ }
+ }
+}
+void wxContourMainFrame::onUndo(){
+ std::string filename;
+ if(kernelManager->onUndoSaveFile(filename)){
+ saveFileWithContours(filename);
+ }
+ if(kernelManager->onUndo(filename)){
+ loadState(filename);
+ }
+}
+void wxContourMainFrame::onRedo(){
+ std::string filename;
+ if(kernelManager->onRedo(filename)){
+ loadState(filename);
+ }
+
+}
+void wxContourMainFrame :: createCopyContourOf ( std::string anExistingKName, std::vector<int> &instantNoTouchData, bool append ){
+ std::string cloneName = kernelManager->createCopyContourOf( anExistingKName, instantNoTouchData );
+ manualContourModel * manualModel = kernelManager->getOutlineByKeyName(cloneName);//_modelManager->getOutlineByKeyName( cloneName )->getModel();
+ _theViewPanel->getSceneManager()->createCopyContourOf( anExistingKName, cloneName, manualModel , append );
+}
+
+void wxContourMainFrame ::loadState(std::string filename){
+ char tmp[255];
+ FILE *pFile=fopen(filename.c_str(),"r+");
+
+ fscanf(pFile,"%s",tmp); // --CreaContour--
+
+ fscanf(pFile,"%s",tmp); // Version
+ fscanf(pFile,"%s",tmp); // 1.0.1
+ std::string version(tmp);
+
+ deleteAllContours();
+
+ openContours(pFile,false);
+ if (version!="1.0.0"){
+ openContours(pFile,true);
+ }
+
+ fclose(pFile);
+
+ //_theViewPanel->getSceneManager()->removeSceneContours();
+ //changeInstant();
+
+}
+
+void wxContourMainFrame::onLoad(){
+ char tmp[255];
+ wxFileDialog dialog(NULL, _T("Choose a file"), _T(""), _T(""), _T("*.roi"), wxOPEN );
+ if (dialog.ShowModal() == wxID_OK)
+ {
+ std::string fileNameContourROI = (const char *)(dialog.GetPath().mb_str());
+ FILE *pFile=fopen(fileNameContourROI.c_str(),"r+");
+
+ fscanf(pFile,"%s",tmp); // --CreaContour--
+
+ fscanf(pFile,"%s",tmp); // Version
+ fscanf(pFile,"%s",tmp); // 1.0.1
+ std::string version(tmp);
+
+ openContours(pFile,false);
+ if (version!="1.0.0"){
+ openContours(pFile,true);
+ }
+// _theViewPanel->getSceneManager()->openFileWithContours(ff);
+
+ fclose(pFile);
+ }
+ _theViewPanel->getSceneManager()->removeSceneContours();
+ changeInstant();
+}
+void wxContourMainFrame::onSave(){
+ wxFileDialog dialog(NULL, _T("Choose a file"), _T(""), _T(""), _T("*.roi"), wxSAVE );
+ if (dialog.ShowModal() == wxID_OK)
+ {
+ std::string fileNameContourROI = (const char *)(dialog.GetPath().mb_str());
+ saveFileWithContours( fileNameContourROI );
+ }
+}
+void wxContourMainFrame::saveFileWithContours( std::string filename ){
+
+ FILE *pFile=fopen(filename.c_str(),"w+");
+ std::vector< std::string > lstNameThings;
+ int i,sizeLstNameThings;
+
+ fprintf(pFile,"--CreaContour--\n");
+ fprintf(pFile,"Version %s\n", "1.0.1" );
+
+ // Normal Contours
+ lstNameThings = kernelManager->GetLstNameThings();
+ sizeLstNameThings = lstNameThings.size();
+ fprintf(pFile,"NumberOfContours %d\n", sizeLstNameThings );
+ for (i=0 ; i<sizeLstNameThings ; i++)
+ {
+ kernelManager->SaveThingName( pFile, lstNameThings[i] );
+ _theViewPanel->getSceneManager()->SaveThingName( pFile, lstNameThings[i] );
+ }// for i
+
+ //-- Contours Statics
+ lstNameThings = kernelManager->GetLstNameThingsStatic();
+ sizeLstNameThings = lstNameThings.size();
+ fprintf(pFile,"NumberOfContoursStatic %d\n", sizeLstNameThings );
+ for (i=0 ; i<sizeLstNameThings ; i++)
+ {
+ kernelManager->SaveThingName( pFile, lstNameThings[i] );
+ _theViewPanel->getSceneManager()->SaveThingName( pFile, lstNameThings[i] );
+ }// for i
+ fclose(pFile);
+}
+
+void wxContourMainFrame::openContours( FILE *pFile, bool staticContour ){
+ char tmp[255];
+ fscanf(pFile,"%s",tmp); // NumberOfContours
+ fscanf(pFile,"%s",tmp); // ##
+ int numberOfContours = atoi(tmp);
+
+ std::vector<int> instantVector;
+ int typeContourModel;
+ manualContourModel *manModelContour;
+ int typeView;
+
+ int i;
+ for (i=0;i<numberOfContours;i++)
+ {
+ instantVector.clear();
+ fscanf(pFile,"%s",tmp); // Instant
+
+ fscanf(pFile,"%s",tmp); // 1
+ instantVector.push_back( atoi(tmp) );
+ fscanf(pFile,"%s",tmp); // 2
+ instantVector.push_back( atoi(tmp) );
+ fscanf(pFile,"%s",tmp); // 3
+ instantVector.push_back( atoi(tmp) );
+ fscanf(pFile,"%s",tmp); // 4
+ instantVector.push_back( atoi(tmp) );
+ fscanf(pFile,"%s",tmp); // 5
+ instantVector.push_back( atoi(tmp) );
+ fscanf(pFile,"%s",tmp); // 6
+ instantVector.push_back( atoi(tmp) );
+
+
+ fscanf(pFile,"%s",tmp); // TypeContourModel
+ fscanf(pFile,"%s",tmp); // ##
+ typeContourModel = atoi(tmp);
+
+ manModelContour = kernelManager->factoryManualContourModel(typeContourModel);
+ manModelContour->Open(pFile);
+
+ fscanf(pFile,"%s",tmp); // TypeView
+ fscanf(pFile,"%s",tmp); // ##
+ typeView = atoi(tmp);
+
+
+// if (typeView==1)
+// {
+// }
+
+
+ std::string theName;
+ theName = kernelManager->createOutline( manModelContour, instantVector );
+ bool addedModel = theName.compare("") != 0;
+ if( addedModel )
+ {
+ double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
+ _theViewPanel->getSpacing(spc);
+ //Adding the manualContourControler to interface objects structure
+ //Adding the manualViewContour to interface objects structure
+ //_theViewPanel->getSceneManager()->setControlActiveStateOfALL( false );//This call is being done here because if the ROI is created underneath the previously created ROIS will still be active.
+ _theViewPanel->getSceneManager()->configureViewControlTo( theName, manModelContour,spc , typeView) ;
+ }
+
+ if (staticContour==true)
+ {
+ Instant instant(&instantVector);
+ kernelManager->changeContourOfManager( theName , &instant );
+ }
+
+ }// for numberOfContours
+
+}
+
+void wxContourMainFrame::RefreshInterface(){
+ changeInstant();
+ _theViewPanel->RefreshInterface();
+ //wxVtk2DBaseView *wxvtk2dbaseview = (wxVtk2DBaseView*)this->_theViewPanel->getWxVtkBaseView();
+ //wxvtk2dbaseview->Refresh();
+}
+
+vtkImageData* wxContourMainFrame::getImageData(){
+ return _theViewPanel->getImageData();
+}
+
+void wxContourMainFrame::onSegmentationOneSlice(int isovalue,int sampling,int method){
+
+ //JCP 20-10-08 Undo redo implementation
+ saveState();
+ //JCP 20-10-08 Undo redo implementation
+
+ wxBusyCursor wait;
+ int x = _theViewPanel->GetX();
+ int y = _theViewPanel->GetY();
+ int z = _theViewPanel->GetZ();
+ SegmentationOneSlice( x,y,z,isovalue, sampling, method );
+ RefreshInterface();
+}
+
+void wxContourMainFrame::SegmentationOneSlice( int x, int y, int z, int isovalue, int sampling, int method )
+{
+ int typeofcontour = 1;
+ //--Extracting Contour
+ //vtkImageData *imagedata = _theViewPanel->getSceneManager()->GetImageData();
+ vtkImageData *imagedata = getImageData();
+// double *range = imagedata->GetScalarRange();
+// double thr = 1;
+
+ vtkImageReslice *imageReslice = vtkImageReslice::New();
+//EED
+// double spc[3];
+// imagedata->GetSpacing(spc);
+// x = x*spc[0];
+// y = y*spc[1];
+// z = z*spc[3];
+
+ imageReslice->SetInput( imagedata );
+ imageReslice->SetInformationInput(imagedata);
+ imageReslice->SetResliceAxesDirectionCosines(1,0,0, 0,1,0 ,0,0,1);
+ imageReslice->SetResliceAxesOrigin(0,0,z);
+ imageReslice->SetOutputDimensionality(2);
+ imageReslice->SetInterpolationModeToLinear();
+
+ imagedata = imageReslice->GetOutput();
+ imagedata->Update();
+ imagedata->UpdateInformation();
+
+ vtkContourFilter* cntVTK = vtkContourFilter::New( );
+ cntVTK->SetInput( imagedata );
+
+ cntVTK->SetNumberOfContours( 1 );
+ //cntVTK->SetValue( 0, vmin );
+// cntVTK->SetValue( 0, (range[1]*thr/100) );
+ cntVTK->SetValue( 1, isovalue );
+// cntVTK->SetValue( 1, vmax );
+ cntVTK->Update( );
+ cntVTK->UpdateInformation();
+
+ vtkCleanPolyData* cpd = vtkCleanPolyData::New( );
+ cpd->SetInput( cntVTK->GetOutput( ) );
+ cpd->ConvertLinesToPointsOff( );
+ cpd->Update( );
+ cpd->UpdateInformation();
+
+ vtkPolyDataConnectivityFilter* conn = vtkPolyDataConnectivityFilter::New( );
+ conn->SetExtractionModeToClosestPointRegion( );
+ //conn->SetMaxRecursionDepth( 3000 );
+
+ conn->SetInput( cpd->GetOutput( ) );
+
+ conn->SetClosestPoint( x, y, 0 );
+ conn->Update( );
+ conn->UpdateInformation();
+
+ vtkCleanPolyData* cpd2 = vtkCleanPolyData::New( );
+ cpd2->SetInput( conn->GetOutput( ) );
+ cpd2->Update();
+ cpd2->UpdateInformation();
+
+ vtkStripper* vtkstripper = vtkStripper::New( );
+ vtkstripper->SetInput( cpd2->GetOutput() );
+ vtkstripper->Update();
+ vtkstripper->UpdateInformation();
+
+
+ vtkPolyData* polyDataResult = vtkstripper->GetOutput();
+
+ polyDataResult->Update( );
+ polyDataResult->UpdateInformation();
+
+/* EED
+ofstream myfile;
+myfile.open ("c:/temp/example.txt");
+myfile << "\n";
+polyDataResult->Print(myfile);
+myfile << "-------------------------------------\n";
+polyDataResult->GetLines()->Print(myfile);
+myfile.close();
+*/
+
+ cntVTK -> Delete();
+ cpd2 -> Delete();
+ cpd -> Delete();
+ conn -> Delete();
+
+
+//--Calculating control points
+
+ std::vector<double> vecX;
+ std::vector<double> vecY;
+ std::vector<double> vecZ;
+
+ std::vector<double> vecCtrlPointX;
+ std::vector<double> vecCtrlPointY;
+ std::vector<double> vecCtrlPointZ;
+
+
+ double *p;
+ int ii,size=polyDataResult->GetNumberOfPoints();
+ int id;
+ for (ii=1;ii<=size;ii++)
+ {
+ id = polyDataResult->GetLines()->GetData()->GetValue(ii);
+ p = polyDataResult->GetPoint(id);
+ double x=p[0];
+ double y=p[1];
+ vecX.push_back( p[0] );
+ vecY.push_back( p[1] );
+ vecZ.push_back( -900 );
+// vecZ.push_back( p[2] );
+ }
+
+
+ ExtractControlPoints2D *extractcontrolpoints2d = new ExtractControlPoints2D();
+ extractcontrolpoints2d->SetContour( &vecX , &vecY , &vecZ );
+
+//PROOFS
+ /*if (methodRadiobox->GetSelection()==0){
+ extractcontrolpoints2d->GetInitialControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
+ }
+ if (methodRadiobox->GetSelection()==1){
+ extractcontrolpoints2d->GetControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
+ }
+ if (methodRadiobox->GetSelection()==2){
+ extractcontrolpoints2d->SetSamplingControlPoints( sampling );
+ extractcontrolpoints2d->GetSamplingControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
+ }*/
+
+ if (method==0){
+ extractcontrolpoints2d->GetInitialControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
+ }
+ else if (method==1){
+ extractcontrolpoints2d->GetControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
+ }
+ else if (method==2){
+ extractcontrolpoints2d->SetSamplingControlPoints( sampling );
+ extractcontrolpoints2d->GetSamplingControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
+ }
+
+ //--Adding contour to the system
+
+ std::vector<int> actualInstantVector;
+ _instantPanel->getInstant( actualInstantVector );
+ actualInstantVector[1]=z;
+
+ int j,sizeCtrPt = vecCtrlPointX.size();
+ manualContourModel *manModelContour = kernelManager->factoryManualContourModel( typeofcontour );
+ manModelContour->SetNumberOfPointsSpline( ((sizeCtrPt/100)+1)*100 );
+ if (sizeCtrPt>=3){
+ for (j=0 ; j<sizeCtrPt ; j++)
+ {
+ manModelContour->AddPoint( vecCtrlPointX[j] , vecCtrlPointY[j] , vecCtrlPointZ[j] );
+ } // for
+ std::string theName;
+ //theName = _modelManager->createOutline( manModelContour, actualInstantVector );
+ theName = kernelManager->createOutline( manModelContour, actualInstantVector );
+ bool addedModel = theName.compare("") != 0;
+ if( addedModel )
+ {
+ double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
+ _theViewPanel->getSpacing(spc);
+ //Adding the manualContourControler to interface objects structure
+ //Adding the manualViewContour to interface objects structure
+ //_theViewPanel->getSceneManager()->setControlActiveStateOfALL( false );//This call is being done here because if the ROI is created underneath the previously created ROIS will still be active.
+ _theViewPanel->configureViewControlTo(theName, manModelContour, spc, typeofcontour);
+ //_theViewPanel->getSceneManager()->configureViewControlTo( theName, manModelContour,spc, typeofcontour ) ;
+ } // if addedModel
+ } // if sizeCtrPt
+}
+
+int wxContourMainFrame::GetImageDataSizeZ(){
+ return _theViewPanel->GetImageDataSizeZ();
+}
+
+void wxContourMainFrame::GetImageDataRange(double *range){
+ _theViewPanel->GetImageDataRange(range);
+}
+
+void wxContourMainFrame::onSegmentationAllSlice(int minZ,int maxZ,int isovalue,int sampling,int method){
+ //JCP 20-10-08 Undo redo implementation
+ saveState();
+ //JCP 20-10-08 Undo redo implementation
+
+ wxBusyCursor wait;
+ int x = _theViewPanel->GetX();
+ int y = _theViewPanel->GetY();
+ int z;
+ double porcent;
+ wxString tmpString;
+ double totalZ = maxZ-minZ+1;
+ for( z=minZ ; z<=maxZ ; z++ )
+ {
+ porcent = 100.0* (z-minZ)/totalZ;
+ tmpString.Printf(_T(" %d %c %d/%d %d"), (int)porcent , 37 , z-minZ+1, (int)totalZ,z );
+ interfMainPanel::getInstance()->setLabelSegmentationPanelVTK(tmpString);
+ //_staticTextSegmentation->SetLabel(tmpString);
+ SegmentationOneSlice( x,y,z,isovalue, sampling,method );
+ }
+ interfMainPanel::getInstance()->setLabelSegmentationPanelVTK(_T(" "));
+ RefreshInterface();
+}
+
+void wxContourMainFrame::showAxis(bool show){
+ _theViewPanel->SetVisibleAxis(show);
+ _theViewPanel->Refresh();
+}
+
+
+void wxContourMainFrame::onRigidPressed(){
+ std::vector<std::string> currentSelection = _theViewPanel->getSelectedObjects();
+ int elementsSelected = currentSelection.size();
+
+ if ( elementsSelected >= 1 ){
+ //JCP 20-10-08 Undo redo implementation
+ saveState();
+ //JCP 20-10-08 Undo redo implementation
+
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+ Instant instant(&tempVector);
+
+ int i , size=currentSelection.size();
+ for ( i=0 ; i<size ; i++ )
+ {
+ kernelManager->changeContourOfManager(currentSelection[i], &instant);
+ } // i
+ }
+}
+
+void wxContourMainFrame::onWidthOfContour(double width){
+
+ _theViewPanel->removeSceneContours();
+ _theViewPanel->SetWidthContour(width);
+
+ //_theViewPanel->getSceneManager()->SetWidthContour( width );
+
+ RefreshInterface();
+}
+int wxContourMainFrame::getColorWindow(){
+ return _theViewPanel->getColorWindow();
+}
+int wxContourMainFrame::getWindowLevel(){
+ return _theViewPanel->getWindowLevel();
+}
+
+void wxContourMainFrame::onBrigthnessColorWindowLevel(int colorwindow,int windowlevel){
+ _theViewPanel->onBrigthnessColorWindowLevel(colorwindow, windowlevel);
+
+
+ RefreshInterface();
+}
+
+void wxContourMainFrame::onInterpolation(bool interpolate){
+ _theViewPanel->onInterpolation(interpolate);
+ RefreshInterface();
+}
+
+void wxContourMainFrame::onChangeInstant(std::string name,int actual){
+ _instantPanel->setConceptValue( name, actual );
+}
+
+void wxContourMainFrame::resetAppend(){
+ kernelManager->resetAppend();
+
+}
+
+void wxContourMainFrame::onSpreadAdd(){
+ std::vector<double> vecX;
+ std::vector<double> vecY;
+ std::vector<double> vecZ;
+ _theViewPanel->GetPointsOfActualContour(&vecX , &vecY , &vecZ );
+
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+
+ std::string val = kernelManager->onSpreadAdd(&vecX , &vecY , &vecZ, tempVector);
+
+ interfMainPanel::getInstance()->appendStringSpread(val);
+
+}
+
+void wxContourMainFrame::onSpreadGo(int type){
+
+ //JCP 20-10-08 Undo redo implementation
+ saveState();
+ //JCP 20-10-08 Undo redo implementation
+
+ wxBusyCursor wait;
+ std::vector<double> vecCtrlPointX;
+ std::vector<double> vecCtrlPointY;
+ std::vector<double> vecCtrlPointZ;
+ double minZ,maxZ;
+ int z;
+
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+// tempVector[1];
+
+ kernelManager->getMaxMinZ(&minZ,&maxZ);
+//JSTG_16-07-08_----------------------------------------------------------------
+ //_contourPropagation->setInterpolationNumber(maxZ-minZ+1);
+ kernelManager->CalculeSplinePropagation();
+
+ double totalZ = maxZ-minZ+1;
+ double porcent;
+ wxString tmpString;
+//--------------------------------------------------------------------
+ for ( z=(int)minZ ; z<=(int)maxZ ; z++ )
+ {
+ porcent = 100.0* (z-minZ)/totalZ;
+ int numero = (int)(z-minZ+1)/(int)totalZ;
+ std::string stringtemp = " "+kernelManager->intToString(porcent)+"% "+kernelManager->intToString(numero)+" "+kernelManager->intToString(z);
+
+ interfMainPanel::getInstance()->setStringSpread(stringtemp);
+
+ int typeofcontour = 1;
+ std::string theName;
+ manualContourModel* manModelContour = kernelManager->GetPoints(z, type, &vecCtrlPointX,&vecCtrlPointY,&vecCtrlPointZ, theName,typeofcontour, tempVector);
+
+ if( manModelContour!=NULL ){
+ double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
+ this->_theViewPanel->getSpacing(spc);
+ //Adding the manualContourControler to interface objects structure
+ //Adding the manualViewContour to interface objects structure
+ //_theViewPanel->getSceneManager()->setControlActiveStateOfALL( false );//This call is being done here because if the ROI is created underneath the previously created ROIS will still be active.
+ _theViewPanel->configureViewControlTo( theName, manModelContour,spc,typeofcontour ) ;
+ } // if addedModel
+ }
+ if(z > maxZ){
+ porcent = 100.0;
+ int numero = (int)(z-minZ+1)/(int)totalZ;
+ std::string stringtemp = " "+kernelManager->intToString(porcent)+"% "+kernelManager->intToString(numero)+" "+kernelManager->intToString(z);
+
+ interfMainPanel::getInstance()->setStringSpread(stringtemp);
+ }// for z
+ //RefreshInterface();
+}
+
+void wxContourMainFrame::getInstantVector(std::vector<int>& tempVector){
+
+}
+
+std::vector<std::string> wxContourMainFrame::getOutlinesName(int slide){
+ std::vector<int> tempVector;
+ _instantPanel->getInstant(tempVector);
+ //Asignation of slide number should be different ex by name
+ tempVector[1]=slide;
+ return kernelManager->getOutlinesNameAtInstant(tempVector);
+}
+
+void wxContourMainFrame::onInformationContourLabels(int typeContourGroup,int selection,int minimumZ,int maximumZ){
+ int maxContourGroup = 0;
+
+ ContourExtractData *contourextractdata = new ContourExtractData();
+
+ contourextractdata ->SetTypeOperation( typeContourGroup % 3 );
+
+ std::vector<manualContourModel*> lstManConMod;
+ std::vector<manualContourModel*> lstManConModTmp;
+ std::vector<manualContourModel*> lstManConModExp;
+ std::vector<double> pLstValue;
+ std::vector<double> pLstValuePosX;
+ std::vector<double> pLstValuePosY;
+ std::vector<double> pLstValuePosZ;
+
+ int resultSize;
+ int resultGrayRangeCount;
+ double resultMin;
+ double resultMax;
+ double resultAverage;
+ double resultStandardeviation;
+
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+
+ vtkImageData *imagedata = _theViewPanel->getImageData();
+ int sizeZ = _theViewPanel->GetImageDataSizeZ();
+ int z;
+ int ii,sizeLstContourThings;
+
+
+ int minZ,maxZ;
+ double totalZ;
+ double porcent;
+ wxString tmpString;
+
+
+
+ if (selection==0 ) // actual slice
+ {
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+ int actualSlice = tempVector[1];
+ minZ = actualSlice;
+ maxZ = actualSlice;
+ }
+ else if (selection==2 ) // All slices
+ {
+ minZ = 0;
+ maxZ = sizeZ-1;
+ }
+ else if (selection==1 ) // slice range
+ {
+ minZ = minimumZ;
+ maxZ = maximumZ;
+ }
+
+
+ totalZ = maxZ-minZ+1;
+ contourextractdata->SetImage( imagedata);
+
+// For each slice..
+ for ( z=minZ ; z<=maxZ ; z++ )
+ {
+
+ porcent = 100.0* (z-minZ)/totalZ;
+ tmpString.Printf(_T(" %d %c %d/%d %d"), (int)porcent , 37 , z-minZ+1, (int)totalZ ,z);
+
+ interfMainPanel::getInstance()->setStringInfoPanel(tmpString);
+ //_staticTextInformation->SetLabel(tmpString);
+
+ //Extraction data from contours of each slice
+ contourextractdata->SetZtoBeAnalys( z);
+
+ tempVector[1]=z;
+ Instant instant(&tempVector);
+ std::vector<ContourThing**> lstContourThings = kernelManager->getOutlinesAtInstant( &instant );
+ sizeLstContourThings = lstContourThings.size();
+
+ lstManConMod.clear();
+ for (ii=0 ; ii<sizeLstContourThings ; ii++)
+ {
+ ContourThing **contourthing = lstContourThings[ii];
+ lstManConMod.push_back( (*contourthing)->getModel() );
+ }
+ lstManConModExp = kernelManager->ExploseEachModel( lstManConMod );
+
+
+ wxString tempString;
+ tempString.Printf(_T("%d - %d"),z, sizeLstContourThings);
+ interfMainPanel::getInstance()->setRowLabelInfoPanel(z, tempString);
+ //_grid->SetRowLabelValue(z, tempString );
+//EED004
+ int iContourGroup,sizeContourGroup;
+ if (typeContourGroup==3) // contour separete
+ {
+ sizeContourGroup=lstManConModExp.size();
+ if ( maxContourGroup<sizeContourGroup )
+ {
+ maxContourGroup=sizeContourGroup;
+ }
+ } else { // contour AND OR XOR
+ sizeContourGroup=1;
+ maxContourGroup=1;
+ }
+
+ int tmpIntA;
+
+
+
+ for( iContourGroup=0 ; iContourGroup<sizeContourGroup ; iContourGroup++ ){
+ lstManConModTmp.clear();
+ if (typeContourGroup==3) // contour separete
+ {
+ lstManConModTmp.push_back( lstManConModExp[iContourGroup]);
+ } else { // contour AND OR XOR
+ lstManConModTmp = lstManConModExp;
+ }
+
+ contourextractdata->SetLstManualContourModel( lstManConModTmp );
+
+ pLstValue.clear();
+ pLstValuePosX.clear();
+ pLstValuePosY.clear();
+ pLstValuePosZ.clear();
+ contourextractdata->GetValuesInsideCrown( &pLstValue,
+ &pLstValuePosX,
+ &pLstValuePosY,
+ &pLstValuePosZ);
+ // Statistics of each slice.
+ contourextractdata->Statistics( &pLstValue,
+ minimumZ,
+ maximumZ,
+ &resultGrayRangeCount,
+ &resultSize,
+ &resultMin,
+ &resultMax,
+ &resultAverage,
+ &resultStandardeviation);
+
+ if (interfMainPanel::getInstance()->getNumberColsInformationPanel()<_numberOfVariablesStatistics*(iContourGroup+1) )
+ {
+ interfMainPanel::getInstance()->appendColsInformationPanel(_numberOfVariablesStatistics);
+ }
+
+ tmpIntA=_numberOfVariablesStatistics*iContourGroup ;
+
+ tempString.Printf(_T("%d"),resultSize);
+ interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA, tempString);
+
+ tempString.Printf(_T("%d"),resultGrayRangeCount);
+ interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA+1, tempString);
+
+ tempString.Printf(_T("%f"),resultMin);
+ interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA+2, tempString);
+
+ tempString.Printf(_T("%f"),resultMax);
+ interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA+3, tempString);
+
+ tempString.Printf(_T("%f"),resultAverage);
+ interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA+4, tempString);
+
+ tempString.Printf(_T("%f"),resultStandardeviation);
+ interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA+5, tempString);
+
+
+ } // for iContourGroup
+ } // for z
+
+ int iTitleGroup;
+ wxString tmpTitleString;
+ int tmpIntB;
+ for ( iTitleGroup=0 ; iTitleGroup<maxContourGroup ; iTitleGroup++ )
+ {
+ tmpIntB =_numberOfVariablesStatistics*iTitleGroup;
+ tmpTitleString.Printf(_T("%d-Size Data"),iTitleGroup);
+ interfMainPanel::getInstance()->setColLableInfoPanel(tmpIntB + 0, tmpTitleString);
+
+ interfMainPanel::getInstance()->setColLableInfoPanel(tmpIntB + 0, tmpTitleString );
+ interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 1, _T("Size Range") );
+ interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 2, _T("Min") );
+ interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 3, _T("Max") );
+ interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 4, _T("Average") );
+ interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 5, _T("St.Dev.") );
+ interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 6, _T(" ") );
+ }
+
+ interfMainPanel::getInstance()->setStringInfoPanel( _T("") );
+ delete contourextractdata;
+}
+
+void wxContourMainFrame::onSaveResults(std::string directory,std::string namefile, std::string filename, int typeContourGroup){
+ SaveValuesXYZ( directory , namefile, typeContourGroup );
+ SaveImageResult( directory , namefile, typeContourGroup);
+
+
+ FILE *pFile=fopen(filename.c_str(),"w+");
+
+ int sizeZ = _theViewPanel->GetImageDataSizeZ();
+
+ wxString tmpString;
+ int i,j,maxX,maxY=sizeZ;
+ maxX= interfMainPanel::getInstance()->getNumberColsInformationPanel();//this->_grid->GetNumberCols();
+
+ int iTitle,sizeTitle = (maxX / _numberOfVariablesStatistics);
+ for ( iTitle=0; iTitle<sizeTitle ; iTitle++)
+ {
+ fprintf(pFile,"-- \t %d-Size \t SizeRange \t Min \t Max \t Ave \t StDv \t" , iTitle,tmpString.c_str() );
+ }
+ fprintf(pFile,"\n" );
+
+
+
+ for ( j=0; j<maxY ; j++)
+ {
+ fprintf(pFile,"%d\t" , j );
+ for (i=0 ; i<maxX ; i++){
+ tmpString = interfMainPanel::getInstance()->getCellValue(j, i);//_grid->GetCellValue( j , i );
+ fprintf(pFile,"%s\t" , (const char *)(tmpString.mb_str()) );
+ } // for i
+ fprintf(pFile,"\n" );
+ } // for j
+
+ fclose(pFile);
+}
+
+void wxContourMainFrame::SaveValuesXYZ(std::string directory,std::string namefile,int typeContourGroup)
+{
+ wxBusyCursor wait;
+ ContourExtractData *contourextractdata = new ContourExtractData();
+ //int typeContourGroup = this->_radiolstboxContourGroup->GetSelection();
+ contourextractdata ->SetTypeOperation( typeContourGroup % 3 );
+
+ std::vector<manualContourModel*> lstManConMod;
+ std::vector<manualContourModel*> lstManConModTmp;
+ std::vector<manualContourModel*> lstManConModExp;
+ std::vector<double> pLstValue;
+ std::vector<double> pLstValuePosX;
+ std::vector<double> pLstValuePosY;
+ std::vector<double> pLstValuePosZ;
+
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+
+ vtkImageData *imagedata = _theViewPanel->getSceneManager()->GetImageData();
+ int sizeZ = _theViewPanel->getSceneManager()->GetImageDataSizeZ();
+ int z;
+ int ii,sizeLstContourThings;
+
+
+ int minZ,maxZ;
+ double totalZ;
+ double porcent;
+ wxString tmpString;
+ minZ = 0;// _mbarrange->GetStart();
+ maxZ = sizeZ;//_mbarrange->GetEnd();
+ totalZ = maxZ-minZ+1;
+
+ contourextractdata->SetImage( imagedata);
+
+// For each slice..
+ for ( z=0 ; z<sizeZ ; z++)
+ {
+
+ porcent = 100.0* (z-minZ)/totalZ;
+
+ tmpString.Printf(_T("Saving Values"));
+ tmpString.Printf(_T(" %d %c %d/%d %d"), (int)porcent , 37 , z-minZ+1, (int)totalZ ,z);
+ interfMainPanel::getInstance()->setStringInfoPanel(tmpString);
+ //_staticTextInformation->SetLabel(tmpString);
+
+
+ //Extraction data from contours of each slice
+ contourextractdata->SetZtoBeAnalys( z);
+
+ tempVector[1]=z;
+ Instant instant(&tempVector);
+ std::vector<ContourThing**> lstContourThings = kernelManager->getOutlinesAtInstant(&instant);//this->_modelManager->getOutlinesAtInstant( &instant );
+ sizeLstContourThings = lstContourThings.size();
+
+ lstManConMod.clear();
+ for (ii=0 ; ii<sizeLstContourThings ; ii++)
+ {
+ ContourThing **contourthing = lstContourThings[ii];
+ lstManConMod.push_back( (*contourthing)->getModel() );
+ }
+ lstManConModExp = kernelManager->ExploseEachModel( lstManConMod );
+
+
+//EED004
+
+ int iContourGroup,sizeContourGroup;
+ if (typeContourGroup==3) // contour separete
+ {
+ sizeContourGroup=lstManConModExp.size();
+ } else { // contour AND OR XOR
+ sizeContourGroup=1;
+ }
+
+ for( iContourGroup=0 ; iContourGroup<sizeContourGroup ; iContourGroup++ ){
+ lstManConModTmp.clear();
+ if (typeContourGroup==3) // contour separete
+ {
+ lstManConModTmp.push_back( lstManConModExp[iContourGroup]);
+ } else { // contour AND OR XOR
+ lstManConModTmp = lstManConModExp;
+ }
+
+ contourextractdata->SetLstManualContourModel( lstManConModTmp );
+
+ pLstValue.clear();
+ pLstValuePosX.clear();
+ pLstValuePosY.clear();
+ pLstValuePosZ.clear();
+ contourextractdata->GetValuesInsideCrown( &pLstValue,
+ &pLstValuePosX,
+ &pLstValuePosY,
+ &pLstValuePosZ);
+
+ std::string temp = directory + "/" + namefile + "-slice";
+ temp = temp + kernelManager->intToString(z) + "-cont" + kernelManager->intToString(iContourGroup);
+ temp = temp + ".txt";
+
+ wxString filename;
+ /*filename.Printf(_T("%s"),directory.c_str());
+ filename.append(_T("\\"));
+ filename.append(_T("%s"),namefile.c_str());
+ filename.append(_T("-slice"));
+ filename.append(_T("%d"),z);
+ filename.append(_T("-cont"));
+ filename.append(_T("%d"),iContourGroup);
+ filename.append(_T(".txt"));*/
+ filename.Printf(temp.c_str());
+ FILE *pFile=fopen((const char *)filename.mb_str(),"w+");
+ fprintf(pFile,"value \t x \t y \t z\n" );
+ int iLstValue,sizeLstValue=pLstValue.size();
+ for (iLstValue=0 ; iLstValue<sizeLstValue ; iLstValue++ )
+ {
+ fprintf(pFile,"%f\t %f\t %f\t %f\n", (float)pLstValue[iLstValue] , (float)pLstValuePosX[iLstValue], (float)pLstValuePosY[iLstValue], (float)z );
+ }
+ fclose(pFile);
+ } // for iContourGroup
+ } // for z
+ interfMainPanel::getInstance()->setStringInfoPanel(_T(""));
+ //_staticTextInformation->SetLabel( _T("") );
+ delete contourextractdata;
+}
+
+void wxContourMainFrame::SaveImageResult(std::string directory,std::string namefile, int typeContourGroup)
+{
+ wxBusyCursor wait;
+ ContourExtractData *contourextractdata = new ContourExtractData( true );
+ //int typeContourGroup = this->_radiolstboxContourGroup->GetSelection();
+ if (typeContourGroup==3)
+ {
+ typeContourGroup=1;
+ }
+ contourextractdata ->SetTypeOperation( typeContourGroup % 3 );
+
+ std::vector<manualContourModel*> lstManConMod;
+ std::vector<manualContourModel*> lstManConModTmp;
+ std::vector<manualContourModel*> lstManConModExp;
+
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+
+ vtkImageData *imagedata = _theViewPanel->getImageData();
+ int sizeZ = _theViewPanel->GetImageDataSizeZ();
+ int z;
+ int ii,sizeLstContourThings;
+
+
+ int minZ,maxZ;
+ double totalZ;
+ double porcent;
+
+ wxString tmpString;
+
+ minZ = 0;// _mbarrange->GetStart();
+ maxZ = sizeZ;//_mbarrange->GetEnd();
+ totalZ = maxZ-minZ+1;
+
+ contourextractdata->SetImage( imagedata);
+
+// For each slice..
+ for ( z=0 ; z<sizeZ ; z++)
+ {
+
+ porcent = 100.0* (z-minZ)/totalZ;
+ tmpString.Printf(_T("Saving Values"));
+ tmpString.Printf(_T("%d %c %d/%d %d"), (int)porcent , 37 , z-minZ+1, (int)totalZ ,z);
+ interfMainPanel::getInstance()->setStringInfoPanel(tmpString);
+
+ //Extraction data from contours of each slice
+ contourextractdata->SetZtoBeAnalys( z);
+
+ tempVector[1]=z;
+ Instant instant(&tempVector);
+ std::vector<ContourThing**> lstContourThings = kernelManager->getOutlinesAtInstant( &instant );
+ sizeLstContourThings = lstContourThings.size();
+
+ lstManConMod.clear();
+ for (ii=0 ; ii<sizeLstContourThings ; ii++)
+ {
+ ContourThing **contourthing = lstContourThings[ii];
+ lstManConMod.push_back( (*contourthing)->getModel() );
+ }
+ lstManConModExp = kernelManager->ExploseEachModel( lstManConMod );
+
+
+ int iContourGroup,sizeContourGroup;
+ if (typeContourGroup==3) // contour separete
+ {
+ sizeContourGroup=lstManConModExp.size();
+ } else { // contour AND OR XOR
+ sizeContourGroup=1;
+ }
+
+ for( iContourGroup=0 ; iContourGroup<sizeContourGroup ; iContourGroup++ ){
+ lstManConModTmp.clear();
+ if (typeContourGroup==3) // contour separete
+ {
+ lstManConModTmp.push_back( lstManConModExp[iContourGroup]);
+ } else { // contour AND OR XOR
+ lstManConModTmp = lstManConModExp;
+ }
+
+ contourextractdata->SetLstManualContourModel( lstManConModTmp );
+
+
+// for (ii=0 ; ii<sizeLstContourThings ; ii++)
+// {
+// ContourThing **contourthing = lstContourThings[ii];
+// lstManConMod.push_back( (*contourthing)->getModel() );
+// }
+// contourextractdata->SetLstManualContourModel( lstManConMod );
+
+ contourextractdata->CalculateImageResult(); // with actual Z
+
+ } // for iContourGroup
+ } // for z
+
+ std::string temp = directory + "/" + namefile + "-Value.mhd";
+
+ wxString filename;
+ filename.Printf(_T(temp.c_str()));
+ //filename.Printf(_T("%s\\%s-Value.mhd",directory.c_str(),namefile.c_str(),z);
+ /*filename.Printf(_T("%s"),directory.c_str());
+ filename.append(_T("\\"));
+ filename.append(_T("%s"),namefile.c_str());
+ filename.append(_T("-Value.mhd"));*/
+
+// Image Value
+ vtkMetaImageWriter *writerValueImage = vtkMetaImageWriter::New( );
+ writerValueImage->SetInput( contourextractdata->GetVtkImageValueResult() );
+ writerValueImage->SetFileName( (const char *)filename.mb_str() );
+ writerValueImage->SetFileDimensionality( 3 );
+ writerValueImage->Write( );
+
+// Image Mask
+ // filename.Printf("%s\\%s-Mask.mhd",directory.c_str(),namefile.c_str(),z);
+ temp = directory + "/" + namefile + "-Mask.mhd";
+
+ filename.Printf(_T(temp.c_str()));
+
+ /*filename.Printf(_T("%s"),directory.c_str());
+ filename.append(_T("\\"));
+ filename.append(_T("%s"),namefile.c_str());
+ filename.append(_T("-Mask.mhd"));*/
+
+ vtkMetaImageWriter *writerMaskImage = vtkMetaImageWriter::New( );
+ writerMaskImage->SetInput( contourextractdata->GetVtkImageMaskResult() );
+ writerMaskImage->SetFileName( (const char *)filename.mb_str() );
+ writerMaskImage->SetFileDimensionality( 3 );
+ writerMaskImage->Write( );
+
+ interfMainPanel::getInstance()->setStringInfoPanel( _T("") );
+ delete contourextractdata;
+}
+
+void wxContourMainFrame::onChangeInstantInstantPanel(std::string name,int value, int minshow, int maxshow){
+ if( name.compare( _theViewPanel->getVerticalConceptName() ) == 0){
+ _theViewPanel->setActualVertical( value);
+ }
+ else if( name.compare( _theViewPanel->getHorizontalConceptName() ) == 0|| _instantPanel->getIfConceptCheckedAt( name, 0 ) ) {
+ _theViewPanel->setHorizontalConcept( name, minshow, maxshow, minshow, maxshow, value);
+ }
+
+ changeInstant();
+}
git://git.creatis.insa-lyon.fr / creaContours.git / blobdiff