diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp index 5faefe9e69..b6dc8c13b4 100644 --- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp +++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.cpp @@ -1,857 +1,1239 @@ /*========================================================================= Program: Medical Imaging & Interaction Toolkit Language: C++ Date: $Date: 2010-03-31 16:40:27 +0200 (Mi, 31 Mrz 2010) $ Version: $Revision: 21975 $ Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. See MITKCopyright.txt or http://www.mitk.org/copyright.html for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ //=========FOR TESTING========== //random generation, number of points equal requested points // Blueberry application and interaction service #include #include // Qmitk #include "QmitkFiberBundleDeveloperView.h" #include // Qt #include // MITK -//#include //for fiberStructure -#include + //===needed when timeSlicedGeometry is null to invoke rendering mechansims ==== #include #include // VTK #include //for randomized FiberStructure #include //for fiberStructure #include //for fiberStructure #include //for geometry //ITK #include //============================================== //======== W O R K E R S ____ S T A R T ======== //============================================== /*=================================================================================== * THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD * --generate FiberIDs--*/ QmitkFiberIDWorker::QmitkFiberIDWorker(QThread* hostingThread, Package4WorkingThread itemPackage) : m_itemPackage(itemPackage), m_hostingThread(hostingThread) { } void QmitkFiberIDWorker::run() { + if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked()) + m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING); /* MEASUREMENTS AND FANCY GUI EFFECTS * accurate time measurement using ITK timeProbe*/ itk::TimeProbe clock; clock.Start(); //set GUI representation of timer to 0, is essential for correct timer incrementation m_itemPackage.st_Controls->infoTimerGenerateFiberIds->setText(QString::number(0)); m_itemPackage.st_FancyGUITimer1->start(); //do processing m_itemPackage.st_FBX->DoGenerateFiberIds(); /* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */ clock.Stop(); m_itemPackage.st_FancyGUITimer1->stop(); m_itemPackage.st_Controls->infoTimerGenerateFiberIds->setText( QString::number(clock.GetTotal()) ); delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore m_hostingThread->quit(); } /*=================================================================================== * THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD * --generate random fibers--*/ QmitkFiberGenerateRandomWorker::QmitkFiberGenerateRandomWorker(QThread* hostingThread, Package4WorkingThread itemPackage) : m_itemPackage(itemPackage), m_hostingThread(hostingThread) { } void QmitkFiberGenerateRandomWorker::run() { - + if(m_itemPackage.st_Controls->checkBoxMonitorFiberThreads->isChecked()) + m_itemPackage.st_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_RUNNING); + /* MEASUREMENTS AND FANCY GUI EFFECTS */ m_itemPackage.st_Controls->infoTimerGenerateFiberBundle->setText(QString::number(0)); m_itemPackage.st_FancyGUITimer1->start(); //do processing, generateRandomFibers int numOfFibers = m_itemPackage.st_Controls->boxFiberNumbers->value(); int distrRadius = m_itemPackage.st_Controls->boxDistributionRadius->value(); int numOfPoints = numOfFibers * distrRadius; std::vector< std::vector > fiberStorage; for (int i=0; i a; fiberStorage.push_back( a ); } /* Generate Point Cloud */ vtkSmartPointer randomPoints = vtkSmartPointer::New(); randomPoints->SetCenter(0.0, 0.0, 0.0); randomPoints->SetNumberOfPoints(numOfPoints); randomPoints->SetRadius(distrRadius); randomPoints->Update(); vtkPoints* pnts = randomPoints->GetOutput()->GetPoints(); /* ASSIGN EACH POINT TO A RANDOM FIBER */ srand((unsigned)time(0)); // init randomizer for (int i=0; iGetNumberOfPoints(); ++i) { //generate random number between 0 and numOfFibers-1 int random_integer; random_integer = (rand()%numOfFibers); //add current point to random fiber fiberStorage.at(random_integer).push_back(i); // MITK_INFO << "point" << i << " |" << pnts->GetPoint(random_integer)[0] << "|" << pnts->GetPoint(random_integer)[1]<< "|" << pnts->GetPoint(random_integer)[2] << "| into fiber" << random_integer; } // initialize accurate time measurement itk::TimeProbe clock; clock.Start(); /* GENERATE VTK POLYLINES OUT OF FIBERSTORAGE */ vtkSmartPointer linesCell = vtkSmartPointer::New(); // Host vtkPolyLines linesCell->Allocate(pnts->GetNumberOfPoints()*2); //allocate for each cellindex also space for the pointId, e.g. [idx | pntID] for (unsigned long i=0; i singleFiber = fiberStorage.at(i); vtkSmartPointer fiber = vtkSmartPointer::New(); fiber->GetPointIds()->SetNumberOfIds((int)singleFiber.size()); for (unsigned long si=0; siGetPointIds()->SetId( si, singleFiber.at(si) ); } linesCell->InsertNextCell(fiber); } /* checkpoint for cellarray allocation */ if ( (linesCell->GetSize()/pnts->GetNumberOfPoints()) != 2 ) //e.g. size: 12, number of points:6 .... each cell hosts point ids (6 ids) + cell index for each idPoint. 6 * 2 = 12 { MITK_INFO << "RANDOM FIBER ALLOCATION CAN NOT BE TRUSTED ANYMORE! Correct leak or remove command: linesCell->Allocate(pnts->GetNumberOfPoints()*2) but be aware of possible loss in performance."; } /* HOSTING POLYDATA FOR RANDOM FIBERSTRUCTURE */ vtkPolyData* PDRandom = vtkPolyData::New(); //no need to delete because data is needed in datastorage. PDRandom->SetPoints(pnts); PDRandom->SetLines(linesCell); // accurate timer measurement stop clock.Stop(); //MITK_INFO << "=====Assambling random Fibers to Polydata======\nMean: " << clock.GetMean() << " Total: " << clock.GetTotal() << std::endl; // call function to convert fiberstructure into fiberbundleX and pass it to datastorage (m_itemPackage.st_host->*m_itemPackage.st_pntr_to_Method_PutFibersToDataStorage)(PDRandom); /* MEASUREMENTS AND FANCY GUI EFFECTS CLEANUP */ m_itemPackage.st_FancyGUITimer1->stop(); m_itemPackage.st_Controls->infoTimerGenerateFiberBundle->setText( QString::number(clock.GetTotal()) ); delete m_itemPackage.st_FancyGUITimer1; // fancy timer is not needed anymore m_hostingThread->quit(); } + +/*=================================================================================== + * THIS METHOD IMPLEMENTS THE ACTIONS WHICH SHALL BE EXECUTED by the according THREAD + * --update GUI elements of thread monitor-- + * implementation not thread safe, not needed so far because + * there exists only 1 thread for fiberprocessing + * for threadsafety, you need to implement checking mechanisms in methods "::threadFor...." */ +QmitkFiberThreadMonitorWorker::QmitkFiberThreadMonitorWorker( QThread* hostingThread, Package4WorkingThread itemPackage ) +: m_itemPackage(itemPackage) +, m_hostingThread(hostingThread) +, m_pixelstepper(10) //for next rendering call, move object 10px +, m_steppingDistance(220) //use only a multiple value of pixelstepper, x-axis border for fancy stuff +{ + + + //set timers + m_thtimer_initMonitor = new QTimer; + m_thtimer_initMonitor->setInterval(10); + + m_thtimer_initMonitorSetFinalPosition = new QTimer; + m_thtimer_initMonitorSetFinalPosition->setInterval(10); + + m_thtimer_initMonitorSetMasks = new QTimer; + m_thtimer_initMonitorSetFinalPosition->setInterval(10); + + + m_thtimer_threadStarted = new QTimer; + m_thtimer_threadStarted->setInterval(50); + + m_thtimer_threadFinished = new QTimer; + m_thtimer_threadFinished->setInterval(50); + + m_thtimer_threadTerminated = new QTimer; + m_thtimer_threadTerminated->setInterval(50); + + + + connect (m_thtimer_initMonitor, SIGNAL( timeout()), this, SLOT( fancyMonitorInitialization() ) ); + connect ( m_thtimer_initMonitorSetFinalPosition, SIGNAL( timeout() ), this, SLOT( fancyMonitorInitializationFinalPos() ) ); + connect ( m_thtimer_initMonitorSetMasks, SIGNAL( timeout() ), this, SLOT( fancyMonitorInitializationMask() ) ); + + connect (m_thtimer_threadStarted, SIGNAL( timeout()), this, SLOT( fancyTextFading_threadStarted() ) ); + connect (m_thtimer_threadFinished, SIGNAL( timeout()), this, SLOT( fancyTextFading_threadFinished() ) ); + connect (m_thtimer_threadTerminated, SIGNAL( timeout()), this, SLOT( fancyTextFading_threadTerminated() ) ); + + //first, the current text shall turn transparent + m_decreaseOpacity_threadStarted = true; + m_decreaseOpacity_threadFinished = true; + m_decreaseOpacity_threadTerminated = true; + + + + +} +void QmitkFiberThreadMonitorWorker::run() +{ + +} + +void QmitkFiberThreadMonitorWorker::initializeMonitor() +{ + //fancy configuration of animation start + mitk::Point2D pntOpen; + pntOpen[0] = 118; + pntOpen[1] = 10; + + mitk::Point2D headPos; + headPos[0] = 19; + headPos[1] = 10; + + mitk::Point2D statusPos; + statusPos[0] = 105; + statusPos[1] = 23; + + mitk::Point2D startedPos; + startedPos[0] = 68; + startedPos[1] = 10; + + mitk::Point2D finishedPos; + finishedPos[0] = 143; + finishedPos[1] = 10; + + mitk::Point2D terminatedPos; + terminatedPos[0] = 240; + terminatedPos[1] = 10; + + m_itemPackage.st_FBX_Monitor->setBracketClosePosition(pntOpen); + m_itemPackage.st_FBX_Monitor->setBracketOpenPosition(pntOpen); + m_itemPackage.st_FBX_Monitor->setHeadingPosition(headPos); + m_itemPackage.st_FBX_Monitor->setMaskPosition(headPos); + m_itemPackage.st_FBX_Monitor->setStatusPosition(statusPos); + m_itemPackage.st_FBX_Monitor->setStartedPosition(startedPos); + m_itemPackage.st_FBX_Monitor->setFinishedPosition(finishedPos); + m_itemPackage.st_FBX_Monitor->setTerminatedPosition(terminatedPos); + + + m_thtimer_initMonitor->start(); +} + +void QmitkFiberThreadMonitorWorker::setThreadStatus(QString status) +{ + m_itemPackage.st_FBX_Monitor->setStatus(status); + m_itemPackage.st_ThreadMonitorDataNode->Modified(); + m_itemPackage.st_MultiWidget->RequestUpdate(); +} + +void QmitkFiberThreadMonitorWorker::threadForFiberProcessingStarted() +{ + if(!m_thtimer_threadStarted->isActive()) { + m_thtimer_threadStarted->start(); + } else { + //fast change without fancy stuff + int counter = m_itemPackage.st_FBX_Monitor->getStarted(); + m_itemPackage.st_FBX_Monitor->setStarted(++counter); + + } + + +} + +void QmitkFiberThreadMonitorWorker::threadForFiberProcessingFinished() +{ + if(!m_thtimer_threadFinished->isActive()) { + m_thtimer_threadFinished->start(); + } else { + //fast change without fancy stuff + int counter = m_itemPackage.st_FBX_Monitor->getFinished(); + m_itemPackage.st_FBX_Monitor->setFinished(++counter); + + } + +} + +void QmitkFiberThreadMonitorWorker::threadForFiberProcessingTerminated() +{ + if(!m_thtimer_threadTerminated->isActive()) { + m_thtimer_threadTerminated->start(); + } else { + //fast change without fancy stuff + int counter = m_itemPackage.st_FBX_Monitor->getTerminated(); + m_itemPackage.st_FBX_Monitor->setTerminated(++counter); + + } + +} + + + +void QmitkFiberThreadMonitorWorker::fancyTextFading_threadStarted() +{ + + if (m_decreaseOpacity_threadStarted) { + int startedOpacity = m_itemPackage.st_FBX_Monitor->getStartedOpacity(); + m_itemPackage.st_FBX_Monitor->setStartedOpacity( --startedOpacity ); + + if (startedOpacity == 0) { + int counter = m_itemPackage.st_FBX_Monitor->getStarted(); + m_itemPackage.st_FBX_Monitor->setStarted(++counter); + m_decreaseOpacity_threadStarted = false; + } + m_itemPackage.st_ThreadMonitorDataNode->Modified(); + m_itemPackage.st_MultiWidget->RequestUpdate(); + + } else { + + int startedOpacity = m_itemPackage.st_FBX_Monitor->getStartedOpacity(); + m_itemPackage.st_FBX_Monitor->setStartedOpacity( ++startedOpacity ); + + if (startedOpacity >= 10) { + m_thtimer_threadStarted->stop(); + m_decreaseOpacity_threadStarted = true; //set back to true, cuz next iteration shall decrease opacity as well + } + + m_itemPackage.st_ThreadMonitorDataNode->Modified(); + m_itemPackage.st_MultiWidget->RequestUpdate(); + + } + + +} + +void QmitkFiberThreadMonitorWorker::fancyTextFading_threadFinished() +{ + if (m_decreaseOpacity_threadFinished) { + int finishedOpacity = m_itemPackage.st_FBX_Monitor->getFinishedOpacity(); + m_itemPackage.st_FBX_Monitor->setFinishedOpacity( --finishedOpacity ); + + if (finishedOpacity == 0) { + int counter = m_itemPackage.st_FBX_Monitor->getFinished(); + m_itemPackage.st_FBX_Monitor->setFinished(++counter); + m_decreaseOpacity_threadFinished = false; + } + m_itemPackage.st_ThreadMonitorDataNode->Modified(); + m_itemPackage.st_MultiWidget->RequestUpdate(); + + } else { + + int finishedOpacity = m_itemPackage.st_FBX_Monitor->getFinishedOpacity(); + m_itemPackage.st_FBX_Monitor->setFinishedOpacity( ++finishedOpacity ); + + if (finishedOpacity >= 10) { + m_thtimer_threadFinished->stop(); + m_decreaseOpacity_threadFinished = true; //set back to true, cuz next iteration shall decrease opacity as well + } + + m_itemPackage.st_ThreadMonitorDataNode->Modified(); + m_itemPackage.st_MultiWidget->RequestUpdate(); + + } + +} + +void QmitkFiberThreadMonitorWorker::fancyTextFading_threadTerminated() +{ + if (m_decreaseOpacity_threadTerminated) { + int terminatedOpacity = m_itemPackage.st_FBX_Monitor->getTerminatedOpacity(); + m_itemPackage.st_FBX_Monitor->setTerminatedOpacity( --terminatedOpacity ); + + if (terminatedOpacity == 0) { + int counter = m_itemPackage.st_FBX_Monitor->getTerminated(); + m_itemPackage.st_FBX_Monitor->setTerminated(++counter); + m_decreaseOpacity_threadTerminated = false; + } + m_itemPackage.st_ThreadMonitorDataNode->Modified(); + m_itemPackage.st_MultiWidget->RequestUpdate(); + + } else { + + int terminatedOpacity = m_itemPackage.st_FBX_Monitor->getTerminatedOpacity(); + m_itemPackage.st_FBX_Monitor->setTerminatedOpacity( ++terminatedOpacity ); + + if (terminatedOpacity >= 10) { + m_thtimer_threadTerminated->stop(); + m_decreaseOpacity_threadTerminated = true; //set back to true, cuz next iteration shall decrease opacity as well + } + + m_itemPackage.st_ThreadMonitorDataNode->Modified(); + m_itemPackage.st_MultiWidget->RequestUpdate(); + + } + + + +} + +void QmitkFiberThreadMonitorWorker::fancyMonitorInitialization() +{ + + mitk::Point2D pntClose = m_itemPackage.st_FBX_Monitor->getBracketClosePosition(); //possible bottleneck, set pntClose to member + mitk::Point2D pntOpen = m_itemPackage.st_FBX_Monitor->getBracketOpenPosition(); //possible bottleneck, set pntClose to member + + pntClose[0] += m_pixelstepper; + pntOpen[0] -= m_pixelstepper; + //MITK_INFO << pntClose[0] << " " << pntOpen[0]; + + m_itemPackage.st_FBX_Monitor->setBracketClosePosition(pntClose); + m_itemPackage.st_FBX_Monitor->setBracketOpenPosition(pntOpen); + + int opacity = m_itemPackage.st_FBX_Monitor->getHeadingOpacity() + 1; + if (opacity > 10) + opacity = 10; + m_itemPackage.st_FBX_Monitor->setHeadingOpacity(opacity); + + + if (pntClose[0] >= m_steppingDistance) + { + if (m_itemPackage.st_FBX_Monitor->getHeadingOpacity() != 10 ) + { + m_itemPackage.st_FBX_Monitor->setHeadingOpacity(10); + m_itemPackage.st_ThreadMonitorDataNode->Modified(); + m_itemPackage.st_MultiWidget->RequestUpdate(); + } + + m_thtimer_initMonitor->stop(); + + //position them to obt y=25 + m_thtimer_initMonitorSetFinalPosition->start(); + } + + m_itemPackage.st_ThreadMonitorDataNode->Modified(); + m_itemPackage.st_MultiWidget->RequestUpdate(); + + +} + +void QmitkFiberThreadMonitorWorker::fancyMonitorInitializationFinalPos() +{ + //get y pos of + mitk::Point2D pntClose = m_itemPackage.st_FBX_Monitor->getBracketClosePosition(); + mitk::Point2D pntOpen = m_itemPackage.st_FBX_Monitor->getBracketOpenPosition(); + mitk::Point2D pntHead = m_itemPackage.st_FBX_Monitor->getHeadingPosition(); + + pntClose[1] += 5; + pntOpen[1] += 5; + pntHead[1] += 5; + + m_itemPackage.st_FBX_Monitor->setBracketClosePosition(pntClose); + m_itemPackage.st_FBX_Monitor->setBracketOpenPosition(pntOpen); + m_itemPackage.st_FBX_Monitor->setHeadingPosition(pntHead); + + + if (pntClose[1] >= 35) { //35 = y position + m_thtimer_initMonitorSetFinalPosition->stop(); + //now init mask of labels + m_thtimer_initMonitorSetMasks->start(); + } + + m_itemPackage.st_ThreadMonitorDataNode->Modified(); + m_itemPackage.st_MultiWidget->RequestUpdate(); + +} + +void QmitkFiberThreadMonitorWorker::fancyMonitorInitializationMask() +{ + //increase opacity + int opacity = m_itemPackage.st_FBX_Monitor->getMaskOpacity(); + opacity++; + m_itemPackage.st_FBX_Monitor->setMaskOpacity(opacity); + m_itemPackage.st_FBX_Monitor->setStartedOpacity(opacity); + m_itemPackage.st_FBX_Monitor->setFinishedOpacity(opacity); + m_itemPackage.st_FBX_Monitor->setTerminatedOpacity(opacity); + m_itemPackage.st_FBX_Monitor->setStatusOpacity(opacity); + + if (opacity >=10) { + m_thtimer_initMonitorSetMasks->stop(); + } + + m_itemPackage.st_ThreadMonitorDataNode->Modified(); + m_itemPackage.st_MultiWidget->RequestUpdate(); + +} //============================================== //======== W O R K E R S ________ E N D ======== //============================================== -// ========= HERE STARTS THE ACTUAL FIBERBUNDLE DEVELOPER VIEW IMPLEMENTATION ====== +// ========= HERE STARTS THE ACTUAL FIBERB2UNDLE DEVELOPER VIEW IMPLEMENTATION ====== const std::string QmitkFiberBundleDeveloperView::VIEW_ID = "org.mitk.views.fiberbundledeveloper"; const std::string id_DataManager = "org.mitk.views.datamanager"; using namespace berry; QmitkFiberBundleDeveloperView::QmitkFiberBundleDeveloperView() : QmitkFunctionality() , m_Controls( 0 ) , m_MultiWidget( NULL ) +, m_FiberIDGenerator( NULL) +, m_GeneratorFibersRandom( NULL ) +, m_fiberMonitorIsOn( false ) { m_hostThread = new QThread; m_threadInProgress = false; } // Destructor QmitkFiberBundleDeveloperView::~QmitkFiberBundleDeveloperView() { //m_FiberBundleX->Delete(); using weakPointer, therefore no delete necessary delete m_hostThread; if (m_FiberIDGenerator != NULL) delete m_FiberIDGenerator; if (m_GeneratorFibersRandom != NULL) delete m_GeneratorFibersRandom; } void QmitkFiberBundleDeveloperView::CreateQtPartControl( QWidget *parent ) { // build up qt view, unless already done in QtDesigner, etc. if ( !m_Controls ) { // create GUI widgets from the Qt Designer's .ui file m_Controls = new Ui::QmitkFiberBundleDeveloperViewControls; m_Controls->setupUi( parent ); /*=========INITIALIZE BUTTON CONFIGURATION ================*/ m_Controls->radioButton_directionX->setEnabled(false); m_Controls->radioButton_directionY->setEnabled(false); m_Controls->radioButton_directionZ->setEnabled(false); m_Controls->buttonGenerateFiberIds->setEnabled(false); m_Controls->buttonGenerateFibers->setEnabled(true); m_Controls->buttonColorFibers->setEnabled(false);//not yet implemented m_Controls->buttonSMFibers->setEnabled(false);//not yet implemented m_Controls->buttonVtkDecimatePro->setEnabled(false);//not yet implemented m_Controls->buttonVtkSmoothPD->setEnabled(false);//not yet implemented m_Controls->buttonGenerateTubes->setEnabled(false);//not yet implemented - + connect( m_Controls->buttonGenerateFibers, SIGNAL(clicked()), this, SLOT(DoGenerateFibers()) ); connect( m_Controls->buttonGenerateFiberIds, SIGNAL(pressed()), this, SLOT(DoGenerateFiberIDs()) ); connect( m_Controls->radioButton_directionRandom, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) ); connect( m_Controls->radioButton_directionX, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) ); connect( m_Controls->radioButton_directionY, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) ); connect( m_Controls->radioButton_directionZ, SIGNAL(clicked()), this, SLOT(DoUpdateGenerateFibersWidget()) ); connect( m_Controls->toolBox, SIGNAL(currentChanged ( int ) ), this, SLOT(SelectionChangedToolBox(int)) ); connect( m_Controls->checkBoxMonitorFiberThreads, SIGNAL(stateChanged(int)), this, SLOT(DoMonitorFiberThreads(int)) ); } // Checkpoint for fiber ORIENTATION if ( m_DirectionRadios.empty() ) { m_DirectionRadios.insert(0, m_Controls->radioButton_directionRandom); m_DirectionRadios.insert(1, m_Controls->radioButton_directionX); m_DirectionRadios.insert(2, m_Controls->radioButton_directionY); m_DirectionRadios.insert(3, m_Controls->radioButton_directionZ); } // set GUI elements of FiberGenerator to according configuration DoUpdateGenerateFibersWidget(); } /* THIS METHOD UPDATES ALL GUI ELEMENTS OF QGroupBox DEPENDING ON CURRENTLY SELECTED * RADIO BUTTONS */ void QmitkFiberBundleDeveloperView::DoUpdateGenerateFibersWidget() { //get selected radioButton QString fibDirection; //stores the object_name of selected radiobutton QVector::const_iterator i; for (i = m_DirectionRadios.begin(); i != m_DirectionRadios.end(); ++i) { QRadioButton* rdbtn = *i; if (rdbtn->isChecked()) fibDirection = rdbtn->objectName(); } if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_RANDOM ) { // disable radiobuttons if (m_Controls->boxFiberMinLength->isEnabled()) m_Controls->boxFiberMinLength->setEnabled(false); if (m_Controls->labelFiberMinLength->isEnabled()) m_Controls->labelFiberMinLength->setEnabled(false); if (m_Controls->boxFiberMaxLength->isEnabled()) m_Controls->boxFiberMaxLength->setEnabled(false); if (m_Controls->labelFiberMaxLength->isEnabled()) m_Controls->labelFiberMaxLength->setEnabled(false); //enable radiobuttons if (!m_Controls->labelFibersTotal->isEnabled()) m_Controls->labelFibersTotal->setEnabled(true); if (!m_Controls->boxFiberNumbers->isEnabled()) m_Controls->boxFiberNumbers->setEnabled(true); if (!m_Controls->labelDistrRadius->isEnabled()) m_Controls->labelDistrRadius->setEnabled(true); if (!m_Controls->boxDistributionRadius->isEnabled()) m_Controls->boxDistributionRadius->setEnabled(true); } else { // disable radiobuttons if (m_Controls->labelDistrRadius->isEnabled()) m_Controls->labelDistrRadius->setEnabled(false); if (m_Controls->boxDistributionRadius->isEnabled()) m_Controls->boxDistributionRadius->setEnabled(false); //enable radiobuttons if (!m_Controls->labelFibersTotal->isEnabled()) m_Controls->labelFibersTotal->setEnabled(true); if (!m_Controls->boxFiberNumbers->isEnabled()) m_Controls->boxFiberNumbers->setEnabled(true); if (!m_Controls->boxFiberMinLength->isEnabled()) m_Controls->boxFiberMinLength->setEnabled(true); if (!m_Controls->labelFiberMinLength->isEnabled()) m_Controls->labelFiberMinLength->setEnabled(true); if (!m_Controls->boxFiberMaxLength->isEnabled()) m_Controls->boxFiberMaxLength->setEnabled(true); if (!m_Controls->labelFiberMaxLength->isEnabled()) m_Controls->labelFiberMaxLength->setEnabled(true); } } void QmitkFiberBundleDeveloperView::DoGenerateFibers() { // GET SELECTED FIBER DIRECTION QString fibDirection; //stores the object_name of selected radiobutton QVector::const_iterator i; for (i = m_DirectionRadios.begin(); i != m_DirectionRadios.end(); ++i) { QRadioButton* rdbtn = *i; if (rdbtn->isChecked()) fibDirection = rdbtn->objectName(); } // vtkPolyData* output; // FiberPD stores the generated PolyData... going to be generated in thread if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_RANDOM ) { // build polydata with random lines and fibers // output = GenerateVtkFibersRandom(); } else if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_X ) { // build polydata with XDirection fibers //output = GenerateVtkFibersDirectionX(); } else if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_Y ) { // build polydata with YDirection fibers // output = GenerateVtkFibersDirectionY(); } else if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_Z ) { // build polydata with ZDirection fibers // output = GenerateVtkFibersDirectionZ(); } } void QmitkFiberBundleDeveloperView::PutFibersToDataStorage( vtkPolyData* threadOutput) { - MITK_INFO << "YEHAAAAAAAAA WHAT A GREAT DAY!!!!!!"; MITK_INFO << "lines: " << threadOutput->GetNumberOfLines() << "pnts: " << threadOutput->GetNumberOfPoints(); //qthread mutex lock mitk::FiberBundleX::Pointer FB = mitk::FiberBundleX::New(); FB->SetFibers(threadOutput); FB->SetGeometry(this->GenerateStandardGeometryForMITK()); mitk::DataNode::Pointer FBNode; FBNode = mitk::DataNode::New(); FBNode->SetName("FiberBundleX"); FBNode->SetData(FB); FBNode->SetVisibility(true); GetDataStorage()->Add(FBNode); //output->Delete(); const mitk::PlaneGeometry * tsgeo = m_MultiWidget->GetTimeNavigationController()->GetCurrentPlaneGeometry(); if (tsgeo == NULL) { /* GetDataStorage()->Modified etc. have no effect, therefore proceed as followed below */ // get all nodes that have not set "includeInBoundingBox" to false mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox" , mitk::BoolProperty::New(false))); mitk::DataStorage::SetOfObjects::ConstPointer rs = GetDataStorage()->GetSubset(pred); // calculate bounding geometry of these nodes mitk::TimeSlicedGeometry::Pointer bounds = GetDataStorage()->ComputeBoundingGeometry3D(rs); // initialize the views to the bounding geometry mitk::RenderingManager::GetInstance()->InitializeViews(bounds); } else { GetDataStorage()->Modified(); m_MultiWidget->RequestUpdate(); //necessary?? } //qthread mutex unlock } /* * Generate polydata of random fibers */ void QmitkFiberBundleDeveloperView::GenerateVtkFibersRandom() { /* ===== TIMER CONFIGURATIONS for visual effect ====== * start and stop is called in Thread */ QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough localTimer->setInterval( 10 ); connect( localTimer, SIGNAL(timeout()), this, SLOT(UpdateGenerateRandomFibersTimer()) ); struct Package4WorkingThread ItemPackageForRandomGenerator; ItemPackageForRandomGenerator.st_FBX = m_FiberBundleX; ItemPackageForRandomGenerator.st_Controls = m_Controls; ItemPackageForRandomGenerator.st_FancyGUITimer1 = localTimer; ItemPackageForRandomGenerator.st_host = this; ItemPackageForRandomGenerator.st_pntr_to_Method_PutFibersToDataStorage = &QmitkFiberBundleDeveloperView::PutFibersToDataStorage; + //set element for thread monitoring + if (m_fiberMonitorIsOn) + ItemPackageForRandomGenerator.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker; + + if (m_threadInProgress) return; //maybe popup window saying, working thread still in progress...pls wait m_GeneratorFibersRandom = new QmitkFiberGenerateRandomWorker(m_hostThread, ItemPackageForRandomGenerator); m_GeneratorFibersRandom->moveToThread(m_hostThread); connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_GenerateFibersRandom()) ); connect(m_hostThread, SIGNAL(started()), m_GeneratorFibersRandom, SLOT(run()) ); connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_GenerateFibersRandom()) ); connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_GenerateFibersRandom()) ); m_hostThread->start(QThread::LowestPriority); } void QmitkFiberBundleDeveloperView::UpdateGenerateRandomFibersTimer() { //MAKE SURE by yourself THAT NOTHING ELSE THAN A NUMBER IS SET IN THAT LABEL QString crntValue = m_Controls->infoTimerGenerateFiberBundle->text(); int tmpVal = crntValue.toInt(); m_Controls->infoTimerGenerateFiberBundle->setText(QString::number(++tmpVal)); m_Controls->infoTimerGenerateFiberBundle->update(); - + } void QmitkFiberBundleDeveloperView::BeforeThread_GenerateFibersRandom() { - m_threadInProgress = true; + m_threadInProgress = true; + if (m_fiberMonitorIsOn){ + m_fiberThreadMonitorWorker->threadForFiberProcessingStarted(); + //m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_STARTED); + } } void QmitkFiberBundleDeveloperView::AfterThread_GenerateFibersRandom() { m_threadInProgress = false; + if (m_fiberMonitorIsOn){ + m_fiberThreadMonitorWorker->threadForFiberProcessingFinished(); + m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE); + } disconnect(m_hostThread, 0, 0, 0); m_hostThread->disconnect(); + + } vtkSmartPointer QmitkFiberBundleDeveloperView::GenerateVtkFibersDirectionX() { int numOfFibers = m_Controls->boxFiberNumbers->value(); vtkSmartPointer linesCell = vtkSmartPointer::New(); vtkSmartPointer points = vtkSmartPointer::New(); //insert Origin point, this point has index 0 in point array double originX = 0.0; double originY = 0.0; double originZ = 0.0; //after each iteration the origin of the new fiber increases //here you set which direction is affected. double increaseX = 0.0; double increaseY = 1.0; double increaseZ = 0.0; //walk along X axis //length of fibers increases in each iteration for (int i=0; i newFiber = vtkSmartPointer::New(); newFiber->GetPointIds()->SetNumberOfIds(i+2); //create starting point and add it to pointset points->InsertNextPoint(originX + (double)i * increaseX , originY + (double)i * increaseY, originZ + (double)i * increaseZ); //add starting point to fiber newFiber->GetPointIds()->SetId(0,points->GetNumberOfPoints()-1); //insert remaining points for fiber for (int pj=0; pj<=i ; ++pj) { //generate next point on X axis points->InsertNextPoint( originX + (double)pj+1 , originY + (double)i * increaseY, originZ + (double)i * increaseZ ); newFiber->GetPointIds()->SetId(pj+1,points->GetNumberOfPoints()-1); } linesCell->InsertNextCell(newFiber); } vtkSmartPointer PDX = vtkSmartPointer::New(); PDX->SetPoints(points); PDX->SetLines(linesCell); return PDX; } vtkSmartPointer QmitkFiberBundleDeveloperView::GenerateVtkFibersDirectionY() { vtkSmartPointer PDY = vtkSmartPointer::New(); //todo return PDY; } vtkSmartPointer QmitkFiberBundleDeveloperView::GenerateVtkFibersDirectionZ() { vtkSmartPointer PDZ = vtkSmartPointer::New(); //todo return PDZ; } /* === OutSourcedMethod: THIS METHOD GENERATES ESSENTIAL GEOMETRY PARAMETERS FOR THE MITK FRAMEWORK === * WITHOUT, the rendering mechanism will ignore objects without valid Geometry * for each object, MITK requires: ORIGIN, SPACING, TRANSFORM MATRIX, BOUNDING-BOX */ mitk::Geometry3D::Pointer QmitkFiberBundleDeveloperView::GenerateStandardGeometryForMITK() { mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New(); // generate origin mitk::Point3D origin; origin[0] = 0; origin[1] = 0; origin[2] = 0; geometry->SetOrigin(origin); // generate spacing float spacing[3] = {1,1,1}; geometry->SetSpacing(spacing); // generate identity transform-matrix vtkMatrix4x4* m = vtkMatrix4x4::New(); geometry->SetIndexToWorldTransformByVtkMatrix(m); // generate boundingbox // for an usable bounding-box use gui parameters to estimate the boundingbox float bounds[] = {500, 500, 500, -500, -500, -500}; // GET SELECTED FIBER DIRECTION QString fibDirection; //stores the object_name of selected radiobutton QVector::const_iterator i; for (i = m_DirectionRadios.begin(); i != m_DirectionRadios.end(); ++i) { QRadioButton* rdbtn = *i; if (rdbtn->isChecked()) fibDirection = rdbtn->objectName(); } if ( fibDirection == FIB_RADIOBUTTON_DIRECTION_RANDOM ) { // use information about distribution parameter to calculate bounding box int distrRadius = m_Controls->boxDistributionRadius->value(); bounds[0] = distrRadius; bounds[1] = distrRadius; bounds[2] = distrRadius; bounds[3] = -distrRadius; bounds[4] = -distrRadius; bounds[5] = -distrRadius; } else { // so far only X,Y,Z directions are available MITK_INFO << "_______GEOMETRY ISSUE_____\n***BoundingBox for X, Y, Z fiber directions are not optimized yet!***"; int maxFibLength = m_Controls->boxFiberMaxLength->value(); bounds[0] = maxFibLength; bounds[1] = maxFibLength; bounds[2] = maxFibLength; bounds[3] = -maxFibLength; bounds[4] = -maxFibLength; bounds[5] = -maxFibLength; } geometry->SetFloatBounds(bounds); geometry->SetImageGeometry(true); //?? return geometry; } void QmitkFiberBundleDeveloperView::UpdateFiberIDTimer() { //MAKE SURE by yourself THAT NOTHING ELSE THAN A NUMBER IS SET IN THAT LABEL QString crntValue = m_Controls->infoTimerGenerateFiberIds->text(); int tmpVal = crntValue.toInt(); m_Controls->infoTimerGenerateFiberIds->setText(QString::number(++tmpVal)); m_Controls->infoTimerGenerateFiberIds->update(); } /* Initialie ID dataset in FiberBundleX */ void QmitkFiberBundleDeveloperView::DoGenerateFiberIDs() { /* ===== TIMER CONFIGURATIONS for visual effect ====== * start and stop is called in Thread */ QTimer *localTimer = new QTimer; // timer must be initialized here, otherwise timer is not fancy enough localTimer->setInterval( 10 ); connect( localTimer, SIGNAL(timeout()), this, SLOT(UpdateFiberIDTimer()) ); // pack items which are needed by thread processing struct Package4WorkingThread FiberIdPackage; FiberIdPackage.st_FBX = m_FiberBundleX; FiberIdPackage.st_FancyGUITimer1 = localTimer; FiberIdPackage.st_Controls = m_Controls; + //set element for thread monitoring + if (m_fiberMonitorIsOn) + FiberIdPackage.st_fiberThreadMonitorWorker = m_fiberThreadMonitorWorker; + if (m_threadInProgress) return; //maybe popup window saying, working thread still in progress...pls wait // THREAD CONFIGURATION m_FiberIDGenerator = new QmitkFiberIDWorker(m_hostThread, FiberIdPackage); m_FiberIDGenerator->moveToThread(m_hostThread); connect(m_hostThread, SIGNAL(started()), this, SLOT( BeforeThread_IdGenerate()) ); connect(m_hostThread, SIGNAL(started()), m_FiberIDGenerator, SLOT(run())); connect(m_hostThread, SIGNAL(finished()), this, SLOT(AfterThread_IdGenerate())); connect(m_hostThread, SIGNAL(terminated()), this, SLOT(AfterThread_IdGenerate())); m_hostThread->start(QThread::LowestPriority); // m_Controls->infoTimerGenerateFiberIds->setText(QString::number(clock.GetTotal())); } void QmitkFiberBundleDeveloperView::BeforeThread_IdGenerate() { m_threadInProgress = true; - + if (m_fiberMonitorIsOn){ + m_fiberThreadMonitorWorker->threadForFiberProcessingStarted(); + m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_STARTED); + } } void QmitkFiberBundleDeveloperView::AfterThread_IdGenerate() { - - m_threadInProgress = false; + if (m_fiberMonitorIsOn){ + m_fiberThreadMonitorWorker->threadForFiberProcessingFinished(); + m_fiberThreadMonitorWorker->setThreadStatus(FBX_STATUS_IDLE); + } disconnect(m_hostThread, 0, 0, 0); m_hostThread->disconnect(); } -/* THE WORKER ACCESS THIS METHOD TO PASS GENERATED FIBERBUNDLE - * TO DATASTORAGE */ -void QmitkFiberBundleDeveloperView::SetGeneratedFBX() -{ - - - -} void QmitkFiberBundleDeveloperView::ResetFiberInfoWidget() { if (m_Controls->infoAnalyseNumOfFibers->isEnabled()) { m_Controls->infoAnalyseNumOfFibers->setText("-"); m_Controls->infoAnalyseNumOfPoints->setText("-"); m_Controls->infoAnalyseNumOfFibers->setEnabled(false); } } void QmitkFiberBundleDeveloperView::FeedFiberInfoWidget() { if (!m_Controls->infoAnalyseNumOfFibers->isEnabled()) m_Controls->infoAnalyseNumOfFibers->setEnabled(true); QString numOfFibers; numOfFibers.setNum( m_FiberBundleX->GetFibers()->GetNumberOfLines() ); QString numOfPoints; numOfPoints.setNum( m_FiberBundleX->GetFibers()->GetNumberOfPoints() ); m_Controls->infoAnalyseNumOfFibers->setText( numOfFibers ); m_Controls->infoAnalyseNumOfPoints->setText( numOfPoints ); } void QmitkFiberBundleDeveloperView::SelectionChangedToolBox(int idx) { MITK_INFO << "printtoolbox: " << idx; if (m_Controls->page_FiberInfo->isVisible() && m_FiberBundleX != NULL) { FeedFiberInfoWidget(); } else { //if infolables are disabled: return //else set info back to - and set label and info to disabled if (!m_Controls->page_FiberInfo->isVisible()) { return; } else { ResetFiberInfoWidget(); } } } void QmitkFiberBundleDeveloperView::FBXDependendGUIElementsConfigurator(bool isVisible) { // ==== FIBER PROCESSING ELEMENTS ====== m_Controls->buttonGenerateFiberIds->setEnabled(isVisible); } void QmitkFiberBundleDeveloperView::DoMonitorFiberThreads(int checkStatus) { //check if in datanode exists already a node of type mitkFiberBundleXThreadMonitor //if not then put node to datastorage //if checkStatus is 1 then start qtimer using fading in starting text in datanode //if checkStatus is 0 then fade out dataNode using qtimer if (checkStatus) { - mitk::FiberBundleXThreadMonitor::Pointer FBXThreadMonitor = mitk::FiberBundleXThreadMonitor::New(); + m_fiberMonitorIsOn = true; + // Generate Node hosting thread information + mitk::FiberBundleXThreadMonitor::Pointer FBXThreadMonitor = mitk::FiberBundleXThreadMonitor::New(); FBXThreadMonitor->SetGeometry(this->GenerateStandardGeometryForMITK()); - m_MonitorNode = mitk::DataNode::New(); - m_MonitorNode->SetName("FBX_threadMonitor"); - m_MonitorNode->SetData(FBXThreadMonitor); - m_MonitorNode->SetVisibility(true); - m_MonitorNode->SetOpacity(1.0); - - GetDataStorage()->Add(m_MonitorNode); - - const mitk::PlaneGeometry * tsgeo = m_MultiWidget->GetTimeNavigationController()->GetCurrentPlaneGeometry(); - if (tsgeo == NULL) { - /* GetDataStorage()->Modified etc. have no effect, therefore proceed as followed below */ - // get all nodes that have not set "includeInBoundingBox" to false - mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New( "includeInBoundingBox" - , mitk::BoolProperty::New(false))); - mitk::DataStorage::SetOfObjects::ConstPointer rs = GetDataStorage()->GetSubset(pred); - // calculate bounding geometry of these nodes - mitk::TimeSlicedGeometry::Pointer bounds = GetDataStorage()->ComputeBoundingGeometry3D(rs); - // initialize the views to the bounding geometry - mitk::RenderingManager::GetInstance()->InitializeViews(bounds); - } else { - GetDataStorage()->Modified(); - m_MultiWidget->RequestUpdate(); //necessary?? - } - - + m_MonitorNode = mitk::DataNode::New(); + m_MonitorNode->SetName("FBX_threadMonitor"); + m_MonitorNode->SetData(FBXThreadMonitor); + m_MonitorNode->SetVisibility(true); + m_MonitorNode->SetOpacity(1.0); + + GetDataStorage()->Add(m_MonitorNode); + + //following code is needed for rendering text in mitk! without geometry nothing is rendered + const mitk::PlaneGeometry * tsgeo = m_MultiWidget->GetTimeNavigationController()->GetCurrentPlaneGeometry(); + if (tsgeo == NULL) { + /* GetDataStorage()->Modified etc. have no effect, therefore proceed as followed below */ + // get all nodes that have not set "includeInBoundingBox" to false + mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New( "includeInBoundingBox" + , mitk::BoolProperty::New(false))); + mitk::DataStorage::SetOfObjects::ConstPointer rs = GetDataStorage()->GetSubset(pred); + // calculate bounding geometry of these nodes + mitk::TimeSlicedGeometry::Pointer bounds = GetDataStorage()->ComputeBoundingGeometry3D(rs); + // initialize the views to the bounding geometry + mitk::RenderingManager::GetInstance()->InitializeViews(bounds); + } else { + + GetDataStorage()->Modified(); + m_MultiWidget->RequestUpdate(); //necessary?? + } + //__GEOMETRY FOR THREADMONITOR GENERATED + + /* ====== initialize thread for managing fiberThread information ========= */ + m_monitorThread = new QThread; + // the package needs datastorage, MonitorDatanode, standardmultiwidget, + struct Package4WorkingThread ItemPackageForThreadMonitor; + ItemPackageForThreadMonitor.st_DataStorage = GetDataStorage(); + ItemPackageForThreadMonitor.st_ThreadMonitorDataNode = m_MonitorNode; + ItemPackageForThreadMonitor.st_MultiWidget = m_MultiWidget; + ItemPackageForThreadMonitor.st_FBX_Monitor = FBXThreadMonitor; + + m_fiberThreadMonitorWorker = new QmitkFiberThreadMonitorWorker(m_monitorThread, ItemPackageForThreadMonitor); + + m_fiberThreadMonitorWorker->moveToThread(m_monitorThread); + connect ( m_monitorThread, SIGNAL( started() ), m_fiberThreadMonitorWorker, SLOT( run() ) ); + m_monitorThread->start(QThread::LowestPriority); + m_fiberThreadMonitorWorker->initializeMonitor();//do some init animation ;-) + + } else { + m_fiberMonitorIsOn = false; + + m_monitorThread->quit(); + //think about outsourcing following lines to quit / terminate slot of thread GetDataStorage()->Remove(m_MonitorNode); GetDataStorage()->Modified(); m_MultiWidget->RequestUpdate(); //necessary?? } + } void QmitkFiberBundleDeveloperView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget) { m_MultiWidget = &stdMultiWidget; } void QmitkFiberBundleDeveloperView::StdMultiWidgetNotAvailable() { m_MultiWidget = NULL; } /* OnSelectionChanged is registered to SelectionService, therefore no need to implement SelectionService Listener explicitly */ void QmitkFiberBundleDeveloperView::OnSelectionChanged( std::vector nodes ) { /* ==== reset everyhing related to FiberBundleX ====== * - variable m_FiberBundleX * - visualization of analysed fiberbundle */ m_FiberBundleX = NULL; //reset pointer, so that member does not point to depricated locations ResetFiberInfoWidget(); - FBXDependendGUIElementsConfigurator(false); - m_Controls->infoTimerGenerateFiberIds->setText("-"); //set GUI representation of timer to - - m_Controls->infoTimerGenerateFiberBundle->setText( "-" ); + FBXDependendGUIElementsConfigurator(false); //every gui element which needs a FBX for processing is disabled + + //timer reset only when no thread is in progress + if (!m_threadInProgress) { + m_Controls->infoTimerGenerateFiberIds->setText("-"); //set GUI representation of timer to - + m_Controls->infoTimerGenerateFiberBundle->setText( "-" ); + } //==================================================== if (nodes.empty()) return; for( std::vector::iterator it = nodes.begin(); it != nodes.end(); ++it ) { mitk::DataNode::Pointer node = *it; /* CHECKPOINT: FIBERBUNDLE*/ if( node.IsNotNull() && dynamic_cast(node->GetData()) ) { m_FiberBundleX = dynamic_cast(node->GetData()); if (m_FiberBundleX == NULL) MITK_INFO << "========ATTENTION=========\n unable to load selected FiberBundleX to FiberBundleDeveloper-plugin \n"; // ==== FIBERBUNDLE_INFO ELEMENTS ==== if ( m_Controls->page_FiberInfo->isVisible() ) FeedFiberInfoWidget(); // enable FiberBundleX related Gui Elements, such as buttons etc. FBXDependendGUIElementsConfigurator(true); } } } void QmitkFiberBundleDeveloperView::Activated() { MITK_INFO << "FB DevelopersV ACTIVATED()"; } diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.h b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.h index 956a72ba70..989d530d0d 100644 --- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.h +++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperView.h @@ -1,233 +1,289 @@ /*========================================================================= - -Program: Medical Imaging & Interaction Toolkit -Language: C++ -Date: $Date: 2010-03-31 16:40:27 +0200 (Mi, 31 Mrz 2010) $ -Version: $Revision: 21975 $ - -Copyright (c) German Cancer Research Center, Division of Medical and -Biological Informatics. All rights reserved. -See MITKCopyright.txt or http://www.mitk.org/copyright.html for details. - -This software is distributed WITHOUT ANY WARRANTY; without even -the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR -PURPOSE. See the above copyright notices for more information. - -=========================================================================*/ + + Program: Medical Imaging & Interaction Toolkit + Language: C++ + Date: $Date: 2010-03-31 16:40:27 +0200 (Mi, 31 Mrz 2010) $ + Version: $Revision: 21975 $ + + Copyright (c) German Cancer Research Center, Division of Medical and + Biological Informatics. All rights reserved. + See MITKCopyright.txt or http://www.mitk.org/copyright.html for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notices for more information. + + =========================================================================*/ #ifndef QmitkFiberBundleDeveloperView_h #define QmitkFiberBundleDeveloperView_h #include #include #include #include "ui_QmitkFiberBundleDeveloperViewControls.h" #include #include #include +#include // Qt #include #include #include // VTK #include #include #include #include #include #include +class QmitkFiberThreadMonitorWorker; //include needed for struct element class QmitkFiberBundleDeveloperView; //this include is needed for the struct element, especially for functors to QmitkFiberBundleDeveloperView /* ==== THIS STRUCT CONTAINS ALL NECESSARY VARIABLES * TO EXECUTE AND UPDATE GUI ELEMENTS DURING PROCESSING OF A THREAD * why? either you add tons of friendclasses (e.g. FiberWorker objects), or you create a package containing all items needed. Otherwise you have to set all members etc. to public! */ struct Package4WorkingThread { mitk::FiberBundleX* st_FBX; QTimer* st_FancyGUITimer1; Ui::QmitkFiberBundleDeveloperViewControls* st_Controls; + + //functors to outdoor methods QmitkFiberBundleDeveloperView* st_host; void (QmitkFiberBundleDeveloperView::*st_pntr_to_Method_PutFibersToDataStorage) (vtkPolyData*); + //==DO NOT TOUCH THIS SECTION=== + //host MITK I/O elements, especially needed for thread monitoring + QmitkFiberThreadMonitorWorker *st_fiberThreadMonitorWorker; + mitk::FiberBundleXThreadMonitor::Pointer st_FBX_Monitor; //needed for direct access do animation/fancy methods + mitk::DataNode::Pointer st_ThreadMonitorDataNode; //needed for renderer to recognize node modifications + mitk::DataStorage::Pointer st_DataStorage; //well that is discussable if needed ;-) probably not + QmitkStdMultiWidget* st_MultiWidget; //needed for rendering update + }; // ==================================================================== // ============= WORKER WHICH IS PASSED TO THREAD ===================== // ==================================================================== //## Documentation //## This class does the actual work for generating fiber ids. class QmitkFiberIDWorker : public QObject { Q_OBJECT public: - QmitkFiberIDWorker( QThread*, Package4WorkingThread ); public slots: - void run(); private: - //mitk::FiberBundleX* m_FBX; - Package4WorkingThread m_itemPackage; QThread* m_hostingThread; }; // ==================================================================== // ============= WORKER WHICH IS PASSED TO THREAD ===================== // ==================================================================== class QmitkFiberGenerateRandomWorker : public QObject { Q_OBJECT public: - QmitkFiberGenerateRandomWorker( QThread*, Package4WorkingThread ); public slots: - void run(); private: - //mitk::FiberBundleX* m_FBX; - Package4WorkingThread m_itemPackage; QThread* m_hostingThread; }; +class QmitkFiberThreadMonitorWorker : public QObject +{ + Q_OBJECT + +public: + + + QmitkFiberThreadMonitorWorker( QThread*, Package4WorkingThread ); + + void initializeMonitor(); + void threadForFiberProcessingStarted(); + void threadForFiberProcessingFinished(); + void threadForFiberProcessingTerminated(); + void setThreadStatus(QString); + + + public slots: + void run(); + void fancyMonitorInitialization(); + void fancyMonitorInitializationFinalPos(); + void fancyMonitorInitializationMask(); + void fancyTextFading_threadStarted(); + void fancyTextFading_threadFinished(); + void fancyTextFading_threadTerminated(); + +private: + Package4WorkingThread m_itemPackage; + QThread* m_hostingThread; + QTimer* m_thtimer_initMonitor; + QTimer* m_thtimer_initMonitorSetFinalPosition; + QTimer* m_thtimer_initMonitorSetMasks; + QTimer* m_thtimer_threadStarted; + QTimer* m_thtimer_threadFinished; + QTimer* m_thtimer_threadTerminated; + + // flags for fancy fading + bool m_decreaseOpacity_threadStarted; + bool m_decreaseOpacity_threadFinished; + bool m_decreaseOpacity_threadTerminated; + + // members for fancy animation + int m_pixelstepper; + int m_steppingDistance; + + +}; +// strings to display fiber_thread monitor +const QString FBX_STATUS_IDLE = "idle"; +const QString FBX_STATUS_STARTED = "starting"; +const QString FBX_STATUS_RUNNING = "running"; // ========= HERE STARTS THE ACTUAL FIBERBUNDLE DEVELOPER VIEW ======= const QString FIB_RADIOBUTTON_DIRECTION_RANDOM = "radioButton_directionRandom"; const QString FIB_RADIOBUTTON_DIRECTION_X = "radioButton_directionX"; const QString FIB_RADIOBUTTON_DIRECTION_Y = "radioButton_directionY"; const QString FIB_RADIOBUTTON_DIRECTION_Z = "radioButton_directionZ"; /*! -\brief QmitkFiberBundleView - -\warning This application module is not yet documented. Use "svn blame/praise/annotate" and ask the author to provide basic documentation. - -\sa QmitkFunctionality -\ingroup Functionalities -*/ + \brief QmitkFiberBundleView + + \warning This application module is not yet documented. Use "svn blame/praise/annotate" and ask the author to provide basic documentation. + + \sa QmitkFunctionality + \ingroup Functionalities + */ class QmitkFiberBundleDeveloperView : public QmitkFunctionality { - - + + // this is needed for all Qt objects that should have a Qt meta-object // (everything that derives from QObject and wants to have signal/slots) Q_OBJECT - + public: - + static const std::string VIEW_ID; - + QmitkFiberBundleDeveloperView(); virtual ~QmitkFiberBundleDeveloperView(); - + virtual void CreateQtPartControl(QWidget *parent); - + virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget); virtual void StdMultiWidgetNotAvailable(); virtual void Activated(); - + protected slots: void DoGenerateFibers(); void DoGenerateFiberIDs(); void DoUpdateGenerateFibersWidget(); void SelectionChangedToolBox(int); void DoMonitorFiberThreads(int); //SLOTS FOR THREADS void BeforeThread_IdGenerate(); void AfterThread_IdGenerate(); void BeforeThread_GenerateFibersRandom(); void AfterThread_GenerateFibersRandom(); //SLOTS FOR TIMERS void UpdateFiberIDTimer(); void UpdateGenerateRandomFibersTimer(); - + protected: - + /// \brief called by QmitkFunctionality when DataManager's selection has changed virtual void OnSelectionChanged( std::vector nodes ); - + Ui::QmitkFiberBundleDeveloperViewControls* m_Controls; - + QmitkStdMultiWidget* m_MultiWidget; - - - - private: + + + +private: /* METHODS GENERATING FIBERSTRUCTURES */ void GenerateVtkFibersRandom(); vtkSmartPointer GenerateVtkFibersDirectionX(); vtkSmartPointer GenerateVtkFibersDirectionY(); vtkSmartPointer GenerateVtkFibersDirectionZ(); - + void PutFibersToDataStorage( vtkPolyData* ); /* METHODS FOR FIBER PROCESSING OR PREPROCESSING */ - + /* HELPERMETHODS */ mitk::Geometry3D::Pointer GenerateStandardGeometryForMITK(); void ResetFiberInfoWidget(); void FeedFiberInfoWidget(); void FBXDependendGUIElementsConfigurator(bool); void SetGeneratedFBX(); //contains the selected FiberBundle //mitk::FiberBundleX* m_FiberBundleX; mitk::WeakPointer m_FiberBundleX; -// radiobutton groups + // radiobutton groups QVector< QRadioButton* > m_DirectionRadios; QVector< QRadioButton* > m_FARadios; QVector< QRadioButton* > m_GARadios; // Thread based Workers which do some processing of fibers QmitkFiberIDWorker * m_FiberIDGenerator; QmitkFiberGenerateRandomWorker * m_GeneratorFibersRandom; QThread * m_hostThread; + QThread * m_monitorThread; bool m_threadInProgress; mitk::DataNode::Pointer m_MonitorNode; + QmitkFiberThreadMonitorWorker *m_fiberThreadMonitorWorker; + bool m_fiberMonitorIsOn; - }; #endif // _QMITKFIBERTRACKINGVIEW_H_INCLUDED diff --git a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperViewControls.ui b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperViewControls.ui index a060497d1d..63db98fc7d 100644 --- a/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperViewControls.ui +++ b/Modules/Bundles/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberBundleDeveloperViewControls.ui @@ -1,843 +1,846 @@ QmitkFiberBundleDeveloperViewControls 0 0 405 753 Form 12 50 false 0 0 0 366 449 Fiber Generator 0 Fiber Bundles Generate Fiberbundle Fiber Parameters 11 Total number of Fibers 10 999999999 100 Qt::Horizontal 40 20 11 Distribution Radius 10 + + 9999 + - 99 + 100 11 Fiber Length Max (points) 10 50 11 Fiber Length Min (points) 10 10 labelFibersTotal boxFiberNumbers horizontalSpacer_3 labelDistrRadius boxDistributionRadius labelFiberMaxLength boxFiberMaxLength labelFiberMinLength boxFiberMinLength 11 Fiber Orientation along Z Axis along X Axis random true along Y Axis Qt::Horizontal 40 20 Qt::Vertical 20 40 QFrame::StyledPanel QFrame::Raised 10 Time: 10 - DWI Values GA Values no values true nothing yet implemented 11 FA Values const value false 10 1.000000000000000 0.100000000000000 1.000000000000000 random range false 10 1.000000000000000 0.100000000000000 no values true false 10 1.000000000000000 0.100000000000000 Qt::Vertical 20 40 Page Select a FiberBundle in Datamanager Qt::Vertical 20 40 0 0 - 366 + 307 403 Fiber Processor 2 Colors Fiber Coloring Color Fibers Qt::Vertical 20 40 Shape Qt::Vertical 20 40 Fiber Smoothing Smooth Fibers QFrame::StyledPanel QFrame::Raised static value relative in% false 10 none true false 10 9999 Qt::Horizontal 40 20 vtkFilters Tubes vtkDecimatePro vtkSmoothPolyDataFilter Cutting Step1: Generate Fibers IDs in FBX Qt::Vertical 20 40 QFrame::StyledPanel QFrame::Raised QFormLayout::FieldsStayAtSizeHint 10 Timer: 10 - Execute Step1 0 0 - 381 - 249 + 185 + 116 FiberInfo General Information Number of Fibers: - Number of Points: - Qt::Vertical 20 40 Qt::Horizontal Monitor Fiber Threading in mitkRenderWindow4 Qt::Vertical 20 40 diff --git a/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.cpp b/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.cpp index 269a655d56..856f833f4e 100644 --- a/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.cpp +++ b/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.cpp @@ -1,61 +1,255 @@ /*========================================================================= Program: Medical Imaging & Interaction Toolkit Language: C++ Date: $Date: 2010-03-31 16:40:27 +0200 (Mi, 31 Mrz 2010) $ Version: $Revision: 21975 $ Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. See MITKCopyright.txt or http://www.mitk.org/copyright.html for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mitkFiberBundleXThreadMonitor.h" -#include // without geometry, fibers are not rendered + mitk::FiberBundleXThreadMonitor::FiberBundleXThreadMonitor() +: m_monitorBracketOpen("[") +, m_monitorBracketClose("]") +, m_monitorHeading("Monitoring Fiberprocessing Threads") +, m_monitorMask("Thread Status:\nStarted: Finished: Terminated:") +, m_monitorStatus("_initialized") +, m_monitorStarted(0) +, m_monitorFinished(0) +, m_monitorTerminated(0) { - + m_monitorBracketOpenPosition[0] = 0; + m_monitorBracketOpenPosition[1] = 0; + m_monitorBracketClosePosition[0] = 0; + m_monitorBracketClosePosition[1] = 0; + m_monitorHeadingPosition[0] = 0; + m_monitorHeadingPosition[1] = 0; + m_monitorMaskPosition[0] = 0; + m_monitorMaskPosition[1] = 0; + m_monitorStatusPosition[0] = 0; + m_monitorStatusPosition[1] = 0; + m_monitorStartedPosition[0] = 0; + m_monitorStartedPosition[1] = 0; + m_monitorFinishedPosition[0] = 0; + m_monitorFinishedPosition[1] = 0; + m_monitorTerminatedPosition[0] = 0; + m_monitorTerminatedPosition[1] = 0; + + m_monitorHeadingOpacity = 0; + m_monitorMaskOpacity = 0; + m_monitorTerminatedOpacity = 0; + m_monitorFinishedOpacity = 0; + m_monitorStartedOpacity = 0; + m_monitorStatusOpacity = 0; } mitk::FiberBundleXThreadMonitor::~FiberBundleXThreadMonitor() { + +} + + +QString mitk::FiberBundleXThreadMonitor::getBracketOpen(){ + return m_monitorBracketOpen; +} +mitk::Point2D mitk::FiberBundleXThreadMonitor::getBracketOpenPosition(){ + return m_monitorBracketOpenPosition; +} +void mitk::FiberBundleXThreadMonitor::setBracketOpenPosition(mitk::Point2D pnt){ + m_monitorBracketOpenPosition[0] = pnt[0]; + m_monitorBracketOpenPosition[1] = pnt[1]; +} + + + + +QString mitk::FiberBundleXThreadMonitor::getBracketClose(){ + return m_monitorBracketClose; +} +mitk::Point2D mitk::FiberBundleXThreadMonitor::getBracketClosePosition(){ + return m_monitorBracketClosePosition; +} +void mitk::FiberBundleXThreadMonitor::setBracketClosePosition(mitk::Point2D pnt){ + m_monitorBracketClosePosition[0] = pnt[0]; + m_monitorBracketClosePosition[1] = pnt[1]; +} + + + +QString mitk::FiberBundleXThreadMonitor::getHeading(){ + return m_monitorHeading; +} +mitk::Point2D mitk::FiberBundleXThreadMonitor::getHeadingPosition(){ + return m_monitorHeadingPosition; +} +void mitk::FiberBundleXThreadMonitor::setHeadingPosition(mitk::Point2D pnt){ + m_monitorHeadingPosition[0] = pnt[0]; + m_monitorHeadingPosition[1] = pnt[1]; +} +int mitk::FiberBundleXThreadMonitor::getHeadingOpacity(){ + return m_monitorHeadingOpacity; +} +void mitk::FiberBundleXThreadMonitor::setHeadingOpacity(int opacity){ + m_monitorHeadingOpacity = opacity; +} + + + + +QString mitk::FiberBundleXThreadMonitor::getMask(){ + return m_monitorMask; +} +mitk::Point2D mitk::FiberBundleXThreadMonitor::getMaskPosition(){ + return m_monitorMaskPosition; +} +void mitk::FiberBundleXThreadMonitor::setMaskPosition(mitk::Point2D pnt){ + m_monitorMaskPosition[0] = pnt[0]; + m_monitorMaskPosition[1] = pnt[1]; +} +int mitk::FiberBundleXThreadMonitor::getMaskOpacity(){ + return m_monitorMaskOpacity; +} +void mitk::FiberBundleXThreadMonitor::setMaskOpacity(int opacity){ + m_monitorMaskOpacity = opacity; +} + + + + + +QString mitk::FiberBundleXThreadMonitor::getStatus(){ + return m_monitorStatus; +} +void mitk::FiberBundleXThreadMonitor::setStatus(QString status){ + m_statusMutex.lock(); + m_monitorStatus = status; + m_statusMutex.unlock(); +} +mitk::Point2D mitk::FiberBundleXThreadMonitor::getStatusPosition(){ + return m_monitorStatusPosition; +} +void mitk::FiberBundleXThreadMonitor::setStatusPosition(mitk::Point2D pnt){ + m_monitorStatusPosition[0] = pnt[0]; + m_monitorStatusPosition[1] = pnt[1]; +} +int mitk::FiberBundleXThreadMonitor::getStatusOpacity(){ + return m_monitorStatusOpacity; +} +void mitk::FiberBundleXThreadMonitor::setStatusOpacity(int opacity){ + m_monitorStatusOpacity = opacity; +} + + +int mitk::FiberBundleXThreadMonitor::getStarted(){ + return m_monitorStarted; +} +/* is thread safe :) */ +void mitk::FiberBundleXThreadMonitor::setStarted(int val) +{ + m_startedMutex.lock(); + m_monitorStarted = val; + m_startedMutex.unlock(); +} +mitk::Point2D mitk::FiberBundleXThreadMonitor::getStartedPosition(){ + return m_monitorStartedPosition; +} +void mitk::FiberBundleXThreadMonitor::setStartedPosition(mitk::Point2D pnt){ + m_monitorStartedPosition[0] = pnt[0]; + m_monitorStartedPosition[1] = pnt[1]; +} +int mitk::FiberBundleXThreadMonitor::getStartedOpacity(){ + return m_monitorStartedOpacity; +} +void mitk::FiberBundleXThreadMonitor::setStartedOpacity(int opacity){ + m_monitorStartedOpacity = opacity; +} + + + +int mitk::FiberBundleXThreadMonitor::getFinished(){ + return m_monitorFinished; +} +void mitk::FiberBundleXThreadMonitor::setFinished(int val) +{ + m_finishedMutex.lock(); + m_monitorFinished = val; + m_finishedMutex.unlock(); +} +mitk::Point2D mitk::FiberBundleXThreadMonitor::getFinishedPosition(){ + return m_monitorFinishedPosition; +} +void mitk::FiberBundleXThreadMonitor::setFinishedPosition(mitk::Point2D pnt){ + m_monitorFinishedPosition[0] = pnt[0]; + m_monitorFinishedPosition[1] = pnt[1]; +} +int mitk::FiberBundleXThreadMonitor::getFinishedOpacity(){ + return m_monitorFinishedOpacity; +} +void mitk::FiberBundleXThreadMonitor::setFinishedOpacity(int opacity){ + m_monitorFinishedOpacity = opacity; } -//setter textproperty opacity etc.... -//setter color -//setter text + + +int mitk::FiberBundleXThreadMonitor::getTerminated(){ + return m_monitorTerminated; +} +void mitk::FiberBundleXThreadMonitor::setTerminated(int val) +{ + m_terminatedMutex.lock(); + m_monitorTerminated = val; + m_terminatedMutex.unlock(); +} +mitk::Point2D mitk::FiberBundleXThreadMonitor::getTerminatedPosition(){ + return m_monitorTerminatedPosition; +} +void mitk::FiberBundleXThreadMonitor::setTerminatedPosition(mitk::Point2D pnt){ + m_monitorTerminatedPosition[0] = pnt[0]; + m_monitorTerminatedPosition[1] = pnt[1]; +} +int mitk::FiberBundleXThreadMonitor::getTerminatedOpacity(){ + return m_monitorTerminatedOpacity; +} +void mitk::FiberBundleXThreadMonitor::setTerminatedOpacity(int opacity){ + m_monitorTerminatedOpacity = opacity; +} /* ESSENTIAL IMPLEMENTATION OF SUPERCLASS METHODS */ void mitk::FiberBundleXThreadMonitor::UpdateOutputInformation() { } void mitk::FiberBundleXThreadMonitor::SetRequestedRegionToLargestPossibleRegion() { } bool mitk::FiberBundleXThreadMonitor::RequestedRegionIsOutsideOfTheBufferedRegion() { return false; } bool mitk::FiberBundleXThreadMonitor::VerifyRequestedRegion() { return true; } void mitk::FiberBundleXThreadMonitor::SetRequestedRegion( itk::DataObject *data ) { - -} \ No newline at end of file + +} + diff --git a/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.h b/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.h index 22a4a54b82..1540cff458 100644 --- a/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.h +++ b/Modules/DiffusionImaging/IODataStructures/FiberBundleX/mitkFiberBundleXThreadMonitor.h @@ -1,64 +1,155 @@ /*========================================================================= Program: Medical Imaging & Interaction Toolkit Module: $RCSfile$ Language: C++ Date: $Date$ Version: $Revision: 11989 $ Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. See MITKCopyright.txt or http://www.mitk.org/copyright.html for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef _MITK_FiberBundleXThreadMonitor_H #define _MITK_FiberBundleXThreadMonitor_H //includes for MITK datastructure #include "mitkBaseData.h" #include "MitkDiffusionImagingExports.h" +#include +#include namespace mitk { /** * \brief Base Class for Fiber Bundles; */ class MitkDiffusionImaging_EXPORT FiberBundleXThreadMonitor : public BaseData { + public: - // ======virtual methods must have====== virtual void UpdateOutputInformation(); virtual void SetRequestedRegionToLargestPossibleRegion(); virtual bool RequestedRegionIsOutsideOfTheBufferedRegion(); virtual bool VerifyRequestedRegion(); virtual void SetRequestedRegion( itk::DataObject *data ); //======================================= mitkClassMacro( FiberBundleXThreadMonitor, BaseData ); itkNewMacro( Self ); - + void setTextL1(QString); + QString getTextL1(); + + QString getBracketOpen(); + mitk::Point2D getBracketOpenPosition(); + void setBracketOpenPosition(mitk::Point2D); + int getBracketOpenOpacity(); // range 0 - 10, multiplicationfactor 0.1 (in mapper) + + QString getBracketClose(); + mitk::Point2D getBracketClosePosition(); + void setBracketClosePosition(mitk::Point2D); + int getBracketCloseOpacity(); // range 0 - 10, multiplicationfactor 0.1 (in mapper) + + QString getHeading(); + mitk::Point2D getHeadingPosition(); + void setHeadingPosition(mitk::Point2D); + int getHeadingOpacity(); // range 0 - 10, multiplicationfactor 0.1 (in mapper) + void setHeadingOpacity(int); + + QString getMask(); + mitk::Point2D getMaskPosition(); + void setMaskPosition(mitk::Point2D); + int getMaskOpacity(); // multiplicationfactor 0.1 (in mapper) + void setMaskOpacity(int); + + QString getStatus(); + void setStatus(QString); + mitk::Point2D getStatusPosition(); + void setStatusPosition(mitk::Point2D); + int getStatusOpacity(); // multiplicationfactor 0.1 (in mapper) + void setStatusOpacity(int); + + int getStarted(); + void setStarted(int); + mitk::Point2D getStartedPosition(); + void setStartedPosition(mitk::Point2D); + int getStartedOpacity(); // multiplicationfactor 0.1 (in mapper) + void setStartedOpacity(int); + + int getFinished(); + void setFinished(int); + mitk::Point2D getFinishedPosition(); + void setFinishedPosition(mitk::Point2D); + int getFinishedOpacity(); // multiplicationfactor 0.1 (in mapper) + void setFinishedOpacity(int); + + int getTerminated(); + void setTerminated(int); + mitk::Point2D getTerminatedPosition(); + void setTerminatedPosition(mitk::Point2D); + int getTerminatedOpacity(); // multiplicationfactor 0.1 (in mapper) + void setTerminatedOpacity(int); + + protected: FiberBundleXThreadMonitor(); virtual ~FiberBundleXThreadMonitor(); + private: + QString m_monitorBracketOpen; + mitk::Point2D m_monitorBracketOpenPosition; + + QString m_monitorBracketClose; + mitk::Point2D m_monitorBracketClosePosition; + + QString m_monitorHeading; + mitk::Point2D m_monitorHeadingPosition; + int m_monitorHeadingOpacity; + + QString m_monitorMask; + mitk::Point2D m_monitorMaskPosition; + int m_monitorMaskOpacity; + + QString m_monitorStatus; + mitk::Point2D m_monitorStatusPosition; + int m_monitorStatusOpacity; + + int m_monitorStarted; + mitk::Point2D m_monitorStartedPosition; + int m_monitorStartedOpacity; + + int m_monitorFinished; + mitk::Point2D m_monitorFinishedPosition; + int m_monitorFinishedOpacity; + + int m_monitorTerminated; + mitk::Point2D m_monitorTerminatedPosition; + int m_monitorTerminatedOpacity; + + QMutex m_startedMutex; + QMutex m_finishedMutex; + QMutex m_terminatedMutex; + QMutex m_statusMutex; + }; } // namespace mitk #endif /* _MITK_FiberBundleX_H */ diff --git a/Modules/DiffusionImaging/Rendering/mitkFiberBundleXThreadMonitorMapper3D.cpp b/Modules/DiffusionImaging/Rendering/mitkFiberBundleXThreadMonitorMapper3D.cpp index a44b6aae06..66cea542fa 100644 --- a/Modules/DiffusionImaging/Rendering/mitkFiberBundleXThreadMonitorMapper3D.cpp +++ b/Modules/DiffusionImaging/Rendering/mitkFiberBundleXThreadMonitorMapper3D.cpp @@ -1,120 +1,214 @@ /*========================================================================= Program: Medical Imaging & Interaction Toolkit Language: C++ Date: $Date: 2009-05-12 19:56:03 +0200 (Di, 12 Mai 2009) $ Version: $Revision: 17179 $ Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. See MITKCopyright.txt or http://www.mitk.org/copyright.html for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "mitkFiberBundleXThreadMonitorMapper3D.h" #include #include //#include #include mitk::FiberBundleXThreadMonitorMapper3D::FiberBundleXThreadMonitorMapper3D() -:m_FiberMonitorMapper(vtkSmartPointer::New()), - m_TextActor(vtkSmartPointer::New()), - m_FiberAssembly(vtkPropAssembly::New()) +: m_FiberMonitorMapper(vtkSmartPointer::New()) +, m_TextActorClose(vtkSmartPointer::New()) +, m_TextActorOpen(vtkSmartPointer::New()) +, m_TextActorHeading(vtkSmartPointer::New()) +, m_TextActorMask(vtkSmartPointer::New()) +, m_TextActorStatus(vtkSmartPointer::New()) +, m_TextActorStarted(vtkSmartPointer::New()) +, m_TextActorFinished(vtkSmartPointer::New()) +, m_TextActorTerminated(vtkSmartPointer::New()) +, m_FiberAssembly(vtkPropAssembly::New()) +, m_lastModifiedMonitorNodeTime(-1) { -m_FiberAssembly->AddPart(m_TextActor); + m_FiberAssembly->AddPart(m_TextActorClose); + m_FiberAssembly->AddPart(m_TextActorOpen); + m_FiberAssembly->AddPart(m_TextActorHeading); + m_FiberAssembly->AddPart(m_TextActorMask); + m_FiberAssembly->AddPart(m_TextActorStatus); + m_FiberAssembly->AddPart(m_TextActorStarted); + m_FiberAssembly->AddPart(m_TextActorFinished); + m_FiberAssembly->AddPart(m_TextActorTerminated); + } mitk::FiberBundleXThreadMonitorMapper3D::~FiberBundleXThreadMonitorMapper3D() { m_FiberAssembly->Delete(); } const mitk::FiberBundleXThreadMonitor* mitk::FiberBundleXThreadMonitorMapper3D::GetInput() { return static_cast ( GetData() ); } /* This method is called once the mapper gets new input, for UI rotation or changes in colorcoding this method is NOT called */ void mitk::FiberBundleXThreadMonitorMapper3D::GenerateData() { +// MITK_INFO << m_LastUpdateTime; FiberBundleXThreadMonitor* monitor = dynamic_cast ( GetData() ); - m_TextActor->SetInput("FIBER MONITOR\n[activated]"); - vtkTextProperty* tprop = m_TextActor->GetTextProperty(); - tprop->SetFontFamilyToArial (); - tprop->SetLineSpacing(1.0); - tprop->SetFontSize(20); - tprop->SetColor(1.0,0.0,0.0); - m_TextActor->SetDisplayPosition( 20, 20 ); - m_TextActor->Modified(); +// m_TextActor->SetInput( monitor->getTextL1().toStdString().c_str() ); + m_TextActorClose->SetInput( monitor->getBracketClose().toStdString().c_str() ); + vtkTextProperty* tpropClose = m_TextActorClose->GetTextProperty(); + //tprop->SetFontFamilyToArial (); + //tprop->SetLineSpacing(1.0); + tpropClose->SetFontSize(16); + tpropClose->SetColor(0.85,0.8,0.8); + m_TextActorClose->SetDisplayPosition( monitor->getBracketClosePosition()[0], monitor->getBracketClosePosition()[1] ); + //m_TextActorClose->Modified(); + + + m_TextActorOpen->SetInput( monitor->getBracketOpen().toStdString().c_str() ); + vtkTextProperty* tpropOpen = m_TextActorOpen->GetTextProperty(); + //tprop->SetFontFamilyToArial (); + //tprop->SetLineSpacing(1.0); + tpropOpen->SetFontSize(16); + tpropOpen->SetColor(0.85,0.8,0.8); + m_TextActorOpen->SetDisplayPosition( monitor->getBracketOpenPosition()[0], monitor->getBracketOpenPosition()[1] ); + //m_TextActorOpen->Modified(); + + + + m_TextActorHeading->SetInput( monitor->getHeading().toStdString().c_str() ); + vtkTextProperty* tpropHeading = m_TextActorHeading->GetTextProperty(); + tpropHeading->SetFontSize(12); + tpropHeading->SetOpacity( monitor->getHeadingOpacity() * 0.1 ); + tpropHeading->SetColor(0.85,0.8,0.8); + m_TextActorHeading->SetDisplayPosition( monitor->getHeadingPosition()[0], monitor->getHeadingPosition()[1] ); + //m_TextActorHeading->Modified(); + + + m_TextActorMask->SetInput( monitor->getMask().toStdString().c_str() ); + vtkTextProperty* tpropMask = m_TextActorMask->GetTextProperty(); + tpropMask->SetFontSize(12); + tpropMask->SetOpacity( monitor->getMaskOpacity() * 0.1 ); + tpropMask->SetColor(1.0,1.0,1.0); + m_TextActorMask->SetDisplayPosition( monitor->getMaskPosition()[0], monitor->getMaskPosition()[1] ); + //m_TextActorHeading->Modified(); + + m_TextActorStatus->SetInput(monitor->getStatus().toStdString().c_str()); + vtkTextProperty* tpropStatus = m_TextActorStatus->GetTextProperty(); + tpropStatus->SetFontSize(10); + tpropStatus->SetOpacity( monitor->getStatusOpacity() * 0.1 ); + tpropStatus->SetColor(0.85,0.8,0.8); + m_TextActorStatus->SetDisplayPosition( monitor->getStatusPosition()[0], monitor->getStatusPosition()[1] ); + //m_TextActorStatus->Modified(); + m_TextActorStarted->SetInput(QString::number(monitor->getStarted()).toStdString().c_str()); + vtkTextProperty* tpropStarted = m_TextActorStarted->GetTextProperty(); + tpropStarted->SetFontSize(12); + tpropStarted->SetOpacity( monitor->getStartedOpacity() * 0.1 ); + tpropStarted->SetColor(0.0,1.0,0.0); + m_TextActorStarted->SetDisplayPosition( monitor->getStartedPosition()[0], monitor->getStartedPosition()[1] ); + //m_TextActorStarted->Modified(); + + m_TextActorFinished->SetInput(QString::number(monitor->getFinished()).toStdString().c_str()); + vtkTextProperty* tpropFinished = m_TextActorFinished->GetTextProperty(); + tpropFinished->SetFontSize(12); + tpropFinished->SetOpacity( monitor->getFinishedOpacity() * 0.1 ); + tpropFinished->SetColor(1.0,1.0,1.0); + m_TextActorFinished->SetDisplayPosition( monitor->getFinishedPosition()[0], monitor->getFinishedPosition()[1] ); + //m_TextActorFinished->Modified(); + + m_TextActorTerminated->SetInput(QString::number(monitor->getTerminated()).toStdString().c_str()); + vtkTextProperty* tpropTerminated = m_TextActorTerminated->GetTextProperty(); + tpropTerminated->SetFontSize(12); + tpropTerminated->SetOpacity( monitor->getTerminatedOpacity() * 0.1 ); + tpropTerminated->SetColor(1.0,1.0,1.0); + m_TextActorTerminated->SetDisplayPosition( monitor->getTerminatedPosition()[0], monitor->getTerminatedPosition()[1] ); + //m_TextActorTerminated->Modified(); + + } void mitk::FiberBundleXThreadMonitorMapper3D::GenerateDataForRenderer( mitk::BaseRenderer *renderer ) { - //MITK_INFO << "FiberBundleXxXXMapper3D()DataForRenderer"; - //ToDo do update checks - this->GenerateData(); + if ( !this->IsVisible( renderer ) ) + { + return; + } + + // Calculate time step of the input data for the specified renderer (integer value) + // this method is implemented in mitkMapper +// this->CalculateTimeStep( renderer ); + + const DataNode *node = this->GetDataNode(); + + + if (m_lastModifiedMonitorNodeTime < node->GetMTime()) + { + this->GenerateData(); + m_lastModifiedMonitorNodeTime = node->GetMTime(); + } } void mitk::FiberBundleXThreadMonitorMapper3D::SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer, bool overwrite) { // MITK_INFO << "FiberBundleXxXXMapper3D()SetDefaultProperties"; Superclass::SetDefaultProperties(node, renderer, overwrite); } vtkProp* mitk::FiberBundleXThreadMonitorMapper3D::GetVtkProp(mitk::BaseRenderer *renderer) { //MITK_INFO << "FiberBundleXxXXMapper3D()GetVTKProp"; //this->GenerateData(); return m_FiberAssembly; } void mitk::FiberBundleXThreadMonitorMapper3D::ApplyProperties(mitk::BaseRenderer* renderer) { // MITK_INFO << "FiberBundleXXXXMapper3D ApplyProperties(renderer)"; } void mitk::FiberBundleXThreadMonitorMapper3D::UpdateVtkObjects() { // MITK_INFO << "FiberBundleXxxXMapper3D UpdateVtkObjects()"; } void mitk::FiberBundleXThreadMonitorMapper3D::SetVtkMapperImmediateModeRendering(vtkMapper *) { } diff --git a/Modules/DiffusionImaging/Rendering/mitkFiberBundleXThreadMonitorMapper3D.h b/Modules/DiffusionImaging/Rendering/mitkFiberBundleXThreadMonitorMapper3D.h index d24fb53dbc..8c4db2f9a1 100644 --- a/Modules/DiffusionImaging/Rendering/mitkFiberBundleXThreadMonitorMapper3D.h +++ b/Modules/DiffusionImaging/Rendering/mitkFiberBundleXThreadMonitorMapper3D.h @@ -1,82 +1,91 @@ /*========================================================================= Program: Medical Imaging & Interaction Toolkit Language: C++ Date: $Date: 2009-05-12 19:56:03 +0200 (Di, 12 Mai 2009) $ Version: $Revision: 17179 $ Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. See MITKCopyright.txt or http://www.mitk.org/copyright.html for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #ifndef FiberBundleXThreadMonitorMapper3D_H_HEADER_INCLUDED #define FiberBundleXThreadMonitorMapper3D_H_HEADER_INCLUDED //#include //?? necessary #include #include #include #include #include #include class vtkPropAssembly; namespace mitk { //##Documentation //## @brief Mapper for FiberBundleX //## @ingroup Mapper class MitkDiffusionImaging_EXPORT FiberBundleXThreadMonitorMapper3D : public VtkMapper3D { public: mitkClassMacro(FiberBundleXThreadMonitorMapper3D, VtkMapper3D); itkNewMacro(Self); //========== essential implementation for 3D mapper ======== const FiberBundleXThreadMonitor* GetInput(); virtual vtkProp *GetVtkProp(mitk::BaseRenderer *renderer); //looks like depricated.. should be replaced bz GetViewProp() static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = NULL, bool overwrite = false ); virtual void ApplyProperties(mitk::BaseRenderer* renderer); static void SetVtkMapperImmediateModeRendering(vtkMapper *mapper); virtual void GenerateDataForRenderer(mitk::BaseRenderer* renderer); virtual void GenerateData(); //========================================================= protected: FiberBundleXThreadMonitorMapper3D(); virtual ~FiberBundleXThreadMonitorMapper3D(); void UpdateVtkObjects(); //?? vtkSmartPointer m_FiberMonitorMapper; - vtkSmartPointer m_TextActor; + vtkSmartPointer m_TextActorClose; + vtkSmartPointer m_TextActorOpen; + vtkSmartPointer m_TextActorHeading; + vtkSmartPointer m_TextActorMask; + vtkSmartPointer m_TextActorStatus; + vtkSmartPointer m_TextActorStarted; + vtkSmartPointer m_TextActorFinished; + vtkSmartPointer m_TextActorTerminated; vtkPropAssembly* m_FiberAssembly; + private: + double m_lastModifiedMonitorNodeTime; }; } // end namespace mitk #endif /* FiberBundleXMapper3D_H_HEADER_INCLUDED */