X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=lib%2FInterface_ManagerContour_NDimensions%2FwxContourMainFrame.cxx;h=30cafdf91220e9193cbf66038d781874208c3a4a;hb=022ea4ddf8cd8a991cc9060f3c13e51af6bc226e;hp=d277065a803cf8c21ad2946d105a2f05a1e6b2ce;hpb=192dfdf774a06066eff90e9c50916723c8592706;p=creaContours.git diff --git a/lib/Interface_ManagerContour_NDimensions/wxContourMainFrame.cxx b/lib/Interface_ManagerContour_NDimensions/wxContourMainFrame.cxx index d277065..30cafdf 100644 --- a/lib/Interface_ManagerContour_NDimensions/wxContourMainFrame.cxx +++ b/lib/Interface_ManagerContour_NDimensions/wxContourMainFrame.cxx @@ -3,6 +3,8 @@ //---------------------------------------------------------------------------------------------------------------- #include "wxContourMainFrame.h" + + //---------------------------------------------------------------------------------------------------------------- // Includes //---------------------------------------------------------------------------------------------------------------- @@ -13,9 +15,11 @@ #include "ConceptDataWrap.h" #include -#include "ImageSourceThing.h" -#include "vtkImageData.h" - +//#include "ImageSourceThing.h" +//#include "wxContour_ActionCommandsID.h" +//#include "OutlineModelBuilder.h" +//#include "wxContourEventHandler.h" +#include //---------------------------------------------------------------------------------------------------------------- // Class implementation @@ -25,6 +29,9 @@ //------------------------------------------------------------------------------------------------------------ // 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) @@ -34,35 +41,156 @@ 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; + + _refLineControl = NULL; + _refLineModel = NULL; + _refLineView = NULL; + _imageReslicer = NULL; + _thresholdTable = NULL; + _thresholdMapper = NULL; + _thresholdActor = NULL; + _actorPresent = false; + + // 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 images, long style,std::string datadir) + : wxPanel(parent, id, pos, size, style) + { + m_mgr.SetManagedWindow(this); + _creatingContoursActive = false; + _theViewPanel = NULL; + _instantPanel = NULL; - _buttonsBar = NULL; - _gridPanel = NULL; - _drawToolsPanel = NULL; - _operationsToolsPanel = NULL; - _autoFormsPanel = NULL; - _standardToolsPanel = NULL; - _editionToolsPanel = NULL; - _listViewPanel = NULL; - _sceneManager = NULL; - _actualInstant = NULL; + _refLineControl = NULL; + _refLineModel = NULL; + _refLineView = NULL; + _imageReslicer = NULL; + _thresholdTable = NULL; + _thresholdMapper = NULL; + _thresholdActor = NULL; + _actorPresent = false; // 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; + _numberOfVariablesStatistics = 7; + + _datadir = datadir; + + + inredo = 0; + inundo = 0; + + _pannew = interfMainPanel::getInstance(this,datadir+"/data/Icons");//, eventHandler); + _performingOperation = new PerformingOperation(); + + if(images.size() > 0) + { + this->setVectImages(images); + } + +} + +void wxContourMainFrame::setVectImages( std::vector images ){ + + #if defined(__GNUC__) + std::string str_home(getenv("HOME")); + #elif defined(_WIN32) + std::string str_home(getenv("USERPROFILE")); + #endif + std::string strCreaContourDataTmp = str_home + "/.creaContourDataTemp/"; + + std::vector conceptNameVect; + std::vector conceptSizeVect; + + notebook = this->createNotebook(); + + + kernelManager = new KernelManagerContour( images , _datadir+"/data/" , strCreaContourDataTmp ); + + + _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() ); + + this->configurePanels( ); + +} + + + wxContourMainFrame* wxContourMainFrame :: getInstance(wxWindow* parent, wxWindowID id,const wxString& title,const wxPoint& pos,const wxSize& size,std::vector images, long style,std::string datadir ){ + if(instance == NULL){ + instance = new wxContourMainFrame(parent, id, title, pos, size, images, style,datadir); + } + return instance; + } + + std::vector wxContourMainFrame ::getVectImages() + { + return kernelManager->getVectImages(); + } + + wxContourMainFrame* wxContourMainFrame :: getInstance() + { + return instance; + } + + void wxContourMainFrame :: resetInstance() + { + instance->Destroy(); } wxContourMainFrame :: ~wxContourMainFrame() { - m_mgr.UnInit(); - //El problema al cerrar la aplicacion puede estar asociado - //a que wxAUINotebook esta en la aplicacion - //principal (wxContourGUIExample)tambien -//EED???? delete _theViewPanel; -//EED???? delete _instantPanel; -//EED???? delete _buttonsBar; -//EED???? delete _actualInstant; -//EED???? delete _sceneManager; + + _pannew->Close(); + interfMainPanel::resetInstance(); + delete kernelManager; + instance = NULL; + //_pannew->Destroy(); + //delete _pannew; + + m_mgr.UnInit(); + //delete m_mgr; + + //El problema al cerrar la aplicacion puede estar asociado + //a que wxAUINotebook esta en la aplicacion + //principal (wxContourGUIExample)tambien + //EED???? delete _theViewPanel; + //EED???? delete _instantPanel; + //EED???? delete _buttonsBar; + //EED???? delete _actualInstant; + //EED???? delete _sceneManager; } @@ -82,45 +210,44 @@ //------------------------------------------------------------------------------------------------------------ // Creational and initialization methods //------------------------------------------------------------------------------------------------------------ - bool wxContourMainFrame :: configurePanels(wxAuiNotebook* theNoteBook) + bool wxContourMainFrame :: configurePanels( ) { bool configured = _theViewPanel!=NULL; configured &= _theViewPanel!=NULL; if( _theViewPanel!=NULL ) { - theNoteBook->AddPage( _theViewPanel, wxT(" View ") ); + notebook->AddPage( _theViewPanel, wxT(" View ") ); m_mgr.Update(); } if( configured ) { - theNoteBook->AddPage( _instantPanel, wxT("Instant Page") ); + notebook->AddPage( _instantPanel, wxT("Instant Page") ); m_mgr.Update(); } - m_mgr.AddPane(theNoteBook, wxAuiPaneInfo().Name(wxT("notebook_content")).CenterPane().PaneBorder(false)); + m_mgr.AddPane(notebook, wxAuiPaneInfo().Name(wxT("notebook_content")).CenterPane().PaneBorder(false)); m_mgr.Update(); - configured &= _buttonsBar!=NULL; - if( _buttonsBar!=NULL ) - { - m_mgr.AddPane(_buttonsBar, wxAuiPaneInfo(). - Name(wxT("TB")).Caption(wxT("Buttons Bar")). - ToolbarPane().Top(). - LeftDockable( ).RightDockable( false ).CloseButton(false)); - m_mgr.Update(); - } - //CreateStatusBar(); - + SetMinSize(wxSize(300,300)); m_mgr.Update(); return configured; } - void wxContourMainFrame :: setNotebook( wxAuiNotebook * noteBook ) - { + bool wxContourMainFrame::addNewPanel(wxPanel* panel) + { + bool configured = panel!=NULL; + configured &= panel!=NULL; + + if( configured ) + { + notebook->AddPage( panel, wxT(" Viewer "), true ); + m_mgr.Update(); + } + return configured; } //------------------------------------------------------------------------------------------------------------ @@ -128,53 +255,2346 @@ //------------------------------------------------------------------------------------------------------------ - void wxContourMainFrame :: setViewPanel( wxContourViewPanel * theViewPanel ) - { - _theViewPanel = theViewPanel; - } - + void wxContourMainFrame :: setInstantChooserPanel( wxInstantChooserPanel * theInstantChooserPanel ) { _instantPanel = theInstantChooserPanel; } - void wxContourMainFrame :: setButtonsBar( wxContour_ButtonsBar * theButtonsBar ) +// void wxContourMainFrame :: setButtonsBar( wxContour_ButtonsBar * theButtonsBar ) +// { +// _buttonsBar = theButtonsBar; +// } + +// void wxContourMainFrame :: setGrid( wxContour_Grid * theGridPanel ) +// { +// _gridPanel = theGridPanel; +// } + +// void wxContourMainFrame :: setDrawToolsPanel( wxContour_DrawToolsPanel * theDrawToolsPanel ) +// { +// _drawToolsPanel = theDrawToolsPanel; +// } + +// void wxContourMainFrame :: setOperationsToolsPanel( wxContour_OperationsToolsPanel * theOperationsToolsPanel ) +// { +// _operationsToolsPanel = theOperationsToolsPanel; +// } + +// void wxContourMainFrame :: setAutomaticFormsPanel( wxContour_AutomaticFormsToolsPanel * theAutoFormsPanel ) +// { +// _autoFormsPanel = theAutoFormsPanel; +// } + +// void wxContourMainFrame :: setStandardToolsPanel( wxContour_StandardToolsPanel * theStandardToolsPanel ) +// { +// _standardToolsPanel= theStandardToolsPanel; +// } + +// void wxContourMainFrame :: setEditionToolsPanel( wxContour_EdtionToolsPanel * theEditionToolsPanel ) +// { +// _editionToolsPanel = theEditionToolsPanel; +// } + +// void wxContourMainFrame :: setListViewPanel( wxContour_ListViewPanel * theListViewPanel ) +// { +// _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::onCreateContourLine( ){ + //JCP 20-10-08 Undo redo implementation + saveState(); + //JCP 20-10-08 Undo redo implementation + createContour( 6 ); +} + +//------------------------------------------------------------------------------------------------------------ + +void wxContourMainFrame :: onCreateContourBullEye(wxPanel* panel ) +{ + //Creating the manualContourModel and including in the model + manualContourModel * manModelContour = factoryManualContourModel(panel ); + + std::vector instantVector; + _instantPanel->getInstant( instantVector ); + std::string theName = kernelManager->createOutline(manModelContour, instantVector); + + /*std::vector instantVector; + _instantPanel->getInstant( instantVector ); + std::string theName; + theName= _modelManager->createOutline( manModelContour, instantVector );*/ + bool addedModel = theName.compare("") != 0;//?? + + if( addedModel ) { - _buttonsBar = theButtonsBar; + 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); + - void wxContourMainFrame :: setGrid( wxContour_Grid * theGridPanel ) + std::vector instantVector; + _instantPanel->getInstant( instantVector ); + std::string theName = kernelManager->createOutline(manModelContour, instantVector); + + /*std::vector instantVector; + _instantPanel->getInstant( instantVector ); + std::string theName; + theName= _modelManager->createOutline( manModelContour, instantVector );*/ + bool addedModel = theName.compare("") != 0;//?? + if( addedModel ) { - _gridPanel = theGridPanel; - } + 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 ; iCrownGetNumberOfSections(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 ; iSectorGetAngOfCrownSection(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 lstKeyNameToBeErase; + lstKeyNameToBeErase = _theViewPanel->getSceneManager()->getSelectedObjects(); + deleteContours( lstKeyNameToBeErase ); +/*JCP 19 - 11 - 08 + int i,size=_sceneManager->getSelectedObjects().size(); + for(i=0;igetSelectedObjects()[i]; + int ispartofstaticlist = this->_modelManager->IsPartOfStaticList( keyName ); + if ( ispartofstaticlist>=0 ) + { + std::vector tempVector; + _instantPanel->getInstant( tempVector ); + Instant instant(&tempVector); + this->_modelManager->ChangeContourOfList(keyName, &instant); + } + } + + std::vector lstKeyName; + std::vector lstKeyNameActualSlice; + std::vector lstKeyNameToBeErase; + + lstKeyNameToBeErase = _sceneManager->getSelectedObjects(); + lstKeyNameActualSlice = _sceneManager->GetlstContoursNameActualSlice(); + int k,kSize=lstKeyNameToBeErase.size(); + int j,jSize=lstKeyNameActualSlice.size(); + bool ok; + for (k=0;k keyNamesVector ) +{ + int i,size=keyNamesVector.size(); + for (i=0;igetSceneManager()->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)_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 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 lstContourThings = this->_modelManager->getOutlinesAtInstant( &instant ); + + sizeLstContourThings = lstContourThings.size(); + for (ii=0 ; iigetName() ); + } //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 instantVect; + _instantPanel->getInstant( instantVect ); +// Instant * theInstant = new Instant ( &instantVect ); + + //Setting the actual instant + //_actualInstant = theInstant; + + kernelManager->setInstant(instantVect); + //_modelManager->setInstant( _actualInstant ); + + onThresholdChange(); + updateInstantOutlines(); + updateInstantImageData(); + updateInstantAxes(); +} + + +void wxContourMainFrame :: updateInstantOutlines() +{ + _theViewPanel->removeSceneContours(); + _theViewPanel->addNameWrapperToScene(); + + //for( int i=0; igetSceneManager()->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 :: setOperationsToolsPanel( wxContour_OperationsToolsPanel * theOperationsToolsPanel ) - { - _operationsToolsPanel = theOperationsToolsPanel; +void wxContourMainFrame::updateInstantImageData() +{ + std::vector inst; + _instantPanel->getInstant(inst); + + vtkImageData* img = kernelManager->getImageAtInstant(inst); + if(img!=NULL){ + _theViewPanel->changeImage(img); + showAxis(false); + }else{ + int z = _instantPanel->getConceptDataOf("Axe Depth")->getActualValue(); + _theViewPanel->setImageSlice(z); } +} + +void wxContourMainFrame::updateInstantAxes() +{ +} + + +void wxContourMainFrame::onChangeDeep(int val){ + _instantPanel->setConceptValue( "Axe Depth", (int)val ); + changeInstant(); +} + + +void wxContourMainFrame::onCopy(){ + std::vector currentSelection = _theViewPanel->getSelectedObjects(); + + std::vector tempVector; + _instantPanel->getInstant( tempVector ); + _performingOperation->reset(); + _performingOperation->setStartCommand( COPY ); + _performingOperation->setStartOperationInstantVector( tempVector ); + _performingOperation->setKeyNamesOperationElems( currentSelection ); +} + +void wxContourMainFrame::onPaste(){ - void wxContourMainFrame :: setAutomaticFormsPanel( wxContour_AutomaticFormsToolsPanel * theAutoFormsPanel ) + + char theStartCommand = _performingOperation->getStartCommand(); + if ( theStartCommand == COPY ) { - _autoFormsPanel = theAutoFormsPanel; + //JCP 20-10-08 Undo redo implementation + saveState(); + //JCP 20-10-08 Undo redo implementation + std::vector tempVector; + _instantPanel->getInstant( tempVector ); + _performingOperation->setEndOperationInstantVector ( tempVector ); + std::vector elems = _performingOperation->getKeyNamesOperationElems(); + int i,size = elems.size(); + for( i=0; i0 ); + } + } +} +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 &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 ); +} + +///AD: 03-09 Copy the object and apply the given transformation +void wxContourMainFrame :: createMirrorContourOf ( std::string anExistingKName, std::vector &instantNoTouchData, bool append ) +{ + std::string cloneName = kernelManager->createCopyContourOf( anExistingKName, instantNoTouchData ); + manualContourModel * manualModel = kernelManager->getOutlineByKeyName(cloneName); + + manualPoint * refPoint1 = _refLineModel->GetManualPoint(0); + manualPoint * refPoint2 = _refLineModel->GetManualPoint(1); + + double pnt1X = refPoint1->GetX(); + double pnt1Y = refPoint1->GetY(); +// double pnt1Z = refPoint1->GetZ(); + double pnt2X = refPoint2->GetX(); + double pnt2Y = refPoint2->GetY(); +// double pnt2Z = refPoint2->GetZ(); - void wxContourMainFrame :: setStandardToolsPanel( wxContour_StandardToolsPanel * theStandardToolsPanel ) + double angle = (atan2(pnt2Y - pnt1Y, pnt2X - pnt1X) * 180 / 3.1415926535897932384626433832795)+90; + vtkTransform *t = vtkTransform::New(); + + t->PostMultiply(); + t->Identity(); + t->Translate(-pnt1X, -pnt1Y, 0); + t->RotateZ(-angle); + t->Scale(-1,1,1); + t->RotateZ(angle); + t->Translate(pnt1X, pnt1Y, 0); + t->Update(); + + int i,size=manualModel->GetSizeLstPoints(); + for (i=0;iGetManualPoint(i); + float vecIn[3]; + float vecOut[3]; + vecIn[0]=mp->GetX(); + vecIn[1]=mp->GetY(); + vecIn[2]=mp->GetZ(); + t->TransformPoint( vecIn, vecOut ); + mp->SetPointX( vecOut[0] ); + mp->SetPointY( vecOut[1] ); + mp->SetPointZ( vecOut[2] ); + } + + _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); } - void wxContourMainFrame :: setEditionToolsPanel( wxContour_EdtionToolsPanel * theEditionToolsPanel ) + 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) { - _editionToolsPanel = theEditionToolsPanel; + std::string fileNameContourROI = (const char *)(dialog.GetPath().mb_str()); + kernelManager->setCurrentFileName(fileNameContourROI); + 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 ; iSaveThingName( 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 ; iSaveThingName( 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 instantVector; + int typeContourModel; + manualContourModel *manModelContour; + int typeView; + + int i; + for (i=0;ifactoryManualContourModel(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::onSegmentationOneSliceITK(wxString distance, wxString sigma, wxString alfa, wxString beta, wxString propagation, wxString iterations, wxString inflation) +{ + //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(); + SegmentationOneSliceITK( x,y,z,distance, sigma, alfa, beta, propagation, iterations, inflation); + RefreshInterface(); +} - void wxContourMainFrame :: setListViewPanel( wxContour_ListViewPanel * theListViewPanel ) +void wxContourMainFrame::SegmentationOneSliceITK(int x, int y, int z, wxString distanc, wxString sigm, wxString alf, wxString bet, wxString prop, wxString iter, wxString inflation) +{ + + int typeofcontour = 1; + //Image Data + vtkImageData *imagedata = getImageData(); + + //Tipo de pixeles a utilizar internamente en ITK + typedef float InternalPixelType; + const unsigned int Dimension = 2; + typedef itk::Image< InternalPixelType, Dimension > InternalImageType; + + //Tipo de pixeles de salida 1 + typedef unsigned char OutputPixelType; + typedef itk::Image< OutputPixelType, Dimension > OutputImageType; + + //Tipo de pixeles de salida 2 + typedef unsigned short OutputPixelType2; + typedef itk::Image< OutputPixelType2, Dimension > OutputImageType2; + + //DefiniciÛn del thresholder + typedef itk::BinaryThresholdImageFilter< + InternalImageType, + OutputImageType > ThresholdingFilterType; + + //DefiniciÛn del primer filtro de conversiÛn de pixeles + typedef itk::CastImageFilter< + OutputImageType, OutputImageType2 > CastFilterType; + + //DefiniciÛn del segundo tipo de conversiÛn de pixeles + typedef itk::CastImageFilter< + OutputImageType2, InternalImageType > CastFilterType2; + + //Tercer tipo de conversiÛn + typedef itk::RescaleIntensityImageFilter< + InternalImageType, + OutputImageType > CastFilterType3; + + //Cuarto tipo de conversiÛn + typedef itk::RescaleIntensityImageFilter< + OutputImageType, + OutputImageType > CastFilterType4; + + ThresholdingFilterType::Pointer thresholder = ThresholdingFilterType::New(); + + thresholder->SetLowerThreshold( 0.0 ); + thresholder->SetUpperThreshold( 128 ); + + thresholder->SetOutsideValue( 255 ); + thresholder->SetInsideValue( 0 ); + + //DefinciÛn de conexiÛnes entre VTK e ITK y el writer + typedef itk::VTKImageToImageFilter ConnectorType; + typedef itk::ImageToVTKImageFilter ConnectorType2; + typedef itk::ImageFileWriter< OutputImageType > WriterType; + + ConnectorType::Pointer connector= ConnectorType::New(); + ConnectorType2::Pointer connector2= ConnectorType2::New(); + + + CastFilterType::Pointer filter=CastFilterType::New(); + CastFilterType2::Pointer filter2=CastFilterType2::New(); + + connector->SetInput( imagedata ); + filter2->SetInput(connector->GetOutput()); + + typedef itk::CurvatureAnisotropicDiffusionImageFilter< + InternalImageType, + InternalImageType > SmoothingFilterType; + + SmoothingFilterType::Pointer smoothing = SmoothingFilterType::New(); + + typedef itk::GradientMagnitudeRecursiveGaussianImageFilter< + InternalImageType, + InternalImageType > GradientFilterType; + + typedef itk::SigmoidImageFilter< + InternalImageType, + InternalImageType > SigmoidFilterType; + + GradientFilterType::Pointer gradientMagnitude = GradientFilterType::New(); + + SigmoidFilterType::Pointer sigmoid = SigmoidFilterType::New(); + + sigmoid->SetOutputMinimum( 0.0 ); + sigmoid->SetOutputMaximum( 255.0 ); + + + typedef itk::FastMarchingImageFilter< + InternalImageType, + InternalImageType > FastMarchingFilterType; + + + FastMarchingFilterType::Pointer fastMarching = FastMarchingFilterType::New(); + + typedef itk::GeodesicActiveContourLevelSetImageFilter< InternalImageType, + InternalImageType > GeodesicActiveContourFilterType; + GeodesicActiveContourFilterType::Pointer geodesicActiveContour = + GeodesicActiveContourFilterType::New(); + + typedef itk::ZeroCrossingImageFilter< + InternalImageType, + InternalImageType > ZeroCrossingFilterType; +ZeroCrossingFilterType::Pointer zeroCrossing = + ZeroCrossingFilterType::New(); + +const double propagationScaling = atof( crea::wx2std(prop).c_str() ); + + geodesicActiveContour->SetPropagationScaling( propagationScaling ); + geodesicActiveContour->SetCurvatureScaling( 1.0 ); + geodesicActiveContour->SetAdvectionScaling( 1.0 ); + + geodesicActiveContour->SetMaximumRMSError( 0.02 ); + int it=atoi( crea::wx2std(iter).c_str() ); + geodesicActiveContour->SetNumberOfIterations( it ); + + smoothing->SetInput( filter2->GetOutput() ); + gradientMagnitude->SetInput( smoothing->GetOutput() ); + sigmoid->SetInput( gradientMagnitude->GetOutput() ); + fastMarching->SetInput( sigmoid->GetOutput() ); + geodesicActiveContour->SetInput( fastMarching->GetOutput() ); + geodesicActiveContour->SetFeatureImage( sigmoid->GetOutput() ); + + zeroCrossing->SetInput( geodesicActiveContour->GetOutput() ); + //thresholder->SetInput( zeroCrossing->GetOutput() ); + thresholder->SetInput( geodesicActiveContour->GetOutput() ); + connector2->SetInput( thresholder->GetOutput() ); + + + smoothing->SetTimeStep( 0.125 ); + smoothing->SetNumberOfIterations( 5 ); + smoothing->SetConductanceParameter( 9.0 ); + + + const double sigma = atof( crea::wx2std(sigm).c_str() ); + gradientMagnitude->SetSigma( sigma ); + + const double alpha = atof( crea::wx2std(alf).c_str() ); + const double beta = atof( crea::wx2std(bet).c_str() ); + + sigmoid->SetAlpha( alpha ); + sigmoid->SetBeta( beta ); + + typedef FastMarchingFilterType::NodeContainer NodeContainer; + typedef FastMarchingFilterType::NodeType NodeType; + + NodeContainer::Pointer seeds = NodeContainer::New(); + + InternalImageType::IndexType seedPosition; + seedPosition[0] = x; + seedPosition[1] = y; + + const double initialDistance = atof( crea::wx2std(distanc).c_str() ); + + NodeType node; + + const double seedValue = - initialDistance; + + node.SetValue( seedValue ); + node.SetIndex( seedPosition ); + + seeds->Initialize(); + seeds->InsertElement( 0, node ); + + fastMarching->SetTrialPoints( seeds ); + + fastMarching->SetSpeedConstant( 1.0 ); + + fastMarching->SetOutputSize( + connector->GetOutput()->GetBufferedRegion().GetSize() ); + + fastMarching->SetStoppingValue( 800 ); + try + { + + connector2->Update(); + vtkImageData *idata = connector2->GetOutput(); + + vtkMarchingContourFilter* cntVTK = vtkMarchingContourFilter::New( ); + + cntVTK->SetInput( idata ); + + cntVTK->SetNumberOfContours( 1 ); + cntVTK->SetValue( 0, 255 ); + cntVTK->Update( ); + cntVTK->UpdateInformation(); + + vtkCleanPolyData* cpd = vtkCleanPolyData::New( ); + cpd->SetInput( cntVTK->GetOutput( ) ); + cpd->Update( ); + cpd->UpdateInformation(); + + vtkPolyDataConnectivityFilter* conn = vtkPolyDataConnectivityFilter::New( ); + conn->SetExtractionModeToLargestRegion( ); + conn->SetInput( cpd->GetOutput( ) ); + conn->Update( ); + conn->UpdateInformation(); + + vtkStripper* vtkstripper = vtkStripper::New( ); + vtkstripper->SetInput( conn->GetOutput() ); + vtkstripper->Update(); + vtkstripper->UpdateInformation(); + + + vtkPolyData* polyDataResult = cntVTK->GetOutput(); + //std::cout<<"Points "<GetNumberOfPoints()<Update( ); + polyDataResult->UpdateInformation(); + +//EED + /* +ofstream myfile; +myfile.open ("C:/Creatis/example.txt"); +myfile << "\n"; +polyDataResult->Print(myfile); +myfile << "-------------------------------------\n"; +polyDataResult->GetLines()->Print(myfile); +myfile.close();*/ + + cntVTK -> Delete(); + cpd -> Delete(); + conn -> Delete(); + + +//--Calculating control points + + std::vector vecX; + std::vector vecY; + std::vector vecXo; + std::vector vecYo; + std::vector::iterator vecXoi; + std::vector::iterator vecYoi; + std::vector vecZ; + + std::vector vecCtrlPointX; + std::vector vecCtrlPointY; + std::vector vecCtrlPointZ; + + + double *p; + double xAct=0; + double yAct=0; + int ii,size=polyDataResult->GetNumberOfPoints(); +ofstream myfile; +myfile.open ("C:/Creatis/example2.txt"); + + size=polyDataResult->GetNumberOfPoints(); + for (ii=0;iiGetPoint(ii); + double x=p[0]; + double y=p[1]; + /*if(fabs(yAct-y)>20) + { + if((xAct-x)>1 || (xAct-x)<-1) + { + vecX.push_back( p[0] ); + vecY.push_back( p[1] ); + myfile <11) + { + vecXo.push_back(p[0]); + vecYo.push_back(p[1]); + } + else + { + vecX.push_back( p[0] ); + myfile <SetContour( &vecX , &vecY , &vecZ ); + +int method=2; + if (method==0){ + extractcontrolpoints2d->GetInitialControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ ); + } + else if (method==1){ + extractcontrolpoints2d->GetControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ ); + } + else if (method==2){ + extractcontrolpoints2d->SetSamplingControlPoints( 15 ); + extractcontrolpoints2d->GetSamplingControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ ); + } + //--Adding contour to the system + + std::vector 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 ; jAddPoint( 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 + + + + WriterType::Pointer writer = WriterType::New(); + CastFilterType3::Pointer caster = CastFilterType3::New(); + + caster->SetInput( gradientMagnitude->GetOutput() ); + writer->SetInput( caster->GetOutput() ); + writer->SetFileName("Gradient Magnitude.png"); + caster->SetOutputMinimum( 0 ); + caster->SetOutputMaximum( 255 ); + writer->Update(); + + CastFilterType3::Pointer caster2 = CastFilterType3::New(); + WriterType::Pointer writer2 = WriterType::New(); + + caster2->SetInput( sigmoid->GetOutput() ); + writer2->SetInput( caster2->GetOutput() ); + writer2->SetFileName("Sigmoid.png"); + caster2->SetOutputMinimum( 0 ); + caster2->SetOutputMaximum( 255 ); + writer2->Update(); + + CastFilterType3::Pointer caster3 = CastFilterType3::New(); + WriterType::Pointer writer3 = WriterType::New(); + + caster3->SetInput( fastMarching->GetOutput() ); + writer3->SetInput( caster3->GetOutput() ); + writer3->SetFileName("FastMarching.bmp"); + caster3->SetOutputMinimum( 0 ); + caster3->SetOutputMaximum( 255 ); + writer3->Update(); + + CastFilterType3::Pointer caster4 = CastFilterType3::New(); + WriterType::Pointer writer4 = WriterType::New(); + + caster4->SetInput( geodesicActiveContour->GetOutput() ); + writer4->SetInput( caster4->GetOutput() ); + writer4->SetFileName("GeodesicActiveContour.png"); + caster4->SetOutputMinimum( 0 ); + caster4->SetOutputMaximum( 255 ); + writer4->Update(); + + CastFilterType3::Pointer caster5 = CastFilterType3::New(); + WriterType::Pointer writer5 = WriterType::New(); + + caster5->SetInput( zeroCrossing->GetOutput() ); + writer5->SetInput( caster5->GetOutput() ); + writer5->SetFileName("ZeroCrossing.bmp"); + caster5->SetOutputMinimum( 0 ); + caster5->SetOutputMaximum( 255 ); + writer5->Update(); + } + catch( itk::ExceptionObject & excep ) + { + std::cerr << "Exception caught !" << std::endl; + std::cerr << excep << std::endl; + } +} + +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 vecX; + std::vector vecY; + std::vector vecZ; + + std::vector vecCtrlPointX; + std::vector vecCtrlPointY; + std::vector 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 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 ; jAddPoint( 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(); +} + + +//Creates a reference line to be used as the axis of the mirroring +void wxContourMainFrame::referenceLine() +{ + if (_refLineControl==NULL) + { + wxBusyCursor wait; + double spc[3]; + + vtkImageData *vtkimagedata = _theViewPanel->getImageData(); + vtkimagedata->GetSpacing(spc); + + wxVtkBaseView * viewer2D = _theViewPanel->getWxVtkBaseView(); + + _refLineControl = new manualLineControler(); + _refLineModel = new manualContourModelLine(); + _refLineView = new manualViewLine(); + _refLineView->SetModel( _refLineModel ); + _refLineView->SetWxVtkBaseView( viewer2D ); + _refLineView->SetRange( 2 ); + _refLineView->SetZ( 1200 ); + + _refLineView->SetSpacing(spc); + + _refLineView->SetColorNormalContour(0, 0, 1); + _refLineView->SetColorEditContour(0, 0.5, 0.5); + _refLineView->SetWidthLine(4); + + _refLineControl->SetModelView( _refLineModel , _refLineView ); + viewer2D->GetInteractorStyleBaseView()->AddInteractorStyleMaracas( _refLineControl ); + _refLineModel->SetCloseContour(false); + _refLineControl->CreateNewManualContour(); + +//EED?? double z = _refLineControl->GetZ(); + /* + _refLineControl->AddPoint(50,100,z); + _refLineControl->AddPoint(80,40,z); + _refLineControl->SetCompleteCreation(true); + + _refLineModel->AddPoint(50,100,z); + _refLineModel->AddPoint(80,40,z); + _refLineModel->UpdateSpline(); + + _refLineView->UpdateViewPoint(0); + _refLineView->UpdateViewPoint(1); + */ + + _refLineControl->SetActive(true); + _refLineView->RefreshContour(); + } +} + +//Hides the referenceLine +void wxContourMainFrame::refLineHide() +{ + if (_refLineControl!=NULL) + { + if (_refLineControl->GetActive()) + { + _refLineView->RemoveCompleteContourActor(); + _refLineControl->SetEditable(false); + _refLineControl->SetActive(false); + + RefreshInterface(); + } + } +} + +//Shows the referenceLine +void wxContourMainFrame::refLineShow() +{ + if (_refLineControl!=NULL) + { + if (_refLineControl->GetActive()==false) + { + wxVtkBaseView * viewer2D = _theViewPanel->getWxVtkBaseView(); + + _refLineView->SetModel( _refLineModel ); + _refLineView->SetWxVtkBaseView( viewer2D ); + _refLineView->SetRange( 2 ); + _refLineView->SetZ( 1200 ); + + _refLineControl->SetModelView( _refLineModel , _refLineView ); + viewer2D->GetInteractorStyleBaseView()->AddInteractorStyleMaracas( _refLineControl ); + _refLineControl->CreateNewManualContour(); + _refLineControl->SetActive(true); + _refLineView->RefreshContour(); + + RefreshInterface(); + } + } +} + +void wxContourMainFrame::refLineChangeWidth(int width) +{ + _refLineView->SetWidthLine(width); + _refLineView->RefreshContour(); + + RefreshInterface(); +} + + +void wxContourMainFrame::onMirror() +{ + //AD:02-09 + std::vector currentSelection = _theViewPanel->getSelectedObjects(); + std::vector filterCurrentSelection; + + std::vector tempVector; + _instantPanel->getInstant( tempVector ); + _performingOperation->reset(); + _performingOperation->setStartCommand( COPY ); + _performingOperation->setStartOperationInstantVector( tempVector ); + _performingOperation->setKeyNamesOperationElems( currentSelection ); + + char theStartCommand = _performingOperation->getStartCommand(); + if ( theStartCommand == COPY ) + { + //JCP 20-10-08 Undo redo implementation + saveState(); + //JCP 20-10-08 Undo redo implementation + std::vector tempVector; + _instantPanel->getInstant( tempVector ); + _performingOperation->setEndOperationInstantVector ( tempVector ); + std::vector elems = _performingOperation->getKeyNamesOperationElems(); + int i,size = elems.size(); + for( i=0; i0 ); + } + } + + //deleteContour( _refName ); + //_refName = ""; +} + +void wxContourMainFrame::onThreshold() +{ + int z = _theViewPanel->GetZ(); + double range[2]; + + vtkImageData * img = getImageData(); + img->GetScalarRange(range); + + int minTot = floor (range[0]); + int maxTot = ceil (range[1]); + + double minMax[2]; + _pannew->onThresholdInstantChange(minMax); + int minVal = floor (minMax[0]); + int maxVal = floor (minMax[1]); + + if (!_actorPresent) + { + if (_imageReslicer==NULL) + { + _imageReslicer = vtkImageReslice::New(); + _imageReslicer->SetInput( img ); + _imageReslicer->SetInformationInput(img); + _imageReslicer->SetResliceAxesDirectionCosines(1,0,0, 0,1,0 ,0,0,1); + _imageReslicer->SetOutputDimensionality(2); + _imageReslicer->SetInterpolationModeToLinear(); + } + + _imageReslicer->SetResliceAxesOrigin(0,0,z); + + img = _imageReslicer->GetOutput(); + img->Update(); + img->UpdateInformation(); + + wxVtkBaseView * baseView = _theViewPanel->getWxVtkBaseView(); + + if (_thresholdTable==NULL) + { + //Lookup Table + _thresholdTable = vtkLookupTable::New(); + _thresholdTable->SetNumberOfTableValues(maxTot+1); + _thresholdTable->SetTableRange(range); + _thresholdTable->SetAlphaRange(0, 1); + _thresholdTable->SetValueRange(0, 1); + _thresholdTable->SetSaturationRange(0, 0); + _thresholdTable->SetRampToLinear( ); + } + + //Assign a fake color for the upper image, and set the white as transparent + int i; + for(i = minTot; i <= maxTot; i++) + { + if( i >= minVal && i <= maxVal ) + { + _thresholdTable->SetTableValue(i, 1.0, 0.0, 0.0, 1); + } + else if( i >= minTot && i < minVal ) + { + _thresholdTable->SetTableValue(i, 1.0, 1.0, 1.0, 0); //transparent + } + else if( i > maxVal && i < maxTot ) + { + _thresholdTable->SetTableValue(i, 1.0, 1.0, 1.0, 0); //transparent + } + else + { + _thresholdTable->SetTableValue(i, 1.0, 1.0, 1.0, 0); //transparent + } + } + _thresholdTable->Build( ); + + if (_thresholdMapper==NULL) + { + _thresholdMapper = vtkImageMapToColors::New( ); + } + + _thresholdMapper->SetLookupTable( _thresholdTable ); + _thresholdMapper->SetInput( img ); + + if (_thresholdActor==NULL) + { + _thresholdActor = vtkImageActor::New( ); + _thresholdActor->SetOpacity( 0.6 ); + _thresholdActor->InterpolateOn( ); + _thresholdActor->SetPosition( 0,0, 900-1 ); + } + + _thresholdActor->SetInput( _thresholdMapper->GetOutput() ); + + baseView->GetRenderer()->AddActor( _thresholdActor ); + _actorPresent = true; + } + + else + { + _imageReslicer->SetResliceAxesOrigin(0,0,z); + img = _imageReslicer->GetOutput(); + img->Update(); + img->UpdateInformation(); + + //Assign a fake color for the upper image, and set the white as transparent + int i; + for(i = minTot; i <= maxTot; i++) + { + if( i >= minVal && i <= maxVal ) + { + _thresholdTable->SetTableValue(i, 1.0, 0.0, 0.0, 1); + } + else if( i >= minTot && i < minVal ) + { + _thresholdTable->SetTableValue(i, 1.0, 1.0, 1.0, 0); //transparent + } + else if( i > maxVal && i < maxTot ) + { + _thresholdTable->SetTableValue(i, 1.0, 1.0, 1.0, 0); //transparent + } + else + { + _thresholdTable->SetTableValue(i, 1.0, 1.0, 1.0, 0); //transparent + } + } + + _thresholdTable->Build( ); + _thresholdMapper->SetLookupTable( _thresholdTable ); + _thresholdMapper->SetInput( img ); + _thresholdActor->SetInput( _thresholdMapper->GetOutput() ); + } + /* + vtkImageViewer2* viewer = vtkImageViewer2::New(); + viewer->SetInput( upperImageActor->GetInput() ); + viewer->SetColorLevel((range[1]-range[0])/2); + viewer->SetColorWindow(range[1]); + viewer->GetRenderer()->AddActor( upperImageActor ); + viewer->Render(); + */ + _theViewPanel->RefreshInterface(); +} + + +void wxContourMainFrame::onThresholdChange() +{ + if (_actorPresent) + { + onThreshold(); + } +} + +void wxContourMainFrame::onThresholdInterpolation(bool interpolate) +{ + if (_thresholdActor!=NULL) + { + if (interpolate) + { + _thresholdActor->InterpolateOn( ); + } + + else + { + _thresholdActor->InterpolateOff( ); + } + + _theViewPanel->RefreshInterface(); + } +} + +void wxContourMainFrame::onThresholdChangeOpacity (int opacity) +{ + if (_actorPresent) + { + _thresholdActor->SetOpacity(opacity*0.1); + } + + _theViewPanel->RefreshInterface(); +} + +void wxContourMainFrame::onThresholdRemove() +{ + if (_actorPresent) + { + wxVtkBaseView * baseView = _theViewPanel->getWxVtkBaseView(); + baseView->GetRenderer()->RemoveActor( _thresholdActor ); + _actorPresent = false; + } + + _theViewPanel->RefreshInterface(); +} + +void wxContourMainFrame::showAxis(bool show) +{ + _theViewPanel->SetVisibleAxis(show); + _theViewPanel->Refresh(); +} + + +void wxContourMainFrame::onRigidPressed(){ + std::vector 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 tempVector; + _instantPanel->getInstant( tempVector ); + Instant instant(&tempVector); + + int i , size=currentSelection.size(); + for ( i=0 ; ichangeContourOfManager(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 vecX; + std::vector vecY; + std::vector vecZ; + _theViewPanel->GetPointsOfActualContour(&vecX , &vecY , &vecZ ); + + std::vector 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 vecCtrlPointX; + std::vector vecCtrlPointY; + std::vector vecCtrlPointZ; + double minZ,maxZ; + int z; + + std::vector 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& tempVector){ + +} + +std::vector wxContourMainFrame::getOutlinesName(int slide){ + std::vector 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 lstManConMod; + std::vector lstManConModTmp; + std::vector lstManConModExp; + std::vector pLstValue; + std::vector pLstValuePosX; + std::vector pLstValuePosY; + std::vector pLstValuePosZ; + + int resultSize; + int resultGrayRangeCount; + double resultMin; + double resultMax; + double resultAverage; + double resultStandardeviation; + + std::vector 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 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 lstContourThings = kernelManager->getOutlinesAtInstant( &instant ); + sizeLstContourThings = lstContourThings.size(); + + lstManConMod.clear(); + for (ii=0 ; iigetModel() ); + } + 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 ( maxContourGroupSetLstManualContourModel( 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 ; iTitleGroupsetColLableInfoPanel(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 ); + + vtkImageData* mask, *value; + this->getMaskValue(mask, value, typeContourGroup); + this->SaveImageResult( directory , namefile, mask, value); + + + 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; iTitlegetCellValue(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 lstManConMod; + std::vector lstManConModTmp; + std::vector lstManConModExp; + std::vector pLstValue; + std::vector pLstValuePosX; + std::vector pLstValuePosY; + std::vector pLstValuePosZ; + + std::vector 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 ; zsetStringInfoPanel(tmpString); + //_staticTextInformation->SetLabel(tmpString); + + + //Extraction data from contours of each slice + contourextractdata->SetZtoBeAnalys( z); + + tempVector[1]=z; + Instant instant(&tempVector); + std::vector lstContourThings = kernelManager->getOutlinesAtInstant(&instant);//this->_modelManager->getOutlinesAtInstant( &instant ); + sizeLstContourThings = lstContourThings.size(); + + lstManConMod.clear(); + for (ii=0 ; iigetModel() ); + } + 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 ; iContourGroupSetLstManualContourModel( 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"; + + // LG 14/01/09 : using crea + wxString filename = crea::std2wx(temp); + /*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 ; iLstValuesetStringInfoPanel(_T("")); + //_staticTextInformation->SetLabel( _T("") ); + delete contourextractdata; +} + +void wxContourMainFrame::getMaskValue(vtkImageData* mask,vtkImageData* value,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 lstManConMod; + std::vector lstManConModTmp; + std::vector lstManConModExp; + + std::vector 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 ; zsetStringInfoPanel(tmpString); + + //Extraction data from contours of each slice + contourextractdata->SetZtoBeAnalys( z); + + tempVector[1]=z; + Instant instant(&tempVector); + std::vector lstContourThings = kernelManager->getOutlinesAtInstant( &instant ); + sizeLstContourThings = lstContourThings.size(); + + lstManConMod.clear(); + for (ii=0 ; iigetModel() ); + } + 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 ; iContourGroupSetLstManualContourModel( lstManConModTmp ); + contourextractdata->CalculateImageResult(); // with actual Z + + } // for iContourGroup + } // for z + + value = contourextractdata->GetVtkImageValueResult(); + mask = contourextractdata->GetVtkImageMaskResult(); + delete contourextractdata; +} + +void wxContourMainFrame::SaveImageResult(std::string directory,std::string namefile, vtkImageData* mask,vtkImageData* value) +{ + + std::string temp = directory + "/" + namefile + "-Value.mhd"; + + wxString filename = crea::std2wx(temp); + // LG + // 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( value ); + 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"; + + // LG 14/01/09 : using crea + filename = crea::std2wx(temp); + // 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( mask ); + writerMaskImage->SetFileName( (const char *)filename.mb_str() ); + writerMaskImage->SetFileDimensionality( 3 ); + writerMaskImage->Write( ); + + interfMainPanel::getInstance()->setStringInfoPanel( _T("") ); + +} + + + +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(); +} + +void wxContourMainFrame::onSnakePressed(){ + std::vector vecX; + std::vector vecY; + std::vector vecZ; + _theViewPanel->GetPointsOfActualContour( &vecX , &vecY , &vecZ ); + + if (vecX.size()!=0){ + std::vector tempVector; + _instantPanel->getInstant( tempVector ); + int i,size=vecZ.size(); + int actualSlice = tempVector[1]; + for ( i=0 ; iShowModal(); + } // if + +} + +void wxContourMainFrame::saveFileWithContoursAutomatique(){ + std::string filename = kernelManager->getCurrentFileName(); + if(filename.compare("")!=0){ + saveFileWithContours(filename); + }else{ + onSave(); } +} +void wxContourMainFrame::ShowToolsPanel(bool show){ + _pannew->Show(show); +}