+/*# ---------------------------------------------------------------------
+#
+# Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image
+# pour la Sant�)
+# Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
+# Previous Authors : Laurent Guigues, Jean-Pierre Roux
+# CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
+#
+# This software is governed by the CeCILL-B license under French law and
+# abiding by the rules of distribution of free software. You can use,
+# modify and/ or redistribute the software under the terms of the CeCILL-B
+# license as circulated by CEA, CNRS and INRIA at the following URL
+# http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
+# or in the file LICENSE.txt.
+#
+# As a counterpart to the access to the source code and rights to copy,
+# modify and redistribute granted by the license, users are provided only
+# with a limited warranty and the software's author, the holder of the
+# economic rights, and the successive licensors have only limited
+# liability.
+#
+# The fact that you are presently reading this means that you have had
+# knowledge of the CeCILL-B license and that you accept its terms.
+# ------------------------------------------------------------------------ */
+
//----------------------------------------------------------------------------------------------------------------
// Class definition include
//----------------------------------------------------------------------------------------------------------------
// Constructors & Destructors
//------------------------------------------------------------------------------------------------------------
-wxContourMainFrame* wxContourMainFrame:: instance = NULL;
+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)
//: wxWindow(parent, id, pos, size, style)
// _modelManager = NULL;
_instantPanel = NULL;
// _buttonsBar = NULL;
-// _gridPanel = NULL;
+// _gridPanel = NULL;
// _drawToolsPanel = NULL;
// _operationsToolsPanel = NULL;
- //_autoFormsPanel = NULL;
+ //_autoFormsPanel = NULL;
// _standardToolsPanel = NULL;
// _editionToolsPanel = NULL;
// _listViewPanel = NULL;
// _sceneManager = NULL;
- //_actualInstant = NULL;
- _numberOfVariablesStatistics = 6+1;
+ //_actualInstant = NULL;
+ _numberOfVariablesStatistics= 6+1;
_refLineControl = NULL;
_refLineModel = NULL;
// set up default notebook style
// m_notebook_style =wxAUI_NB_TAB_SPLIT | wxAUI_NB_TAB_EXTERNAL_MOVE | wxNO_BORDER;
-// m_notebook_theme = 0;
+// m_notebook_theme = 0;
//wxContour_ActionCommandsID a;
-
+
_contourextractdata = NULL;
_viewMaskImage = NULL;
_viewMaskImagePanel = NULL;
_viewThresholdImage = NULL;
_viewThresholdImagePanel = NULL;
-
+ _viewColorLayerImagePanel = NULL;
+ _frameShowResultImages = NULL;
}
- wxContourMainFrame :: wxContourMainFrame(wxWindow* parent, wxWindowID id,const wxString& title,const wxPoint& pos,const wxSize& size,std::vector<vtkImageData*> images, long style,std::string datadir)
+ wxContourMainFrame::wxContourMainFrame(wxWindow* parent, wxWindowID id,const wxString& title,const wxPoint& pos,const wxSize& size,std::vector<vtkImageData*> images, long style,std::string datadir)
: wxPanel(parent, id, pos, size, style)
{
m_mgr.SetManagedWindow(this);
_contourGroup = 1;
_creatingContoursActive = false;
_theViewPanel = NULL;
-
_instantPanel = NULL;
_refLineControl = NULL;
_refLineModel = NULL;
_viewMaskImagePanel = NULL;
_viewThresholdImage = NULL;
_viewThresholdImagePanel = NULL;
-
+ _viewColorLayerImagePanel = NULL;
// set up default notebook style
- m_notebook_style =wxAUI_NB_TAB_SPLIT | wxAUI_NB_TAB_EXTERNAL_MOVE | wxNO_BORDER;
- m_notebook_theme = 0;
+ 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;
-
+ _numberOfVariablesStatistics= 7;
+ _datadir = datadir;
+ inredo = 0;
+ inundo = 0;
_pannew = interfMainPanel::getInstance(this,datadir+"/data/Icons");//, eventHandler);
- _performingOperation = new PerformingOperation();
-
+ _performingOperation = new PerformingOperation();
if(images.size() > 0)
{
this->setVectImages(images);
}
-
_contourextractdata = NULL;
}
void wxContourMainFrame::setVectImages(std::vector<vtkImageData*> imgs)
{
-
_images = imgs;
-
- #if defined(__GNUC__)
+ #if defined(_WIN32)
+ std::string str_home(getenv("USERPROFILE"));
+ #elif 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<std::string> conceptNameVect;
- std::vector<int> conceptSizeVect;
-
- notebook = this->createNotebook();
-
-
- kernelManager = new KernelManagerContour( imgs , _datadir+"/data/" , strCreaContourDataTmp );
-
-
- _instantPanel = new wxInstantChooserPanel( notebook, "Instant Chooser", true, false, "c" );
- _theViewPanel = new wxContourViewPanel( kernelManager->getSourceImage(), notebook );
-
+ std::string strCreaContourDataTmp = str_home + "/.creaContourDataTemp/";
+ std::vector<std::string> conceptNameVect;
+ std::vector<int> conceptSizeVect;
+ notebook = this->createNotebook();
+ kernelManager = new KernelManagerContour( imgs , _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<vtkImageData*> images, long style,std::string datadir ){
- if(instance == NULL){
- instance = new wxContourMainFrame(parent, id, title, pos, size, images, style,datadir);
+ wxContourMainFrame* wxContourMainFrame :: getInstance(wxWindow* parent, wxWindowID id,const wxString& title,const wxPoint& pos,const wxSize& size,std::vector<vtkImageData*> images, long style,std::string datadir )
+ {
+ if(instance == NULL)
+ {
+ instance=new wxContourMainFrame(parent, id, title, pos, size, images, style,datadir);
}
return instance;
}
- std::vector<vtkImageData*> wxContourMainFrame ::getVectImages()
+ std::vector<vtkImageData*> wxContourMainFrame::getVectImages()
{
return kernelManager->getVectImages();
}
- wxContourMainFrame* wxContourMainFrame :: getInstance()
+ wxContourMainFrame* wxContourMainFrame::getInstance()
{
- return instance;
+ return instance;
}
- void wxContourMainFrame :: resetInstance()
+ void wxContourMainFrame::resetInstance()
{
instance->Destroy();
}
- wxContourMainFrame :: ~wxContourMainFrame()
+ wxContourMainFrame::~wxContourMainFrame()
{
delete _contourextractdata;
deleteAllContours();
m_mgr.UnInit();
//delete m_mgr;
- //El problema al cerrar la aplicacion puede estar asociado
- //a que wxAUINotebook esta en la aplicacion
+ //El problema al cerrar la aplicacion puede estar asociado
+ //a que wxAUINotebook esta en la aplicacion
//principal (wxContourGUIExample)tambien
- //EED???? delete _theViewPanel;
+ //EED???? delete _theViewPanel;
//EED???? delete _instantPanel;
//EED???? delete _buttonsBar;
- //EED???? delete _actualInstant;
+ //EED???? delete _actualInstant;
//EED???? delete _sceneManager;
}
// Creational and initialization methods using WxAui
//------------------------------------------------------------------------------------------------------------
//
- wxAuiNotebook * wxContourMainFrame :: createNotebook()
+ wxAuiNotebook * wxContourMainFrame::createNotebook()
{
wxSize client_size = GetClientSize();
wxAuiNotebook* noteBook = new wxAuiNotebook(this, -1, wxPoint(client_size.x, client_size.y), wxSize(430,200), m_notebook_style);
wxBitmap page_bmp = wxArtProvider::GetBitmap(wxART_NORMAL_FILE, wxART_OTHER, wxSize(16,16));
return noteBook;
}
-
+
//------------------------------------------------------------------------------------------------------------
- // Creational and initialization methods
+ // Creational and initialization methods
//------------------------------------------------------------------------------------------------------------
- bool wxContourMainFrame :: configurePanels( )
+ bool wxContourMainFrame::configurePanels( )
{
bool configured = _theViewPanel!=NULL;
-
+
configured &= _theViewPanel!=NULL;
if( _theViewPanel!=NULL )
{
- notebook->AddPage( _theViewPanel, wxT(" View ") );
+ notebook->AddPage( _theViewPanel, wxT(" View ") );
m_mgr.Update();
}
-
-
if( configured )
{
notebook->AddPage( _instantPanel, wxT("Instant Page") );
m_mgr.Update();
}
-
m_mgr.AddPane(notebook, wxAuiPaneInfo().Name(wxT("notebook_content")).CenterPane().PaneBorder(false));
m_mgr.Update();
-
SetMinSize(wxSize(300,300));
m_mgr.Update();
return configured;
{
bool configured = panel!=NULL;
configured &= panel!=NULL;
-
+
if( configured )
{
notebook->AddPage( panel, wxT(" Viewer "), true );
//------------------------------------------------------------------------------------------------------------
// Attributes getters and setters
//------------------------------------------------------------------------------------------------------------
-
-
+
+
void wxContourMainFrame :: setInstantChooserPanel( wxInstantChooserPanel * theInstantChooserPanel )
{
- _instantPanel = theInstantChooserPanel;
+ _instantPanel = theInstantChooserPanel;
}
// void wxContourMainFrame :: setButtonsBar( wxContour_ButtonsBar * theButtonsBar )
// }
// void wxContourMainFrame :: setOperationsToolsPanel( wxContour_OperationsToolsPanel * theOperationsToolsPanel )
-// {
+// {
// _operationsToolsPanel = theOperationsToolsPanel;
// }
void wxContourMainFrame::onCreateContourSpline( ){
-
+
//JCP 20-10-08 Undo redo implementation
saveState();
//JCP 20-10-08 Undo redo implementation
createContour( 1 );
-
+
}
-void wxContourMainFrame::onCreateContourRectangle( ){
+
+void wxContourMainFrame::onCreateContourRectangle( )
+{
//JCP 20-10-08 Undo redo implementation
saveState();
- //JCP 20-10-08 Undo redo implementation
+ //JCP 20-10-08 Undo redo implementation
createContour( 2 );
}
-void wxContourMainFrame::onCreateContourCircle( ){
+
+void wxContourMainFrame::onCreateContourCircle( )
+{
//JCP 20-10-08 Undo redo implementation
saveState();
- //JCP 20-10-08 Undo redo implementation
+ //JCP 20-10-08 Undo redo implementation
createContour( 3 );
}
-void wxContourMainFrame::onCreateContourLine( ){
+void wxContourMainFrame::onCreateContourLine( )
+{
//JCP 20-10-08 Undo redo implementation
saveState();
- //JCP 20-10-08 Undo redo implementation
+ //JCP 20-10-08 Undo redo implementation
createContour( 6 );
}
// RaC 09-09 --------------------------------------
-void wxContourMainFrame::onCreateContourPoints( ){
+void wxContourMainFrame::onCreateContourPoints( )
+{
//JCP 20-10-08 Undo redo implementation
saveState();
- //JCP 20-10-08 Undo redo implementation
+ //JCP 20-10-08 Undo redo implementation
createContour( 7 );
}
// RaC 09-09 --------------------------------------
+// RaC 10-09 --------------------------------------
+void wxContourMainFrame::onCreateContourPolygon( )
+{
+ //JCP 20-10-08 Undo redo implementation
+ saveState();
+ //JCP 20-10-08 Undo redo implementation
+ createContour( 10 );
+}
+// RaC 10-09 --------------------------------------
+
//------------------------------------------------------------------------------------------------------------
void wxContourMainFrame :: onCreateContourBullEye(wxPanel* 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;
if( addedModel )
{
double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
- _theViewPanel->getSpacing(spc);
+ _theViewPanel->getSpacing(spc);
//Adding the manualContourControler to interface objects structure
- //Adding the manualViewContour 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 )
+
+void wxContourMainFrame::createContour( int typeContour )
{
//Creating the manualContourModel and including in the model
manualBaseModel * manModelContour = kernelManager->factoryManualContourModel(typeContour);
-
std::vector<int> instantVector;
_instantPanel->getInstant( instantVector );
+
+ std::vector<int> tempVector;
+ getInstantVector( tempVector );
+ manModelContour->SetLabel2( std::to_string(tempVector[1]) );
+
std::string theName = kernelManager->createOutline(manModelContour, instantVector);
-
/*std::vector<int> instantVector;
_instantPanel->getInstant( instantVector );
std::string theName;
if( addedModel )
{
double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
- _theViewPanel->getSpacing(spc);
+ _theViewPanel->getSpacing(spc);
//Adding the manualContourControler to interface objects structure
- //Adding the manualViewContour 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) ;
- }
-
+ } // if addedModel
}
+
manualBaseModel * wxContourMainFrame::factoryManualContourModel(wxPanel* panel){
manualContourModelBullEye *manModelContourBullEye = new manualContourModelBullEye();
for ( iSector=0 ; iSector<sizeSectors ; iSector++ )
{
ang = ((PanelBullEyeOptions*)panel)->GetAngOfCrownSection(iCrown,iSector);
- angDelta= ((PanelBullEyeOptions*)panel)->GetAngDeltaOfCrownSection(iCrown);
+ angDelta= ((PanelBullEyeOptions*)panel)->GetAngDeltaOfCrownSection(iCrown);
manModelContourBullEye->AddSector(radioA,radioB,ang,angDelta);
} // for iSector
} // for iCrown
} // if _panelBullEyeOptions
-
+
return manModelContour;
}
-void wxContourMainFrame :: saveState(){
-
+
+void wxContourMainFrame :: saveState()
+{
std::string temp = kernelManager->saveState();
- saveFileWithContours(temp);
+ saveFileWithContours(temp);
}
-void wxContourMainFrame::onDeleteContour(){
+void wxContourMainFrame::onDeleteContour()
+{
//JCP 20-10-08 Undo redo implementation
saveState();
//JCP 20-10-08 Undo redo implementation
for (j=0;j<jSize; j++)
{
if (lstKeyNameToBeErase[k]==lstKeyNameActualSlice[j])
- {
+ {
ok=true;
}
} // for j
}
}
-void wxContourMainFrame :: deleteContour( std::string theKeyName ){
+void wxContourMainFrame :: deleteContour( std::string theKeyName )
+{
/*
manualContourModel * cModel;
manualViewBaseContour * cViewer;
_theViewPanel->removeFromScene(theKeyName);
kernelManager->deleteCModel(theKeyName);
- //_theViewPanel->getSceneManager()->removeFromScene( theKeyName );
+ //_theViewPanel->getSceneManager()->removeFromScene( theKeyName );
//cViewer = conwrapviewControl->getViewer();
//_theViewPanel->getSceneManager()->removeWrap( theKeyName );
- //cControler* conwrapviewControl->getControler();
+ //cControler* conwrapviewControl->getControler();
// delete cModel;
// delete cViewer;
// delete cControler;
//JCP 21 - 11 - 08
}
-void wxContourMainFrame::onDeleteContoursActSlice(){
+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() );
+
+ std::vector<int> tempVector;
+ getInstantVector( tempVector );
+ deleteContours( getOutlinesName( tempVector[1] ) );
+// deleteContours( (std::vector<std::string>)_theViewPanel->getSceneManager()->GetlstContoursNameActualSlice() );
+
}
void wxContourMainFrame::onDeleteAllContours(){
//JCP 20-10-08 Undo redo implementation
//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()->removeSceneContours( );
_theViewPanel->getSceneManager()->removeAllOutlines();
- kernelManager->removeAllOutlines();
+ kernelManager->removeAllOutlines();
//JCP --08-09-2008
/*
if ( (minZ==0) && (maxZ==_mbarrangeDeleteAll->GetMax() ))
deleteContour( (*contourthing)->getName() );
} //for ii
}// for z
- } // if
+ } // if
JCP --08-09-2008 */
}
-void wxContourMainFrame::setConceptValue( std::string name, int value ){
+void wxContourMainFrame::setConceptValue( std::string name, int value )
+{
_instantPanel->setConceptValue(name, value);
}
-ConceptDataWrap* wxContourMainFrame::getLastConceptData(){
+ConceptDataWrap* wxContourMainFrame::getLastConceptData()
+{
return _instantPanel->getLastConceptData();
}
-bool wxContourMainFrame::getIfConceptCheckedAt( std::string name, int pos ){
+bool wxContourMainFrame::getIfConceptCheckedAt( std::string name, int pos )
+{
return _instantPanel->getIfConceptCheckedAt( name, pos );
}
vtkImageData * mask;
vtkImageData * value;
this->getMaskValue(&mask, &value, typeContourGroup, selection, minZ, maxZ);
-
+
std::vector<int> nTypeView;
nTypeView.push_back(5);
nTypeView.push_back(1);
nTypeView.push_back(2);
- nTypeView.push_back(0);
-
- wxFrame *frame = new wxFrame(this, -1,_T("Result image extracted.."),wxDefaultPosition,wxSize(600,600), wxDEFAULT_FRAME_STYLE|wxSTAY_ON_TOP);
- wxAuiManager *m_mgr_noteBookViewerResult = new wxAuiManager();
- m_mgr_noteBookViewerResult->SetManagedWindow(frame);
-
- wxAuiNotebook* noteBookViewerResult = new wxAuiNotebook(frame, -1, wxPoint(600, 600), wxSize(430,200), m_notebook_style);
- m_mgr_noteBookViewerResult->AddPane(noteBookViewerResult, wxAuiPaneInfo().Name(wxT("notebook_content")).CenterPane().PaneBorder(false));
+ nTypeView.push_back(0);
- wxPanel *panelViewer1 = new wxMaracas_N_ViewersWidget(noteBookViewerResult, value,&nTypeView);
- wxPanel *panelViewer2 = new wxMaracas_N_ViewersWidget(noteBookViewerResult, mask,&nTypeView);
-
+ if (_frameShowResultImages==NULL)
+ {
+// wxFrame *_frameShowResultImages = new wxFrame(this, -1,_T("Result image extracted.."),wxDefaultPosition,wxSize(600,600), wxDEFAULT_FRAME_STYLE|wxSTAY_ON_TOP);
+ _frameShowResultImages = new wxFrame(this, -1,_T("Result image extracted.."),wxDefaultPosition,wxSize(600,600),
+ wxFRAME_TOOL_WINDOW|wxSYSTEM_MENU | wxCAPTION | wxCLIP_CHILDREN |wxFRAME_FLOAT_ON_PARENT | wxRESIZE_BORDER );
- noteBookViewerResult->AddPage( panelViewer1, wxT("Image result") );
- noteBookViewerResult->AddPage( panelViewer2, wxT("Mask result") );
- m_mgr_noteBookViewerResult->Update();
- frame->Show();
+ wxAuiManager *m_mgr_noteBookViewerResult = new wxAuiManager();
+ m_mgr_noteBookViewerResult->SetManagedWindow(_frameShowResultImages);
+
+ wxAuiNotebook* noteBookViewerResult = new wxAuiNotebook(_frameShowResultImages, -1, wxPoint(600, 600), wxSize(430,200), m_notebook_style);
+ m_mgr_noteBookViewerResult->AddPane(noteBookViewerResult, wxAuiPaneInfo().Name(wxT("notebook_content")).CenterPane().PaneBorder(false));
+
+ wxPanel *panelViewer1 = new wxMaracas_N_ViewersWidget(noteBookViewerResult, value,&nTypeView);
+ wxPanel *panelViewer2 = new wxMaracas_N_ViewersWidget(noteBookViewerResult, mask,&nTypeView);
+
+
+ noteBookViewerResult->AddPage( panelViewer1, wxT("Image result") );
+ noteBookViewerResult->AddPage( panelViewer2, wxT("Mask result") );
+ m_mgr_noteBookViewerResult->Update();
+ _frameShowResultImages->Show();
+ } // if _frameShowResultImages
}
std::vector<int> instantVect;
_instantPanel->getInstant( instantVect );
int actualSlice = instantVect[1];
-
kernelManager->setInstant(instantVect);
-
// Refresh Mask image
- if(_viewMaskImage!=NULL){
- _viewMaskImage->SetZ(actualSlice);
+ if(_viewMaskImage!=NULL)
+ {
+ _viewMaskImage->SetZ(actualSlice);
if (_viewMaskImagePanel->IsVisible()==true)
{
vtkImageData *mask, *value;
getMaskValue(&mask,&value, _contourGroup , 0, -1, -1);
_viewMaskImage->onThreshold();
}
- }
-
+ } // if _viewMaskImage
// Refresh Threshold image
- if(_viewThresholdImage!=NULL){
- _viewThresholdImage->SetZ(actualSlice);
- if (_viewThresholdImagePanel->IsVisible()==true){
+ if(_viewThresholdImage!=NULL)
+ {
+ _viewThresholdImage->SetZ(actualSlice);
+ if (_viewThresholdImagePanel->IsVisible()==true)
+ {
_viewThresholdImage->onThreshold();
}
- }
-
+ } // if _viewThresholdImage
updateInstantOutlines();
updateInstantImageData();
updateInstantAxes();
-void wxContourMainFrame :: updateInstantOutlines()
+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(){
+int wxContourMainFrame::getNamesWrappingSize()
+{
return kernelManager->getNamesWrappingSize();
}
-std::string wxContourMainFrame::getNameWrapping(int i){
+
+std::string wxContourMainFrame::getNameWrapping(int i)
+{
return kernelManager->getNameWrapping(i);
}
_instantPanel->getInstant(inst);
vtkImageData* img = kernelManager->getImageAtInstant(inst);
- if(img!=NULL){
+ if(img!=NULL)
+ {
_theViewPanel->changeImage(img);
showAxis(false);
}else{
int z = _instantPanel->getConceptDataOf("Axe Depth")->getActualValue();
_theViewPanel->setImageSlice(z);
- }
+ } // if img
}
void wxContourMainFrame::updateInstantAxes()
void wxContourMainFrame::onChangeDeep(int val){
- _instantPanel->setConceptValue( "Axe Depth", (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->setKeyNamesOperationElems( currentSelection );
}
-void wxContourMainFrame::onPaste(){
-
-
+void wxContourMainFrame::onPaste()
+{
char theStartCommand = _performingOperation->getStartCommand();
if ( theStartCommand == COPY )
{
_instantPanel->getInstant( tempVector );
_performingOperation->setEndOperationInstantVector ( tempVector );
std::vector<std::string> elems = _performingOperation->getKeyNamesOperationElems();
- int i,size = elems.size();
+ int i,size = elems.size();
for( i=0; i<size; i++ )
- {
+ {
createCopyContourOf( elems[i], tempVector, i>0 );
- }
+ }
}
}
-void wxContourMainFrame::onUndo(){
+
+void wxContourMainFrame::onUndo()
+{
std::string filename;
if(kernelManager->onUndoSaveFile(filename)){
saveFileWithContours(filename);
if(kernelManager->onRedo(filename)){
loadState(filename);
}
-
+
}
void wxContourMainFrame :: createCopyContourOf ( std::string anExistingKName, std::vector<int> &instantNoTouchData, bool append )
{
mp->SetPointX( vecOut[0] );
mp->SetPointY( vecOut[1] );
mp->SetPointZ( vecOut[2] );
- }
+ } // for i
_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.2 || 1.0.1 || 1.0.0
-
- deleteAllContours();
-
- loadContours(pFile, false);
- loadContours(pFile, true);
-
- fclose(pFile);
-}
-
-void wxContourMainFrame ::loadContours( FILE *pFile, bool staticContour )
+void wxContourMainFrame ::loadState(std::string filename)
{
- char tmp[255];
-
- fscanf(pFile,"%s",tmp); // ImageDimensions
- fscanf(pFile,"%s",tmp); // X
- fscanf(pFile,"%s",tmp); // Y
- fscanf(pFile,"%s",tmp); // Z
-
- fscanf(pFile,"%s",tmp); // ImageSpacing
- fscanf(pFile,"%s",tmp); // X
- fscanf(pFile,"%s",tmp); // Y
- fscanf(pFile,"%s",tmp); // Z
-
- fscanf(pFile,"%s",tmp); // NumberOfContours
- fscanf(pFile,"%s",tmp); // ##
- int numberOfContours = atoi(tmp);
-
- std::vector<int> instantVector;
- int typeContourModel;
- manualBaseModel *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);
-
- 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
+ deleteAllContours();
+ onLoadContours(filename,false);
}
void wxContourMainFrame::onLoad()
{
- char tmp[255];
- char tmpD[255];
std::string fileNameContourROI = GetFileLocation();
-
//CMRU 03-09-09-----------------------------------------------------------------------------------------------
if(GetFileLocation().empty())
{
//------------------------------------------------------------------------------------------------------------
+//EED 2017-09-16 Migration wxWidgets 2.8 to 3.0
+#if wxMAJOR_VERSION <= 2
wxFileDialog dialog(NULL, _T("Choose a file"), _T(""), _T(""), _T("*.roi"), wxOPEN );
+#else
+ wxFileDialog dialog(NULL, _T("Choose a file"), _T(""), _T(""), _T("*.roi"), wxFD_OPEN );
+#endif
if (dialog.ShowModal() == wxID_OK)
{
fileNameContourROI = (const char *)(dialog.GetPath().mb_str());
- }
- }
+ } // if dialog
+ } // if FileLocation
+ onLoadContours(fileNameContourROI,true);
+}
- FILE *pFile =fopen(fileNameContourROI.c_str(),"r+");
+void wxContourMainFrame::SetZForAllContours(int pz)
+{
+ //-- Normal Contours
+ std::vector< std::string > lstNameThings;
+ int i,sizeLstNameThings;
+ int ii,sizeLstPoints;
+ lstNameThings = kernelManager->GetLstNameThings();
+ sizeLstNameThings = lstNameThings.size();
+ for (i=0 ; i<sizeLstNameThings ; i++)
+ {
+printf("EED wxContourMainFrame::SetZForAllContours contour=%d \n", i );
+ manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(lstNameThings[i]);
+ sizeLstPoints = manualModel->GetSizeLstPoints();
+ for (ii=0 ; ii<sizeLstPoints ; ii++)
+ {
+ manualModel->GetManualPoint(ii)->SetPointZ(-900);
+ }// for ii list of points
+ }// for i list of Things
+ //-- Static Contours
+ lstNameThings = kernelManager->GetLstNameThingsStatic();
+ sizeLstNameThings = lstNameThings.size();
+ for (i=0 ; i<sizeLstNameThings ; i++)
+ {
+ manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(lstNameThings[i]);
+ sizeLstPoints = manualModel->GetSizeLstPoints();
+ for (ii=0 ; ii<sizeLstPoints ; ii++)
+ {
+ manualModel->GetManualPoint(ii)->SetPointZ(-900);
+ }// for ii list of points
+ }// for i list of static things
+}
+
+void wxContourMainFrame::onLoadContours(std::string fileNameContourROI, bool interactiveInterface)
+{
+ char tmp[255];
+ char tmpD[255];
+ FILE *pFile =fopen(fileNameContourROI.c_str(),"r+");
//CMRU 03-09-09- ----------------------------------------------------------------------------------------------
if(pFile != NULL)
{
//------------------------------------------------------------------------------------------------------------
- fileNameContourROI.append("data");
+ fileNameContourROI.append("data");
FILE *pFileData=fopen(fileNameContourROI.c_str(),"r+");
if(pFileData != NULL)
{
fscanf(pFileData,"%s",tmpD); // --CreaContour--
fscanf(pFileData,"%s",tmpD); // Version
- fscanf(pFileData,"%s",tmpD); // 1.0.2 || 1.0.1 || 1.0.0
-
+ fscanf(pFileData,"%s",tmpD); // 1.0.3 || 1.0.2 || 1.0.1 || 1.0.0
+
fscanf(pFileData,"%s",tmpD); // onePixelSize
fscanf(pFileData,"%s",tmpD); // #
- _onePixelSize = atof(tmpD);
- fscanf(pFileData,"%s",tmpD); // NumberOfContours
+ _onePixelSize = atof(tmpD);
+ fscanf(pFileData,"%s",tmpD); // NumberOfContours
fscanf(pFileData,"%s",tmpD); // #
}
-
fscanf(pFile,"%s",tmp); // --CreaContour--
-
fscanf(pFile,"%s",tmp); // Version
- fscanf(pFile,"%s",tmp); // 1.0.2 || 1.0.1 || 1.0.0
+ fscanf(pFile,"%s",tmp); // 1.0.3 || 1.0.2 || 1.0.1 || 1.0.0
std::string version(tmp);
-
//AD:02-06-09
- if (version=="1.0.2")
+ _tmpReadFileTypeOfTransformation=-1;
+ if (version=="1.0.3")
{
- openContours(pFile,pFileData,2,false);
- openContours(pFile,pFileData,2,true); //Load StaticContours
- }
-
- //AD:02-06-09
- else if (version=="1.0.1")
- {
- openContours(pFile,pFileData,1,false); //Skips ImageDimensions and ImageSpacing
- openContours(pFile,pFileData,1,true); //Load StaticContours, skips ImageDimensions and ImageSpacing
- }
-
- //AD:02-06-09
- else if (version=="1.0.0")
+ readDimSpc(pFile,interactiveInterface); // DimSpc interactive ON
+ openContours(pFile,pFileData,false);
+ openContours(pFile,pFileData,true); //Load StaticContours
+ }
+ if (version=="1.0.2")
{
- openContours(pFile,pFileData,1,false); //Skips ImageDimensions and ImageSpacing
+//EED001
+ readDimSpc(pFile,interactiveInterface); // DimSpc interactive ON
+ openContours(pFile,pFileData,false);
+ readDimSpc(pFile,false); // DimSpc interactive OFF
+ openContours(pFile,pFileData,true); // Load StaticContours
+ SetZForAllContours(-900);
+ } else if (version=="1.0.1") { //AD:02-06-09
+ openContours(pFile,pFileData,false); //Skips ImageDimensions and ImageSpacing
+ openContours(pFile,pFileData,true); //Load StaticContours, skips ImageDimensions and ImageSpacing
+ } else if (version=="1.0.0") { //AD:02-06-09
+ openContours(pFile,pFileData,false); //Skips ImageDimensions and ImageSpacing
}
-
fclose(pFile);
-
if(pFileData != NULL)
{
fclose(pFileData);
- }
- }
+ } // if
+ } // pFile
_theViewPanel->getSceneManager()->removeSceneContours();
changeInstant();
}
+
+void wxContourMainFrame::onImport()
+{
+ std::string filename, filenamecontours;
+//EED 2017-09-16 Migration wxWidgets 2.8 to 3.0
+#if wxMAJOR_VERSION <= 2
+ wxFileDialog dialog(NULL, _T("Choose a XML Osirix File"), _T(""), _T(""), _T("*.xml"), wxOPEN );
+#else
+ wxFileDialog dialog(NULL, _T("Choose a XML Osirix File"), _T(""), _T(""), _T("*.xml"), wxFD_OPEN );
+#endif
+ if (dialog.ShowModal() == wxID_OK)
+ {
+ filename = dialog.GetPath().mb_str();
+ filenamecontours = kernelManager->parseOsirixFile(filename);
+
+ if(filenamecontours.compare("") != 0)
+ {
+ onLoadContours(filenamecontours,true);
+ } // if
+ } // if
+}
+
+void wxContourMainFrame::onTest()
+{
+ std::string filename, filenamecontours;
+//EED 2017-09-16 Migration wxWidgets 2.8 to 3.0
+#if wxMAJOR_VERSION <= 2
+ wxFileDialog dialog(NULL, _T("Choose a File"), _T(""), _T(""), _T("*.*"), wxOPEN );
+#else
+ wxFileDialog dialog(NULL, _T("Choose a File"), _T(""), _T(""), _T("*.*"), wxFD_OPEN );
+#endif
+ if (dialog.ShowModal() == wxID_OK)
+ {
+ filename = dialog.GetPath().mb_str();
+ std::cout << "This is the filename: " << filename << std::endl;
+ } // if
+}
+
//AD: 29-05-09
-void wxContourMainFrame::onSave(){
+void wxContourMainFrame::onSave()
+{
//CMRU 03-09-09-----------------------------------------------------------------------------------------------
if(GetFileLocation().empty())
{
//------------------------------------------------------------------------------------------------------------
+//EED 2017-09-16 Migration wxWidgets 2.8 to 3.0
+#if wxMAJOR_VERSION <= 2
wxFileDialog dialog(NULL, _T("Choose a file"), _T(""), _T(""), _T("*.roi"), wxSAVE );
+#else
+ wxFileDialog dialog(NULL, _T("Choose a file"), _T(""), _T(""), _T("*.roi"), wxFD_SAVE );
+#endif
if (dialog.ShowModal() == wxID_OK)
{
std::string fileNameContourROI = (const char *)(dialog.GetPath().mb_str());
kernelManager->setCurrentFileName(fileNameContourROI);
saveFileWithContours( fileNameContourROI );
}
- }
-//CMRU 03-09-09-----------------------------------------------------------------------------------------------
- else
- {
- std::cout<<"Nombre del archivo: "<<GetFileLocation()<<std::endl;
+ } else {//CMRU 03-09-09-----------------------------------------------------------------------------------------------
+ std::cout<<"Nombre del archivo: "<<GetFileLocation()<<std::endl;
std::string fileNameContourROI = GetFileLocation();
- std::cout<<"Nombre del archivo: "<<fileNameContourROI<<std::endl;
+ std::cout<<"Nombre del archivo: "<<fileNameContourROI<<std::endl;
kernelManager->setCurrentFileName(fileNameContourROI);
saveFileWithContours( fileNameContourROI);
}
//CMRU 03-09-09-----------------------------------------------------------------------------------------------
filename.append("data");
- std::cout<<"Nombre del archivo: "<<filename<<std::endl;
+ std::cout<<"Nombre del archivo: "<<filename<<std::endl;
FILE *pFileData=fopen(filename.c_str(),"w+");
//------------------------------------------------------------------------------------------------------------
std::vector< std::string > lstNameThings;
- int i,sizeLstNameThings;
+ int i,sizeLstNameThings;
fprintf(pFile,"--CreaContour--\n");
- fprintf(pFile,"Version %s\n", "1.0.2" );
+ fprintf(pFile,"Version %s\n", "1.0.3" );
//CMRU 03-09-09-----------------------------------------------------------------------------------------------
fprintf(pFileData,"--CreaContour--\n");
- fprintf(pFileData,"Version %s\n", "1.0.2" );
+ fprintf(pFileData,"Version %s\n", "1.0.3" );
fprintf(pFileData,"OnePixelSize %f\n", _onePixelSize);
- std::cout<<"Valor de un pixel: "<<_onePixelSize<<std::endl;
-
+
//------------------------------------------------------------------------------------------------------------
-
+
vtkImageData *image = _images[0];
int dimRange[3];
fprintf(pFile,"ImageSpacing %f %f %f\n", spaRange[0], spaRange[1], spaRange[2] );
// Normal Contours
-
+
lstNameThings = kernelManager->GetLstNameThings();
- sizeLstNameThings = lstNameThings.size();
+ sizeLstNameThings = lstNameThings.size();
fprintf(pFile,"NumberOfContours %d\n", sizeLstNameThings );
//CMRU 03-09-09-----------------------------------------------------------------------------------------------
fprintf(pFileData,"NumberOfContours %d\n", sizeLstNameThings );
//------------------------------------------------------------------------------------------------------------
- for (i=0 ; i<sizeLstNameThings ; i++)
+
+// EED 2017-05-30
+ double spc[3];
+ spc[0]=1;
+ spc[1]=1;
+ spc[2]=1;
+
+ for (i=0 ; i<sizeLstNameThings ; i++)
{
//CMRU 03-09-09-----------------------------------------------------------------------------------------------
manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(lstNameThings[i]);
- double sizeInPixel = manualModel ->GetPathSize();
+
+// EED 2017-05-30
+// double sizeInPixel = manualModel ->GetPathSize( );
+ double sizeInPixel = manualModel ->GetPathSize( spc );
+
double realContourSize = sizeInPixel*_onePixelSize;
manualModel ->SetRealSize(realContourSize);
//------------------------------------------------------------------------------------------------------------
//-- Static Contours
- fprintf(pFile,"ImageDimensions %d %d %d\n", dimRange[0], dimRange[1], dimRange[2] );
-
- fprintf(pFile,"ImageSpacing %f %f %f\n", spaRange[0], spaRange[1], spaRange[2] );
-
+// fprintf(pFile,"ImageDimensions %d %d %d\n", dimRange[0], dimRange[1], dimRange[2] );
+// fprintf(pFile,"ImageSpacing %f %f %f\n", spaRange[0], spaRange[1], spaRange[2] );
+
lstNameThings = kernelManager->GetLstNameThingsStatic();
- sizeLstNameThings = lstNameThings.size();
+ sizeLstNameThings = lstNameThings.size();
fprintf(pFile,"NumberOfContoursStatic %d\n", sizeLstNameThings );
//CMRU 03-09-09-----------------------------------------------------------------------------------------------
fprintf(pFileData,"NumberOfContoursStatic %d\n", sizeLstNameThings );
//------------------------------------------------------------------------------------------------------------
- for (i=0 ; i<sizeLstNameThings ; i++)
+ for (i=0 ; i<sizeLstNameThings ; i++)
{
kernelManager->SaveThingName( pFile, pFileData, lstNameThings[i] );
_theViewPanel->getSceneManager()->SaveThingName( pFile, lstNameThings[i] );
fclose(pFileData);
}
-//AD:04-06-09
-void wxContourMainFrame::openContours( FILE *pFile, FILE *pFileData, int version, bool staticContour )
+
+//EED02
+void wxContourMainFrame::readDimSpc(FILE *pFile, bool interactiveOption)
{
char tmp[255];
-
- vtkImageData *image = _images[0];
- int imageDim[3];
- double imageSpac[3];
- int tempDim[3];
- double tempSpac[3];
-
- bool compatible = true;
-
- //Version==2
- if (version==2)
- {
- image->GetDimensions(imageDim);
- image->GetSpacing(imageSpac);
-
- fscanf(pFile,"%s",tmp); // ImageDimensions
- fscanf(pFile,"%s",tmp); // X
- tempDim[0] = atoi(tmp);
- fscanf(pFile,"%s",tmp); // Y
- tempDim[1] = atoi(tmp);
- fscanf(pFile,"%s",tmp); // Z
- tempDim[2] = atoi(tmp);
-
- fscanf(pFile,"%s",tmp); // ImageSpacing
- fscanf(pFile,"%s",tmp); // X
- tempSpac[0] = atof(tmp);
- fscanf(pFile,"%s",tmp); // Y
- tempSpac[1] = atof(tmp);
- fscanf(pFile,"%s",tmp); // Z
- tempSpac[2] = atof(tmp);
-
+ int imageDim[3];
+ double imageSpac[3];
+ vtkImageData *image = _images[0];
+ image->GetDimensions(imageDim);
+ image->GetSpacing(imageSpac);
+
+ fscanf(pFile,"%s",tmp); // ImageDimensions
+ fscanf(pFile,"%s",tmp); // X
+ _tmpReadFileImageDim[0] = atoi(tmp);
+ fscanf(pFile,"%s",tmp); // Y
+ _tmpReadFileImageDim[1] = atoi(tmp);
+ fscanf(pFile,"%s",tmp); // Z
+ _tmpReadFileImageDim[2] = atoi(tmp);
+
+ fscanf(pFile,"%s",tmp); // ImageSpacing
+ fscanf(pFile,"%s",tmp); // X
+ _tmpReadFileImageSpac[0] = atof(tmp);
+ fscanf(pFile,"%s",tmp); // Y
+ _tmpReadFileImageSpac[1] = atof(tmp);
+ fscanf(pFile,"%s",tmp); // Z
+ _tmpReadFileImageSpac[2] = atof(tmp);
+
+
+ if (interactiveOption==true)
+ {
//Compare Spacing and Dims in X and Y (Necessary in Z?) - Just for Version 2
- if (imageDim[0]!=tempDim[0] || imageDim[1]!=tempDim[1] || imageSpac[0]!=tempSpac[0] || imageSpac[1]!=tempSpac[1])
+ if (imageDim[0]!=_tmpReadFileImageDim[0] || imageDim[1]!=_tmpReadFileImageDim[1] || imageSpac[0]!=_tmpReadFileImageSpac[0] || imageSpac[1]!=_tmpReadFileImageSpac[1])
{
- compatible = false;
- }
- }
-
- fscanf(pFile,"%s",tmp); // NumberOfContours
+ wxDialog* dial = new wxDialog (this,-1,_T("Tools"),wxDefaultPosition, wxSize(460,360));
+ wxSizer* buttonsSizer = dial->CreateSeparatedButtonSizer(wxOK|wxCANCEL);
+// wxBoxSizer *dialSizer = new wxBoxSizer(wxVERTICAL);
+ wxFlexGridSizer *dialSizer = new wxFlexGridSizer(1);
+
+ wxString lstOptOperation[3];
+ lstOptOperation[0]=_T("By Dimension (XY)");
+ lstOptOperation[1]=_T("By Spacing (XY)");
+ lstOptOperation[2]=_T("By Spacing (XYZ)");
+ wxRadioBox * radioOpts = new wxRadioBox(dial, -1, _T("Type of Transformation"), wxDefaultPosition, wxSize(370,200), 3 , lstOptOperation, 3, wxRA_SPECIFY_ROWS);
+
+ dialSizer->Add( new wxStaticText(dial,-1,_T("The image resolution is not compatible with the ")) , 0, wxGROW );
+ dialSizer->Add( new wxStaticText(dial,-1,_T("selected Roi file. Do you want to tranform it?")) , 0, wxGROW );
+ dialSizer->Add( new wxStaticText(dial,-1,_T(" ")) , 0, wxGROW );
+ dialSizer->Add(radioOpts,0,wxGROW);
+ dialSizer->Add( new wxStaticText(dial,-1,_T(" ")) , 0, wxGROW );
+ dialSizer->Add(buttonsSizer,0,wxGROW);
+ dial->SetSizer(dialSizer, true);
+ dial->Layout();
+ dial->ShowModal();
+
+ _tmpReadFileTypeOfTransformation = -1;
+//EED bool transform = false;
+
+ if (dial->GetReturnCode() == wxID_OK)
+ {
+ _tmpReadFileTypeOfTransformation = radioOpts->GetSelection();
+ }// if wxOK
+
+ } // if dim spc
+ } // if interactiveOption
+}
+
+
+
+
+//AD:04-06-09
+void wxContourMainFrame::openContours( FILE *pFile, FILE *pFileData, bool staticContour )
+{
+printf ("EED wxContourMainFrame::openContours Start \n");
+ char tmp[255];
+
+ vtkImageData *image = _images[0];
+
+ int imageDim[3];
+ double imageSpac[3];
+ image->GetDimensions(imageDim);
+ image->GetSpacing(imageSpac);
+
+
+ fscanf(pFile,"%s",tmp); // NumberOfContours
fscanf(pFile,"%s",tmp); // ##
- int numberOfContours = atoi(tmp);
+ int numberOfContours = atoi(tmp);
std::vector<int> instantVector;
int typeContourModel;
manualBaseModel *manModelContour;
int typeView;
+/*
if (compatible==true)
{
int i;
fscanf(pFile,"%s",tmp); // TypeView
fscanf(pFile,"%s",tmp); // ##
- typeView = atoi(tmp);
+ typeView = atoi(tmp);
std::string theName;
theName = kernelManager->createOutline( manModelContour, instantVector );
if( addedModel )
{
double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
- _theViewPanel->getSpacing(spc);
+ _theViewPanel->getSpacing(spc);
//Adding the manualContourControler to interface objects structure
- //Adding the manualViewContour 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) //StaticContours (will appear in all slices)
{
kernelManager->changeContourOfManager( theName , &instant );
}
- }// for numberOfContours
+ }// for numberOfContours
}
else if (compatible==false)
{
- wxDialog* dial = new wxDialog (this,-1,_T("Tools"),wxDefaultPosition, wxSize(260,160));
- wxSizer* buttonsSizer = dial->CreateSeparatedButtonSizer(wxOK|wxCANCEL);
- wxBoxSizer *dialSizer = new wxBoxSizer(wxVERTICAL);
-
- wxString lstOptOperation[2];
- lstOptOperation[0]=_T("By Dimension");
- lstOptOperation[1]=_T("By Spacing");
- wxRadioBox * radioOpts = new wxRadioBox(dial, -1, _T("Type of Transformation"), wxDefaultPosition, wxSize(270,45), 2 , lstOptOperation, 2, wxRA_SPECIFY_COLS);
-
- dialSizer->Add( new wxStaticText(dial,-1,_T("The image resolution is not compatible with the ")) , 0, wxGROW );
- dialSizer->Add( new wxStaticText(dial,-1,_T("selected Roi file. Do you want to tranform it?")) , 0, wxGROW );
- dialSizer->Add( new wxStaticText(dial,-1,_T(" ")) , 0, wxGROW );
- dialSizer->Add(radioOpts,0,wxGROW);
- dialSizer->Add( new wxStaticText(dial,-1,_T(" ")) , 0, wxGROW );
- dialSizer->Add(buttonsSizer,0,wxGROW);
- dial->SetSizer(dialSizer, true);
- dial->Layout();
- dial->ShowModal();
-
- int typeOfTransformation = -1;
- bool transform = false;
+*/
- if (dial->GetReturnCode() == wxID_OK)
- {
- typeOfTransformation = radioOpts->GetSelection();
- transform = true;
- }
-
int i;
for (i=0;i<numberOfContours;i++)
{
{
manModelContour->OpenData(pFileData);
}
- if (transform==true)
- {
- if (typeOfTransformation==0)
- {
- double transX, transY;
- transX = (double) imageDim[0]/tempDim[0];
- transY = (double) imageDim[1]/tempDim[1];
- manModelContour->Transform_Ax_Plus_B(transX,0,transY,0);
- }
- else if (typeOfTransformation==1)
- {
- double transX, transY;
- transX = (double) tempSpac[0]/imageSpac[0];
- transY = (double) tempSpac[1]/imageSpac[1];
- manModelContour->Transform_Ax_Plus_B(transX,0,transY,0);
- }
- }
+
+ if (_tmpReadFileTypeOfTransformation==-1){
+ //nothing to do..
+ } else if (_tmpReadFileTypeOfTransformation==0){
+ double transX, transY;
+ transX = (double) imageDim[0]/_tmpReadFileImageDim[0]; // X
+ transY = (double) imageDim[1]/_tmpReadFileImageDim[1]; // Y
+ manModelContour->Transform_Ax_Plus_B(transX,0,transY,0);
+ } else if (_tmpReadFileTypeOfTransformation==1) {
+ double transX, transY;
+ transX = (double) _tmpReadFileImageSpac[0]/imageSpac[0]; // X
+ transY = (double) _tmpReadFileImageSpac[1]/imageSpac[1]; // Y
+ manModelContour->Transform_Ax_Plus_B(transX,0,transY,0);
+ } else if (_tmpReadFileTypeOfTransformation==2) { // with Z include
+ double transX, transY;
+ transX = (double) _tmpReadFileImageSpac[0]/imageSpac[0]; // X
+ transY = (double) _tmpReadFileImageSpac[1]/imageSpac[1]; // Y
+ instantVector[1]=instantVector[1]*_tmpReadFileImageSpac[2]/imageSpac[2]; // Z
+ manModelContour->Transform_Ax_Plus_B(transX,0,transY,0);
+ }else {
+ printf ("EED Warnning! wxContourMainFrame::openContours _tmpReadFileTypeOfTransformation not set. \n");
+ }
fscanf(pFile,"%s",tmp); // TypeView
fscanf(pFile,"%s",tmp); // ##
- typeView = atoi(tmp);
+ typeView = atoi(tmp);
std::string theName;
theName = kernelManager->createOutline( manModelContour, instantVector );
if( addedModel )
{
double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
- _theViewPanel->getSpacing(spc);
+ _theViewPanel->getSpacing(spc);
//Adding the manualContourControler to interface objects structure
- //Adding the manualViewContour 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) //StaticContours (will appear in all slices)
{
Instant instant(&instantVector);
kernelManager->changeContourOfManager( theName , &instant );
}
- }// for numberOfContours
- }
+ }// for numberOfContours
+
+/* } */
+
+printf ("EED wxContourMainFrame::openContours END \n");
+
}
-void wxContourMainFrame::RefreshInterface(){
+void wxContourMainFrame::RefreshInterface()
+{
changeInstant();
_theViewPanel->RefreshInterface();
//wxVtk2DBaseView *wxvtk2dbaseview = (wxVtk2DBaseView*)this->_theViewPanel->getWxVtkBaseView();
//wxvtk2dbaseview->Refresh();
}
-vtkImageData* wxContourMainFrame::getImageData(){
+vtkImageData* wxContourMainFrame::getImageData()
+{
return _theViewPanel->getImageData();
}
//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 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,
+ 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,
+ typedef itk::RescaleIntensityImageFilter<
+ InternalImageType,
OutputImageType > CastFilterType3;
-
//Cuarto tipo de conversiÛn
- typedef itk::RescaleIntensityImageFilter<
- OutputImageType,
+ 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<OutputImageType2> ConnectorType;
typedef itk::ImageToVTKImageFilter<OutputImageType> 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();
-
+//EED10JUIN2011 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,
+ typedef itk::CurvatureAnisotropicDiffusionImageFilter<
+ InternalImageType,
InternalImageType > SmoothingFilterType;
-
SmoothingFilterType::Pointer smoothing = SmoothingFilterType::New();
-
- typedef itk::GradientMagnitudeRecursiveGaussianImageFilter<
- InternalImageType,
+ typedef itk::GradientMagnitudeRecursiveGaussianImageFilter<
+ InternalImageType,
InternalImageType > GradientFilterType;
-
- typedef itk::SigmoidImageFilter<
- InternalImageType,
+ 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,
+ typedef itk::FastMarchingImageFilter<
+ InternalImageType,
InternalImageType > FastMarchingFilterType;
-
-
FastMarchingFilterType::Pointer fastMarching = FastMarchingFilterType::New();
-
- typedef itk::GeodesicActiveContourLevelSetImageFilter< InternalImageType,
+ typedef itk::GeodesicActiveContourLevelSetImageFilter< InternalImageType,
InternalImageType > GeodesicActiveContourFilterType;
- GeodesicActiveContourFilterType::Pointer geodesicActiveContour =
+ GeodesicActiveContourFilterType::Pointer geodesicActiveContour =
GeodesicActiveContourFilterType::New();
-
- typedef itk::ZeroCrossingImageFilter<
- InternalImageType,
+ 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() );
+ 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() );
-
+ 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;
-
+ 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->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 "<<polyDataResult->GetNumberOfPoints()<<std::endl;
- polyDataResult->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<double> vecX;
- std::vector<double> vecY;
- std::vector<double> vecXo;
- std::vector<double> vecYo;
- std::vector<double>::iterator vecXoi;
- std::vector<double>::iterator vecYoi;
- std::vector<double> vecZ;
-
- std::vector<double> vecCtrlPointX;
- std::vector<double> vecCtrlPointY;
- std::vector<double> 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;ii<size;ii++)
- {
- if(ii==0)
+// connector2->Update();
+ vtkImageData *idata = NULL;
+ idata = connector2->GetOutput();
+ vtkMarchingContourFilter* cntVTK = vtkMarchingContourFilter::New( );
+ cntVTK->SetNumberOfContours( 1 );
+ cntVTK->SetValue( 0, 255 );
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ cntVTK->SetInput( idata );
+ cntVTK->Update( );
+ cntVTK->UpdateInformation();
+#else
+ cntVTK->SetInputData( idata );
+#endif
+ vtkCleanPolyData* cpd = vtkCleanPolyData::New( );
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ cpd->SetInput( cntVTK->GetOutput( ) );
+ cpd->Update( );
+ cpd->UpdateInformation();
+#else
+ cpd->SetInputData( cntVTK->GetOutput( ) );
+#endif
+ vtkPolyDataConnectivityFilter* conn = vtkPolyDataConnectivityFilter::New( );
+ conn->SetExtractionModeToLargestRegion( );
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ conn->SetInput( cpd->GetOutput( ) );
+ conn->Update( );
+ conn->UpdateInformation();
+#else
+ conn->SetInputData( cpd->GetOutput( ) );
+#endif
+ vtkStripper* vtkstripper = vtkStripper::New( );
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ vtkstripper->SetInput( conn->GetOutput() );
+ vtkstripper->Update();
+ vtkstripper->UpdateInformation();
+#else
+ vtkstripper->SetInputData( conn->GetOutput() );
+ cntVTK->Update();
+#endif
+ vtkPolyData* polyDataResult = cntVTK->GetOutput();
+ //std::cout<<"Points "<<polyDataResult->GetNumberOfPoints()<<std::endl;
+
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ polyDataResult->Update( );
+ polyDataResult->UpdateInformation();
+#else
+ // ..
+#endif
+ cntVTK -> Delete();
+ cpd -> Delete();
+ conn -> Delete();
+ //--Calculating control points
+ std::vector<double> vecX;
+ std::vector<double> vecY;
+ std::vector<double> vecXo;
+ std::vector<double> vecYo;
+ std::vector<double>::iterator vecXoi;
+ std::vector<double>::iterator vecYoi;
+ std::vector<double> vecZ;
+ std::vector<double> vecCtrlPointX;
+ std::vector<double> vecCtrlPointY;
+ std::vector<double> 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;ii<size;ii++)
{
- xAct=x;
- yAct=y;
- }
- p = polyDataResult->GetPoint(ii);
- double x=p[0];
- double y=p[1];
- /*if(fabs(yAct-y)>20)
- {
- if((xAct-x)>1 || (xAct-x)<-1)
+ if(ii==0)
{
- vecX.push_back( p[0] );
- vecY.push_back( p[1] );
- myfile <<p[0]<<","<<p[1]<<"\n";
- std::cout<<" x Anterior "<<xAct<<" x actual "<<x<<std::endl;
- std::cout<<" y Anterior "<<yAct<<" y actual "<<y<<std::endl;
- std::cout<<" x "<<p[0]<<" y "<<p[1]<<std::endl;
- vecZ.push_back( 900 );
- xAct=x;
- yAct=y;
+ xAct=x;
+ yAct=y;
}
- else
+ p = polyDataResult->GetPoint(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 <<p[0]<<","<<p[1]<<"\n";
+// std::cout<<" x Anterior "<<xAct<<" x actual "<<x<<std::endl;
+// std::cout<<" y Anterior "<<yAct<<" y actual "<<y<<std::endl;
+// std::cout<<" x "<<p[0]<<" y "<<p[1]<<std::endl;
+// vecZ.push_back( 900 );
+// xAct=x;
+// yAct=y;
+// } else {
+// vecXo.push_back(p[0]);
+// vecYo.push_back(p[1]);
+// }
+// } else
+
+ if(fabs(xAct-x)>11)
{
vecXo.push_back(p[0]);
vecYo.push_back(p[1]);
- }
-
- }
- else*/ if(fabs(xAct-x)>11)
- {
- vecXo.push_back(p[0]);
- vecYo.push_back(p[1]);
- }
- else
- {
- vecX.push_back( p[0] );
- myfile <<p[0]<<","<<p[1]<<"\n";
- //std::cout<<" x Anterior "<<xAct<<" x actual "<<x<<std::endl;
- //std::cout<<" y Anterior "<<yAct<<" y actual "<<y<<std::endl;
- //std::cout<<" x "<<p[0]<<" y "<<p[1]<<std::endl;
- vecY.push_back( p[1] );
- vecZ.push_back( 900 );
- xAct=x;
- yAct=y;
- }
-
-
- }
+ } else {
+ vecX.push_back( p[0] );
+ myfile <<p[0]<<","<<p[1]<<"\n";
+ //std::cout<<" x Anterior "<<xAct<<" x actual "<<x<<std::endl;
+ //std::cout<<" y Anterior "<<yAct<<" y actual "<<y<<std::endl;
+ //std::cout<<" x "<<p[0]<<" y "<<p[1]<<std::endl;
+ vecY.push_back( p[1] );
+//EED 2017-12-16
+ vecZ.push_back( -900 );
+ xAct = x;
+ yAct = y;
+ } // if xAct
- while(!vecXo.empty())
- {
- vecX.push_back(vecXo.back());
- //std::cout<<" x Siguiente "<<vecXo.back();
- vecXo.pop_back();
- vecZ.push_back( 900 );
- }
- while(!vecYo.empty())
- {
- vecY.push_back(vecYo.back());
- vecYo.pop_back();
- }
- myfile.close();
- /*for(int l=0;l<vecX.size();l++)
- {
- if(l==0)
+ } // for
+
+ while(!vecXo.empty())
{
- vecXo.push_back(p[0]);
- vecYo.push_back(p[1]);
+ vecX.push_back(vecXo.back());
+ //std::cout<<" x Siguiente "<<vecXo.back();
+ vecXo.pop_back();
+ //EED 2017-12-16
+ vecZ.push_back( -900 );
}
- else
+ while(!vecYo.empty())
{
- if(vecXoi[l-1]==)
- {
- }
+ vecY.push_back(vecYo.back());
+ vecYo.pop_back();
}
+ myfile.close();
+
+// for(int l=0;l<vecX.size();l++)
+// {
+// if(l==0)
+// {
+// vecXo.push_back(p[0]);
+// vecYo.push_back(p[1]);
+// } else {
+// if(vecXoi[l-1]==)
+// {
+// }
+// } // if
+// } // for
+
+ ExtractControlPoints2D *extractcontrolpoints2d = new ExtractControlPoints2D();
+ extractcontrolpoints2d->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<int> actualInstantVector;
+ _instantPanel->getInstant( actualInstantVector );
+ actualInstantVector[1]=z;
- ExtractControlPoints2D *extractcontrolpoints2d = new ExtractControlPoints2D();
+ int j,sizeCtrPt = vecCtrlPointX.size();
- extractcontrolpoints2d->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<int> actualInstantVector;
- _instantPanel->getInstant( actualInstantVector );
- actualInstantVector[1]=z;
+ manualBaseModel *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 j,sizeCtrPt = vecCtrlPointX.size();
-
- manualBaseModel *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
+ } catch( itk::ExceptionObject & excep ) {
+ std::cerr << "Exception caught !" << std::endl;
+ std::cerr << excep << std::endl;
+ } // try
-
-
- 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();
void wxContourMainFrame::SegmentationOneSlice( int x, int y, int z, int isovalue, int sampling, int method )
-{
+{
+
+//printf("EED wxContourMainFrame::SegmentationOneSlice Start=%d %d\n",sampling,method );
+//printf("EED wxContourMainFrame::SegmentationOneSlice %d %d %d \n",x,y,z );
+
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];
+ double spc[3];
+ imagedata->GetSpacing(spc);
+ x = x*spc[0];
+ y = y*spc[1];
+ z = z;
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
imageReslice->SetInput( imagedata );
+#else
+ imageReslice->SetInputData( imagedata );
+#endif
imageReslice->SetInformationInput(imagedata);
imageReslice->SetResliceAxesDirectionCosines(1,0,0, 0,1,0 ,0,0,1);
- imageReslice->SetResliceAxesOrigin(0,0,z);
+ imageReslice->SetResliceAxesOrigin(0,0,z*spc[2]);
imageReslice->SetOutputDimensionality(2);
imageReslice->SetInterpolationModeToLinear();
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ // ..
+#else
+ imageReslice->Update();
+#endif
+
imagedata = imageReslice->GetOutput();
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
imagedata->Update();
imagedata->UpdateInformation();
+#else
+ // ..
+#endif
vtkContourFilter* cntVTK = vtkContourFilter::New( );
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
cntVTK->SetInput( imagedata );
+#else
+ cntVTK->SetInputData( imagedata );
+#endif
cntVTK->SetNumberOfContours( 1 );
//cntVTK->SetValue( 0, vmin );
// cntVTK->SetValue( 1, vmax );
cntVTK->Update( );
cntVTK->UpdateInformation();
-
+
vtkCleanPolyData* cpd = vtkCleanPolyData::New( );
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
cpd->SetInput( cntVTK->GetOutput( ) );
+#else
+ cpd->SetInputData( cntVTK->GetOutput( ) );
+#endif
cpd->ConvertLinesToPointsOff( );
cpd->Update( );
cpd->UpdateInformation();
vtkPolyDataConnectivityFilter* conn = vtkPolyDataConnectivityFilter::New( );
- conn->SetExtractionModeToClosestPointRegion( );
+
+// conn->SetExtractionModeToPointSeededRegions();
+// conn->SetExtractionModeToCellSeededRegions();
+// conn->SetExtractionModeToSpecifiedRegions();
+// conn->SetExtractionModeToLargestRegion();
+// conn->SetExtractionModeToAllRegions();
+
+ conn->SetExtractionModeToClosestPointRegion();
+
//conn->SetMaxRecursionDepth( 3000 );
-
+
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
conn->SetInput( cpd->GetOutput( ) );
-
+#else
+ conn->SetInputData( cpd->GetOutput( ) );
+#endif
+
conn->SetClosestPoint( x, y, 0 );
conn->Update( );
conn->UpdateInformation();
-
+
vtkCleanPolyData* cpd2 = vtkCleanPolyData::New( );
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
cpd2->SetInput( conn->GetOutput( ) );
+#else
+ cpd2->SetInputData( conn->GetOutput( ) );
+#endif
cpd2->Update();
cpd2->UpdateInformation();
vtkStripper* vtkstripper = vtkStripper::New( );
+vtkstripper->SetJoinContiguousSegments(true);
+ vtkstripper->SetMaximumLength(20000);
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
vtkstripper->SetInput( cpd2->GetOutput() );
+#else
+ vtkstripper->SetInputData( cpd2->GetOutput() );
+// vtkstripper->SetInputData( cntVTK->GetOutput() );
+
+#endif
vtkstripper->Update();
vtkstripper->UpdateInformation();
vtkPolyData* polyDataResult = vtkstripper->GetOutput();
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
polyDataResult->Update( );
polyDataResult->UpdateInformation();
+#else
+ //...
+#endif
/* EED
ofstream myfile;
polyDataResult->GetLines()->Print(myfile);
myfile.close();
*/
-
- cntVTK -> Delete();
- cpd2 -> Delete();
- cpd -> Delete();
- conn -> Delete();
-
+ 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;
+//printf("EED wxContourMainFrame::SegmentationOneSlice GetNumberOfLines=%d \n",polyDataResult->GetNumberOfLines() );
+//int numberOfPointsInCell;
+//int numberOfcells=polyDataResult->GetNumberOfCells();
+//for (int jj=0; jj<numberOfcells ; jj++)
+//{
+// vtkCell* vtkcell = polyDataResult->GetCell( jj );
+// numberOfPointsInCell=vtkcell->GetNumberOfPoints();
+// printf("EED wxContourMainFrame::SegmentationOneSlice cell=%d points=%d \n",jj,numberOfPointsInCell );
+//}// for jj
+// printf("EED wxContourMainFrame::SegmentationOneSlice PrintSelf \n");
+// polyDataResult->PrintSelf( std::cout, vtkIndent(0) );
- 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 );
- }
+ if (polyDataResult->GetNumberOfCells()>0)
+ {
+ double *p;
+ vtkCell* vtkcell = polyDataResult->GetCell( 0 );
+ // int ii,size=polyDataResult->GetNumberOfPoints();
+ int ii,size=vtkcell->GetNumberOfPoints();
+ int id;
+ for (ii=0;ii<size;ii++)
+ {
+ // id = polyDataResult->GetLines()->GetData()->GetValue(ii);
+ // p = polyDataResult->GetPoint(id);
+ p = vtkcell->GetPoints()->GetPoint(ii);
+// printf("EED wxContourMainFrame::SegmentationOneSlice (%d) id=%d px=%f py=%f\n",ii,id, p[0],p[1]);
+ // double x=p[0];
+ // double y=p[1];
+ vecX.push_back( p[0] );
+ vecY.push_back( p[1] );
+ //EED 2017-12-16
+ 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 );
+ }*/
- //--Adding contour to the system
+ 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 );
+ }
- std::vector<int> actualInstantVector;
- _instantPanel->getInstant( actualInstantVector );
- actualInstantVector[1]=z;
+ //--Adding contour to the system
+ std::vector<int> actualInstantVector;
+ _instantPanel->getInstant( actualInstantVector );
+ actualInstantVector[1]=z;
- int j,sizeCtrPt = vecCtrlPointX.size();
- manualBaseModel *manModelContour = kernelManager->factoryManualContourModel( typeofcontour );
- manModelContour->SetNumberOfPointsSpline( ((sizeCtrPt/100)+1)*100 );
- if (sizeCtrPt>=3){
- for (j=0 ; j<sizeCtrPt ; j++)
+ int j,sizeCtrPt = vecCtrlPointX.size();
+ manualBaseModel *manModelContour = kernelManager->factoryManualContourModel( typeofcontour );
+ manModelContour->SetNumberOfPointsSpline( ((sizeCtrPt/100)+1)*100 *2 );
+ manModelContour->SetLabel2( std::to_string(z) );
+ if (sizeCtrPt>=3)
{
- 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
+ for (j=0 ; j<sizeCtrPt ; j++)
+ {
+ manModelContour->AddPoint( vecCtrlPointX[j] / spc[0], vecCtrlPointY[j] / spc[1], 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
+ } // if NumberOfCells > 0
+//printf("EED wxContourMainFrame::SegmentationOneSlice End\n");
}
-int wxContourMainFrame::GetImageDataSizeZ(){
+
+int wxContourMainFrame::GetImageDataSizeZ()
+{
return _theViewPanel->GetImageDataSizeZ();
}
-void wxContourMainFrame::GetImageDataRange(double *range){
+void wxContourMainFrame::GetImageDataRange(double *range)
+{
_theViewPanel->GetImageDataRange(range);
}
-void wxContourMainFrame::onSegmentationAllSlice(int minZ,int maxZ,int isovalue,int sampling,int method){
+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;
+ 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;
_refLineModel->SetCloseContour(false);
_refLineControl->CreateNewManualContour();
-//AD: Inicializar el mirroring con una linea ya pintada
+//AD: Inicializar el mirroring con una linea ya pintada
/*
double z = _refLineControl->GetZ();
_instantPanel->getInstant( tempVector );
_performingOperation->setEndOperationInstantVector ( tempVector );
std::vector<std::string> elems = _performingOperation->getKeyNamesOperationElems();
- int i,size = elems.size();
+ int i,size = elems.size();
for( i=0; i<size; i++ )
- {
+ {
createMirrorContourOf( elems[i], tempVector, i>0 );
- }
+ }
}
//deleteContour( _refName );
_theViewPanel->removeSceneContours();
_theViewPanel->SetWidthContour(width);
-
+
//_theViewPanel->getSceneManager()->SetWidthContour( width );
RefreshInterface();
img->GetScalarRange(range);
std::cout<<"Val 1: "<<range[0]<<" Val 2: "<<range[1]<<std::endl;
-
+
return (int)range[1];
*/
return _theViewPanel->getColorWindow();
img->GetScalarRange(range);
std::cout<<"Val 1: "<<range[0]<<" Val 2: "<<range[1]<<std::endl;
-
+
return (int)range[1];
*/
return _theViewPanel->getWindowLevel();
}
-void wxContourMainFrame::onBrigthnessColorWindowLevel(int colorwindow,int windowlevel){
+void wxContourMainFrame::onBrigthnessColorWindowLevel(int colorwindow,int windowlevel)
+{
_theViewPanel->onBrigthnessColorWindowLevel(colorwindow, windowlevel);
RefreshInterface();
}
-void wxContourMainFrame::onInterpolation(bool interpolate){
- _theViewPanel->onInterpolation(interpolate);
+void wxContourMainFrame::onInterpolation(bool interpolate)
+{
+ _theViewPanel->onInterpolation(interpolate);
+ RefreshInterface();
+}
+
+void wxContourMainFrame::onBeforeAfterContour(bool before,bool after)
+{
+ _theViewPanel->onBeforeAfterContour(before,after);
+ RefreshInterface();
+}
+
+void wxContourMainFrame::onJumpSlice(int step, int shift)
+{
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+ int ss = abs(step);
+ int pos = tempVector[1];
+ int maxZ = interfMainPanel::getInstance()->GetImageDataSizeZ();
+ pos=(pos/ss)*ss+step+shift;
+ if ((pos>=0) && (pos<maxZ))
+ {
+ tempVector[1]=pos;
+ _instantPanel->setInstant( tempVector );
+ RefreshInterface();
+ } // if pos
+}
+
+void wxContourMainFrame::onShowTextContour(bool show)
+{
+ _theViewPanel->onShowTextContour(show);
RefreshInterface();
}
-void wxContourMainFrame::onChangeInstant(std::string name,int actual){
+void wxContourMainFrame::onChangeInstant(std::string name,int actual)
+{
_instantPanel->setConceptValue( name, actual );
}
-void wxContourMainFrame::resetAppend(){
+void wxContourMainFrame::resetAppend()
+{
kernelManager->resetAppend();
-
}
-void wxContourMainFrame::onSpreadAdd(){
- std::vector<double> vecX;
- std::vector<double> vecY;
- std::vector<double> vecZ;
+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){
+void wxContourMainFrame::onSpreadAddAll()
+{
+//EED02
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+ int minZ,maxZ;
+ minZ = 0;
+ maxZ = interfMainPanel::getInstance()->GetImageDataSizeZ();
+ int z;
+ int sizeLstContourThings;
+ for ( z=minZ ; z<=maxZ ; z++ )
+ {
+ tempVector[1]=z;
+ Instant instant(&tempVector);
+ std::vector<ContourThing**> lstContourThings = kernelManager->getOutlinesAtInstant( &instant );
+ sizeLstContourThings = lstContourThings.size();
+ if (sizeLstContourThings>=1)
+ {
+ std::vector<double> vecX;
+ std::vector<double> vecY;
+ std::vector<double> vecZ;
+ ContourThing **contourthing = lstContourThings[0];
+ manualBaseModel *cModel = (*contourthing)->getModel();
+ int i,size = cModel->GetNumberOfPointsSpline();
+ double x,y,z;
+ for (i=0; i<size; i++)
+ {
+ cModel->GetSpline_i_Point(i, &x, &y, &z);
+ vecX.push_back(x);
+ vecY.push_back(y);
+ vecZ.push_back(z);
+ } // for i
+ std::string val = kernelManager->onSpreadAdd(&vecX , &vecY , &vecZ, tempVector);
+ interfMainPanel::getInstance()->appendStringSpread(val);
+ }// if sizeLstContourThings
+ } // for z
+}
+
+
+void wxContourMainFrame::onSpreadGo(int type)
+{
//JCP 20-10-08 Undo redo implementation
saveState();
//JCP 20-10-08 Undo redo implementation
-
- wxBusyCursor wait;
+ wxBusyCursor wait;
std::vector<double> vecCtrlPointX;
std::vector<double> vecCtrlPointY;
std::vector<double> vecCtrlPointZ;
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);
+
+ interfMainPanel::getInstance()->setStringSpread(stringtemp);
int typeofcontour = 1;
std::string theName;
if( manModelContour!=NULL ){
double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
- this->_theViewPanel->getSpacing(spc);
+ this->_theViewPanel->getSpacing(spc);
//Adding the manualContourControler to interface objects structure
- //Adding the manualViewContour 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){
-
+void wxContourMainFrame::getInstantVector(std::vector<int>& tempVector)
+{
+ _instantPanel->getInstant( tempVector );
}
-std::vector<std::string> wxContourMainFrame::getOutlinesName(int slide){
+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
}
+void wxContourMainFrame::SetScalarRange(int grayRangeMin, int grayRangeMax)
+{
+ _contourextractdata->SetScalarRange(grayRangeMin,grayRangeMax);
+}
+
void wxContourMainFrame::onInformationContourLabels(int typeContourGroup,int selection,int minimumZ,int maximumZ,int grayRangeMin, int grayRangeMax)
{
-//EED01Juillet2009 GenerateContourExtractData();
-
+
wxString tempString;
int maxContourGroup = 0;
-
+
_contourextractdata ->SetTypeOperation( typeContourGroup % 3 );
std::vector<manualBaseModel*> lstManConMod;
std::vector<double> pLstValuePosY;
std::vector<double> pLstValuePosZ;
- int resultSize;
+ int resultSize;
int resultGrayRangeCount;
- double resultMin;
+ double resultMin;
double resultMax;
double resultAverage;
double resultStandardeviation;
std::vector<int> tempVector;
_instantPanel->getInstant( tempVector );
-//EED01Juillet2009 vtkImageData *imagedata = _theViewPanel->getImageData();
-// int sizeZ = _theViewPanel->GetImageDataSizeZ();
int z;
int ii,sizeLstContourThings;
int minZ,maxZ;
double totalZ;
- double porcent;
+ double porcent;
wxString tmpString;
minZ = minimumZ;
maxZ = maximumZ;
}
-
+
totalZ = maxZ-minZ+1;
-//EED01Juillet2009 _contourextractdata->SetImage( imagedata);
_contourextractdata->InitVolumeStatistics();
-
+
// 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);
+ interfMainPanel::getInstance()->setStringInfoPanel(tmpString);
//_staticTextInformation->SetLabel(tmpString);
//Extraction data from contours of each slice
if (typeContourGroup==3) // contour separete
{
sizeContourGroup=lstManConModExp.size();
- if ( maxContourGroup<sizeContourGroup )
+ if ( maxContourGroup<sizeContourGroup )
{
maxContourGroup=sizeContourGroup;
}
for( iContourGroup=0 ; iContourGroup<sizeContourGroup ; iContourGroup++ ){
lstManConModTmp.clear();
-
+
if (typeContourGroup==3) // contour separete
{
}
_contourextractdata->SetLstManualContourModel( lstManConModTmp );
+ _contourextractdata->SetScalarRange(grayRangeMin,grayRangeMax);
pLstValue.clear();
pLstValuePosX.clear();
pLstValuePosY.clear();
pLstValuePosZ.clear();
- _contourextractdata->GetValuesInsideCrown( &pLstValue,
+
+
+ int numberOfPixels;
+ _contourextractdata->GetValuesInsideCrown( &numberOfPixels,
+ &pLstValue,
&pLstValuePosX,
&pLstValuePosY,
&pLstValuePosZ);
+ resultSize=numberOfPixels;
// Statistics of each slice.
_contourextractdata->Statistics( &pLstValue,
grayRangeMin,
grayRangeMax,
- &resultGrayRangeCount,
- &resultSize,
- &resultMin,
+ &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"),numberOfPixels);
+
+ 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
// Print Volume Statistics
- int vol_rCountRange;
+ int vol_rCountRange;
int vol_rsize;
double vol_minValue;
double vol_maxValue;
double vol_average;
double vol_standardeviation;
-
+
if (selection!=0 ) // actual slice
{
&vol_average, &vol_standardeviation);
interfMainPanel::getInstance()->setRowLabelInfoPanel(maxZ+2, _T("Total:"));
-
+
tempString.Printf(_T("%d"),vol_rsize);
- interfMainPanel::getInstance()->setCellValueInfoPanel(maxZ+2, 0, tempString);
-
+ interfMainPanel::getInstance()->setCellValueInfoPanel(maxZ+2, 0, tempString);
+
tempString.Printf(_T("%d"),vol_rCountRange);
interfMainPanel::getInstance()->setCellValueInfoPanel(maxZ+2, 1, tempString);
-
+
tempString.Printf(_T("%f"),vol_minValue);
interfMainPanel::getInstance()->setCellValueInfoPanel(maxZ+2, 2, tempString);
-
+
tempString.Printf(_T("%f"),vol_maxValue);
interfMainPanel::getInstance()->setCellValueInfoPanel(maxZ+2, 3, tempString);
-
+
tempString.Printf(_T("%f"),vol_average);
interfMainPanel::getInstance()->setCellValueInfoPanel(maxZ+2, 4, tempString);
-
+
tempString.Printf(_T("%f"),vol_standardeviation);
interfMainPanel::getInstance()->setCellValueInfoPanel(maxZ+2, 5, tempString);
}
//-----------------------------------------
-
+
int iTitleGroup;
wxString tmpTitleString;
int tmpIntB;
}
//AD: 29-05-09
-void wxContourMainFrame::onSaveResults(std::string directory,std::string namefile, std::string filename,
+void wxContourMainFrame::onSaveResults(std::string directory,std::string namefile, std::string filename,
int typeContourGroup, int selection, int minZ, int maxZ, bool XYZValues, bool contourImage, bool statistics)
{
if (XYZValues)
this->getMaskValue(&mask, &value, typeContourGroup,selection,minZ,maxZ);
this->SaveImageResult( directory , namefile, mask, value);
}
-
+
if (statistics)
{
std::ostringstream name;
name << filename << ".xls";
-
+
FILE *pFile=fopen(name.str().c_str(),"w+");
wxString tmpString;
int i,j,maxX;
-
+
// int sizeZ = _theViewPanel->GetImageDataSizeZ();
// int maxY=sizeZ+2;
-
+
maxX= interfMainPanel::getInstance()->getNumberColsInformationPanel();//this->_grid->GetNumberCols();
// -- Title --
}
fprintf(pFile,"\n\n" );
-
-
+
+
if (selection==0 ) // actual slice
{
std::vector<int> tempVector;
minZ = actualSlice;
maxZ = actualSlice;
}
-
+
// Stadistics...
for ( j=minZ; j<=maxZ ; j++)
{
fprintf(pFile,"\n" );
} // for j
-
+
// Total of stadistics.....
if (selection!=0)
{
} // for i
fprintf(pFile,"\n" );
}
-
+
fclose(pFile);
}
}
void wxContourMainFrame::SaveValuesXYZ(std::string directory,std::string namefile,int typeContourGroup)
{
wxBusyCursor wait;
-//EED01Juillet2009 GenerateContourExtractData();
-
+
//int typeContourGroup = this->_radiolstboxContourGroup->GetSelection();
_contourextractdata ->SetTypeOperation( typeContourGroup % 3 );
std::vector<int> tempVector;
_instantPanel->getInstant( tempVector );
-//EED01Juillet2009 vtkImageData *imagedata = _theViewPanel->getSceneManager()->GetImageData();
int sizeZ = _theViewPanel->getSceneManager()->GetImageDataSizeZ();
int z;
int ii,sizeLstContourThings;
int minZ,maxZ;
double totalZ;
- double porcent;
+ double porcent;
wxString tmpString;
minZ = 0;// _mbarrange->GetStart();
maxZ = sizeZ;//_mbarrange->GetEnd();
totalZ = maxZ-minZ+1;
-//EED01Juillet2009 _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);
pLstValuePosX.clear();
pLstValuePosY.clear();
pLstValuePosZ.clear();
- _contourextractdata->GetValuesInsideCrown( &pLstValue,
+ int numberOfPixels;
+ _contourextractdata->GetValuesInsideCrown( &numberOfPixels,
+ &pLstValue,
&pLstValuePosX,
&pLstValuePosY,
&pLstValuePosZ);
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" );
void wxContourMainFrame::getMaskValue(vtkImageData ** mask,vtkImageData ** value,int typeContourGroup, int selection, int minZ, int maxZ){
wxBusyCursor wait;
-//EED01Juillet2009 GenerateContourExtractData();
//int typeContourGroup = this->_radiolstboxContourGroup->GetSelection();
if (typeContourGroup==3)
int z;
int ii,sizeLstContourThings;
-
double totalZ;
- double porcent;
+ double porcent;
wxString tmpString;
-
-
+
+
if (selection==0 ) // actual slice
{
int actualSlice = tempVector[1];
minZ = actualSlice;
maxZ = actualSlice;
- }
-
+ }
+
totalZ = maxZ-minZ;
-//EED01Juillet2009 _contourextractdata->SetImage( imagedata);
- // cleanning image before range
+ // cleanning image before range
for (z=0; z<minZ; z++){
_contourextractdata->ResetImageResult(z);
}
- // cleanning image after range
+ // cleanning image after range
for (z=maxZ+1; z<sizeZimage; z++){
_contourextractdata->ResetImageResult(z);
}
-
-
+
+
// For each slice..
for ( z=minZ ; z<=maxZ ; z++)
{
}
+std::string wxContourMainFrame::GetStringTypeImage( vtkImageData* image)
+{
+ std::string result="";
+ if ( image->GetScalarType()==VTK_CHAR )
+ {
+ result="CHAR";
+ } else if ( image->GetScalarType()==VTK_UNSIGNED_CHAR ){
+ result="UCHAR";
+ } else if ( image->GetScalarType()==VTK_FLOAT ){
+ result="FLOAT";
+ } else if ( image->GetScalarType()==VTK_DOUBLE ){
+ result="DOUBLE";
+ } else if ( image->GetScalarType()==VTK_INT ){
+ result="INT";
+ } else if ( image->GetScalarType()==VTK_UNSIGNED_INT ){
+ result="UINT";
+ } else if ( image->GetScalarType()==VTK_SHORT ){
+ result="SHORT";
+ } else if ( image->GetScalarType()==VTK_UNSIGNED_SHORT ){
+ result="USHORT";
+ } else if ( image->GetScalarType()==VTK_LONG ){
+ result="LONG";
+ } else if ( image->GetScalarType()==VTK_UNSIGNED_LONG ){
+ result="ULONG";
+ }
+ return result;
+}
+
void wxContourMainFrame::SaveImageResult(std::string directory,std::string namefile, vtkImageData* mask,vtkImageData* value)
{
-
- std::string temp = directory + "/" + namefile + "-Value.mhd";
+ std::string stringType;
+ double spc[3];
+ kernelManager->GetSpacing(spc,0); // returns the spacing of the first image
+ stringType = GetStringTypeImage(value);
+ std::string temp = directory + "/" + namefile + "-image-Value-"+stringType+".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
+
+ vtkImageChangeInformation *valueChInfo = vtkImageChangeInformation::New();
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ valueChInfo->SetInput(value);
+#else
+ valueChInfo->SetInputData(value);
+#endif
+ valueChInfo->SetSpacingScale(spc);
+ valueChInfo->Update();
vtkMetaImageWriter *writerValueImage = vtkMetaImageWriter::New( );
- writerValueImage->SetInput( value );
+
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ writerValueImage->SetInput( valueChInfo->GetOutput() );
+#else
+ writerValueImage->SetInputData( valueChInfo->GetOutput() );
+#endif
writerValueImage->SetFileName( (const char *)filename.mb_str() );
writerValueImage->SetFileDimensionality( 3 );
+ writerValueImage->SetCompression(false);
writerValueImage->Write( );
// Image Mask
- // filename.Printf("%s\\%s-Mask.mhd",directory.c_str(),namefile.c_str(),z);
- temp = directory + "/" + namefile + "-Mask.mhd";
+ stringType = GetStringTypeImage(mask);
+ temp = directory + "/" + namefile + "-image-Mask-"+stringType+".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"));*/
+ vtkImageChangeInformation *maskChInfo = vtkImageChangeInformation::New();
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ maskChInfo->SetInput(mask);
+#else
+ maskChInfo->SetInputData(mask);
+#endif
+ maskChInfo->SetSpacingScale(spc);
+ maskChInfo->Update();
vtkMetaImageWriter *writerMaskImage = vtkMetaImageWriter::New( );
- writerMaskImage->SetInput( mask );
+
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ writerMaskImage->SetInput( maskChInfo->GetOutput() );
+#else
+ writerMaskImage->SetInputData( maskChInfo->GetOutput() );
+#endif
+
writerMaskImage->SetFileName( (const char *)filename.mb_str() );
writerMaskImage->SetFileDimensionality( 3 );
+ writerMaskImage->SetCompression(false);
writerMaskImage->Write( );
interfMainPanel::getInstance()->setStringInfoPanel( _T("") );
-
+
}
}
void wxContourMainFrame::onSnakePressed(){
- std::vector<double> vecX;
- std::vector<double> vecY;
- std::vector<double> vecZ;
- _theViewPanel->GetPointsOfActualContour( &vecX , &vecY , &vecZ );
+ std::vector<double> vecX;
+ std::vector<double> vecY;
+ std::vector<double> vecZ;
+ _theViewPanel->GetPointsOfActualContour( &vecX , &vecY , &vecZ );
if (vecX.size()!=0){
std::vector<int> tempVector;
} // for
wxDialog* dialog = new wxDialog(this, -1, wxString(_T("Snake")));
- wxPanel* panel = new wxPanel(dialog,-1);
+ wxPanel* panel = new wxPanel(dialog,-1);
// wxStaticText* sttext = new wxStaticText(panel, -1, wxString(_T("Panel para snake")));
new wxStaticText(panel, -1, wxString(_T("Panel para snake")));
dialog->ShowModal();
- } // if
+ } // if
}
-void wxContourMainFrame::saveFileWithContoursAutomatique(){
+void wxContourMainFrame::saveFileWithContoursAutomatique()
+{
+printf("EED wxContourMainFrame::saveFileWithContoursAutomatique \n");
std::string filename = kernelManager->getCurrentFileName();
if(filename.compare("")!=0){
saveFileWithContours(filename);
onSave();
}
}
-void wxContourMainFrame::ShowToolsPanel(bool show){
+void wxContourMainFrame::ShowToolsPanel(bool show)
+{
_pannew->Show(show);
}
wxPanel *wxContourMainFrame::getMaskImageViewPanel(wxWindow *parent)
{
-
+
if (_viewMaskImagePanel==NULL)
{
_contourextractdata = new ContourExtractData(true);
_contourextractdata->SetImage( _theViewPanel->getImageData() );
-
// double range[2];
// _theViewPanel->getImageData()->GetScalarRange(range);
//int min = (int)floor (range[0]);
//int max = (int)ceil (range[1]);
+
+//EED 2017-12-17
int min = 254;
int max = 256;
-
- _viewMaskImagePanel = new ThresholdImageViewPanel( parent, -1, -1 , 0);
+
+ _viewMaskImagePanel = new ThresholdImageViewPanel( parent, -1, -1 , -1,-1, 0);
_viewMaskImage = new ThresholdImageView();
- _viewMaskImage->SetImage(_contourextractdata->GetVtkImageMaskResult() );
+ _viewMaskImage->SetImage( _contourextractdata->GetVtkImageMaskResult() );
_viewMaskImage->SetminMaxValue( min, max);
_viewMaskImage->SetBaseColor( 0,0,1 );
+
+
+ std::vector<int> colorbarposition;
+ colorbarposition.push_back( -999 );
+ colorbarposition.push_back( -999 );
+ _viewMaskImage->SetColorBarPosition( colorbarposition );
+ double spc[3];
+ _viewMaskImage->SetSpcBase( _theViewPanel->getImageData()->GetSpacing() );
+ _viewMaskImage->SetNewSpacingLayer( _theViewPanel->getImageData()->GetSpacing() );
+
_viewMaskImagePanel->SetThresholdImageView( _viewMaskImage );
_viewMaskImage->SetwxVtkBaseView( _theViewPanel->getWxVtkBaseView() );
-
+ _viewMaskImage->onThresholdChangeOpacity( 25 );
}
return _viewMaskImagePanel;
}
+
+wxPanel *wxContourMainFrame::getColorLayerImageViewPanel(wxWindow *parent)
+{
+ if (_viewColorLayerImagePanel==NULL)
+ {
+ double range[2];
+ _theViewPanel->getImageData()->GetScalarRange(range);
+ int min = (int)floor (range[0]);
+ int max = (int)ceil (range[1]);
+ _viewColorLayerImagePanel = new ColorLayerImageViewPanel( parent, min, max, 100, 1);
+ _viewColorLayerImagePanel->GetColorLayerImageViewManager()->SetwxVtkBaseView( 0 , _theViewPanel->getWxVtkBaseView() );
+ // std::vector<double> range = bbGetInputlstRangeForColorBar();
+ // clivp->GetColorLayerImageViewManager()->SetRangeForColorBar( range );
+ std::vector<int> colorbarposition;
+ colorbarposition.push_back( 50 );
+ colorbarposition.push_back( 105 );
+ _viewColorLayerImagePanel->GetColorLayerImageViewManager()->SetColorBarPosition( colorbarposition );
+ // std::vector<double> base_color;
+ // _viewColorLayerImagePanel->GetColorLayerImageViewManager()->SetBaseColors( base_color );
+ // std::vector<double> grey_level_boundaries;
+ // clivp->GetColorLayerImageViewManager()->SetGreyLevelBoundaries( grey_level_boundaries );
+ std::vector<double> transparence_level_boundaries;
+ transparence_level_boundaries.push_back(0);
+ _viewColorLayerImagePanel->GetColorLayerImageViewManager()->SetBaseTransparence( transparence_level_boundaries );
+ _viewColorLayerImagePanel->GetColorLayerImageViewManager()->SetPlainOrGradientColor( false );
+// _viewColorLayerImagePanel->SetFittingMode( 3 );
+ }
+ return _viewColorLayerImagePanel;
+}
+
+void wxContourMainFrame::SetColorLayerImage(vtkImageData* img)
+{
+ if (_viewColorLayerImagePanel!=NULL)
+ {
+ if (img!=NULL)
+ {
+ _viewColorLayerImagePanel->SetActive(true);
+ _viewColorLayerImagePanel->SetImage( img );
+// RefreshInterface();
+ } // img
+ } // _viewColorLayerImagePanel
+}
+
wxPanel *wxContourMainFrame::getThresholdImageViewPanel(wxWindow *parent)
{
if (_viewThresholdImagePanel==NULL)
{
double range[2];
_theViewPanel->getImageData()->GetScalarRange(range);
- int min = (int)floor (range[0]);
- int max = (int)ceil (range[1]);
- _viewThresholdImagePanel = new ThresholdImageViewPanel( parent, min, max , 1);
- _viewThresholdImage = new ThresholdImageView();
+ int min = (int)floor (range[0]);
+ int max = (int)ceil (range[1]);
+ int start = (max+min)/2 - (max-min)*0.25;
+ int end = (max+min)/2 + (max-min)*0.25;
+ _viewThresholdImagePanel = new ThresholdImageViewPanel( parent, min, max, start, end , 1);
+ _viewThresholdImage = new ThresholdImageView();
+ _viewThresholdImage->SetminMaxValue(start,end);
+// _viewThresholdImage->SetminMaxValue(range[0],range[1]);
_viewThresholdImage->SetImage( _theViewPanel->getImageData() );
- _viewThresholdImage->SetminMaxValue( min, max);
+ std::vector<int> colorbarposition;
+ colorbarposition.push_back( 10 );
+ colorbarposition.push_back( 105 );
+ _viewThresholdImage->SetColorBarPosition( colorbarposition );
+ double spc[3];
+ _viewThresholdImage->SetSpcBase( _theViewPanel->getImageData()->GetSpacing() );
+ _viewThresholdImage->SetNewSpacingLayer( _theViewPanel->getImageData()->GetSpacing() );
+
_viewThresholdImage->SetBaseColor( 1,0,0 );
_viewThresholdImagePanel->SetThresholdImageView( _viewThresholdImage );
_viewThresholdImage->SetwxVtkBaseView( _theViewPanel->getWxVtkBaseView() );
+ _viewThresholdImage->onThresholdChangeOpacity( 25 );
+ RefreshInterface();
}
return _viewThresholdImagePanel;
}
{
std::string cloneName = currentSelection [0];
manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(cloneName);
- tipo = manualModel-> GetTypeModel();
+ tipo = manualModel-> GetTypeModel();
}
return tipo;
}
double wxContourMainFrame::getContourSizeInPixels()
{
- double contourSize = 0;
+ double contourSize = 0;
std::vector<std::string> currentSelection = _theViewPanel->getSelectedObjects(); if(!currentSelection.empty())
if(!currentSelection.empty())
{
std::string cloneName = currentSelection [0];
-
+
manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(cloneName);//_modelManager->getOutlineByKeyName( cloneName )->getModel();
- contourSize = manualModel-> GetPathSize();
- }
+
+// EED 2017-05-30
+// contourSize = manualModel->GetPathSize();
+ double spc[3];
+ spc[0]=1;
+ spc[1]=1;
+ spc[2]=1;
+ contourSize = manualModel->GetPathSize( spc );
+ }
return contourSize;
}
+
manualBaseModel * wxContourMainFrame::getContour ()
{
std::vector<std::string> currentSelection = _theViewPanel->getSelectedObjects();
{
std::string cloneName = currentSelection [0];
manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(cloneName);//_modelManager->getOutlineByKeyName( cloneName )->getModel();
- return manualModel;
+ return manualModel;
}
return NULL;
}
-void wxContourMainFrame::onPrintLabel (wxString label, manualBaseModel* manualModel)
+void wxContourMainFrame::onPrintLabel (wxString label, manualBaseModel* manualModel)
{
std::string labelAscii(label.ToAscii());
int pos = labelAscii.find(" ");
int j;
-
- for (j=0 ; pos != string::npos;j++)
+
+ for (j=0 ; pos != string::npos;j++)
{
labelAscii.replace( pos, 1, "_" );
pos= labelAscii.find(" ");
}
- manualModel -> SetLabel(labelAscii);
+ manualModel -> SetLabel(labelAscii);
}
void wxContourMainFrame::onInsertCalculation(manualBaseModel* manualModel)
{
- double sizeInPixel = manualModel ->GetPathSize();
+// EED 2017-05-30
+// double sizeInPixel = manualModel ->GetPathSize( );
+ double spc[3];
+ spc[0]=1; // ????
+ spc[1]=1; // ????
+ spc[2]=1; // ????
+ double sizeInPixel = manualModel ->GetPathSize( spc );
+
double onePixelRealSize = interfMainPanel::getInstance()->GetPixelValue();;
- double realContourSize = sizeInPixel*onePixelRealSize;
- manualModel ->SetRealSize(realContourSize);
+ double realContourSize = sizeInPixel*onePixelRealSize;
+ manualModel ->SetRealSize(realContourSize);
}
double wxContourMainFrame::onePixelSize( double value)
{
- return _onePixelSize = value;
+ return _onePixelSize = value;
}
std::string wxContourMainFrame::GetFileLocation()
{
_fileLocation = newFileLocation;
std::cout<<"GETFILELOCATION:"<<_fileLocation<<std::endl;
+
+//EED 2019-12-17
+ kernelManager->setCurrentFileName(_fileLocation);
+}
+//------------------------------------------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+void wxContourMainFrame::FlipSelectedContours(int flipDirection)
+{
+ FlipLstOfContours(
+ (std::vector<std::string>)_theViewPanel->getSceneManager()->getSelectedObjects() ,
+ flipDirection
+ );
+
+}
+
+void wxContourMainFrame::FlipActualSliceContours(int flipDirection)
+{
+ FlipLstOfContours(
+ (std::vector<std::string>)_theViewPanel->getSceneManager()->GetlstContoursNameActualSlice() ,
+ flipDirection
+ );
+}
+
+void wxContourMainFrame::FlipAllContours(int flipDirection)
+{
+ FlipLstOfContours(
+ kernelManager->GetLstNameThings() ,
+ flipDirection
+ );
+}
+
+void wxContourMainFrame::FlipLstOfContours(std::vector<std::string> lstNameThings, int flipDirection)
+{
+ int ext[6];
+ getImageData()->GetExtent(ext);
+ int sizeX = ext[1]-ext[0];
+ int sizeY = ext[3]-ext[2];
+
+
+ int i,sizeLstNameThings;
+ int ii,sizeLstPoints;
+
+ sizeLstNameThings = lstNameThings.size();
+ for (i=0 ; i<sizeLstNameThings ; i++)
+ {
+ manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(lstNameThings[i]);
+ if (flipDirection==0)
+ {
+ manualModel->Transform_Ax_Plus_B(-1,sizeX,1,0 );
+ } else {
+ manualModel->Transform_Ax_Plus_B(1,0,-1,sizeY );
+ }
+ }// for i list of Things
+
+ //-- Static Contours
+
+ lstNameThings = kernelManager->GetLstNameThingsStatic();
+ sizeLstNameThings = lstNameThings.size();
+ for (i=0 ; i<sizeLstNameThings ; i++)
+ {
+ manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(lstNameThings[i]);
+ if (flipDirection==0)
+ {
+ manualModel->Transform_Ax_Plus_B(-1,sizeX,1,0 );
+ } else {
+ manualModel->Transform_Ax_Plus_B(1,0,-1,sizeY );
+ }
+ }// for i list of static things
+}
+
+void wxContourMainFrame::FlipContours(int typeContourFlip, int flipDirection)
+{
+ saveState();
+
+ if (typeContourFlip==0) //
+ {
+ FlipSelectedContours(flipDirection);
+ }
+
+ if (typeContourFlip==1) //
+ {
+ FlipActualSliceContours(flipDirection);
+ }
+
+ if (typeContourFlip==2) //
+ {
+ FlipAllContours(flipDirection);
+ }
+ RefreshInterface();
+}
+
+void wxContourMainFrame::SetXY(int x, int y)
+{
+ _theViewPanel->SetXY(x,y);
+}
+
+wxVtkBaseView* wxContourMainFrame::GetWxVtkBaseView()
+{
+ if (_theViewPanel!=NULL)
+ {
+ return _theViewPanel->getWxVtkBaseView();;
+ } else {
+ return NULL;
+ }
}
-//------------------------------------------------------------------------------------------------------------
\ No newline at end of file
+
+
+
git://git.creatis.insa-lyon.fr / creaContours.git / blobdiff