#include <itkNumericSeriesFileNames.h>
// VTK include
+#include <vtkImageMapper3D.h>
+#include <vtkInformation.h>
+#include <vtkVersion.h>
#include <vtkImageData.h>
#include <vtkImageActor.h>
#include <vtkCornerAnnotation.h>
//------------------------------------------------------------------------------
vvMainWindow::vvMainWindow():vvMainWindowBase()
-{
+{ //out << __func__ << endl;
setupUi(this); // this sets up the GUI
mInputPathName = "";
}
//------------------------------------------------------------------------------
void vvMainWindow::show()
-{
+{ //out << __func__ << endl;
vvMainWindowBase::show();
PopupRegisterForm(true);
}
//------------------------------------------------------------------------------
void vvMainWindow::UpdateMemoryUsage()
-{
+{ //out << __func__ << endl;
// clitk::PrintMemory(true);
if (clitk::GetMemoryUsageInMb() == 0) infoPanel->setMemoryInMb("NA");
else infoPanel->setMemoryInMb(QString::number(clitk::GetMemoryUsageInMb())+" MiB");
//------------------------------------------------------------------------------
void vvMainWindow::createRecentlyOpenedFilesMenu()
-{
+{ //out << __func__ << endl;
recentlyOpenedFilesMenu = new QMenu("Recently opened files...");
recentlyOpenedFilesMenu->setIcon(QIcon(QString::fromUtf8(":/common/icons/open.png")));
menuFile->insertMenu(actionOpen_Image_With_Time,recentlyOpenedFilesMenu);
//------------------------------------------------------------------------------
void vvMainWindow::updateRecentlyOpenedFilesMenu(const std::list<std::string> &recent_files)
-{
+{ //out << __func__ << endl;
if(recentlyOpenedFilesMenu==NULL) {
createRecentlyOpenedFilesMenu();
} else {
//------------------------------------------------------------------------------
void vvMainWindow::ComputeMidPosition()
-{
+{ //out << __func__ << endl;
bool ok;
int index=GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
- int ref = QInputDialog::getInteger(this,"Chose reference phase","Reference phase",0,0,\
- mSlicerManagers[index]->GetImage()->GetVTKImages().size()-1,1,&ok);
+ int ref = QInputDialog::getInt(this,"Chose reference phase","Reference phase",0,0,\
+mSlicerManagers[index]->GetImage()->GetVTKImages().size()-1,1,&ok);
if (ok) {
vvMidPosition midp;
midp.slicer_manager = mSlicerManagers[index];
//------------------------------------------------------------------------------
void vvMainWindow::AddContour(int image_index, vvMesh::Pointer contour, bool propagation)
-{
+{ //out << __func__ << endl;
QTreeWidgetItem *item = new QTreeWidgetItem();
item->setData(0,Qt::UserRole,"filename.vtk");
item->setData(1,Qt::UserRole,tr("contour"));
//------------------------------------------------------------------------------
void vvMainWindow::OpenVTKContour()
-{
+{ //out << __func__ << endl;
if (mSlicerManagers.size() > 0) {
QString Extensions = "Images ( *.vtk *.obj)";
Extensions += ";;All Files (*)";
//------------------------------------------------------------------------------
void vvMainWindow::AddDCStructContour(int index, QString file)
-{
+{ //out << __func__ << endl;
vvMeshReader reader;
reader.SetFilename(file.toStdString());
vvStructSelector selector;
//------------------------------------------------------------------------------
void vvMainWindow::OpenDCStructContour()
-{
+{ //out << __func__ << endl;
if (mSlicerManagers.size() > 0) {
QString Extensions = "Dicom Files ( *.dcm RS*)";
Extensions += ";;All Files (*)";
//------------------------------------------------------------------------------
void vvMainWindow::ComputeDeformableRegistration()
-{
+{ //out << __func__ << endl;
if (mSlicerManagers.size() > 0) {
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
vvDeformationDialog dialog(index,mSlicerManagers);
//------------------------------------------------------------------------------
void vvMainWindow::WarpImage()
-{
+{ //out << __func__ << endl;
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
if (!mSlicerManagers[index]->GetVF().IsNull()) {
bool ok;
- int ref = QInputDialog::getInteger(this,"Chose reference phase","Reference phase",0,0,\
+ int ref = QInputDialog::getInt(this,"Chose reference phase","Reference phase",0,0,\
mSlicerManagers[index]->GetImage()->GetVTKImages().size()-1,1,&ok);
if (ok) {
WarpImage(mSlicerManagers[index],ref);
//------------------------------------------------------------------------------
void vvMainWindow::WarpImage(vvSlicerManager* selected_slicer,int reference_phase)
-{
+{ //out << __func__ << endl;
if (!selected_slicer->GetVF().IsNull()) {
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
QFileInfo info(selected_slicer->GetFileName().c_str());
//------------------------------------------------------------------------------
vvMainWindow::~vvMainWindow()
-{
+{ //out << __func__ << endl;
for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
if (mSlicerManagers[i] != NULL)
delete mSlicerManagers[i];
//------------------------------------------------------------------------------
QTabWidget * vvMainWindow::GetTab()
-{
+{ //out << __func__ << endl;
return tabWidget;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::MergeImages()
-{
+{ //out << __func__ << endl;
QString Extensions = EXTENSIONS;
Extensions += ";;All Files (*)";
QStringList files = QFileDialog::getOpenFileNames(this,tr("Merge Images"),mInputPathName,Extensions);
//------------------------------------------------------------------------------
void vvMainWindow::SliceImages()
-{
+{ //out << __func__ << endl;
QString Extensions = EXTENSIONS;
Extensions += ";;All Files (*)";
//------------------------------------------------------------------------------
void vvMainWindow::MergeImagesWithTime()
-{
+{ //out << __func__ << endl;
QString Extensions = EXTENSIONS;
Extensions += ";;All Files (*)";
QStringList files = QFileDialog::getOpenFileNames(this,tr("Merge Images With Time"),mInputPathName,Extensions);
//------------------------------------------------------------------------------
void vvMainWindow::OpenDicom()
-{
+{ //out << __func__ << endl;
std::vector<std::string> files;
//std::cout << "dicomSeriesSelector " << std::endl;
//------------------------------------------------------------------------------
void vvMainWindow::OpenImages()
-{
+{ //out << __func__ << endl;
QString Extensions = EXTENSIONS;
Extensions += ";;All Files (*)";
}
//------------------------------------------------------------------------------
void vvMainWindow::OpenRecentImage()
-{
+{ //out << __func__ << endl;
QAction * caller = qobject_cast<QAction*>(sender());
std::vector<std::string> images;
images.push_back(caller->text().toStdString());
//------------------------------------------------------------------------------
void vvMainWindow::OpenImageWithTime()
-{
+{ //out << __func__ << endl;
QString Extensions = EXTENSIONS;
Extensions += ";;All Files (*)";
//------------------------------------------------------------------------------
void vvMainWindow::LoadImages(std::vector<std::string> files, vvImageReader::LoadedImageType filetype)
-{
+{ //out << __func__ << endl;
//Separate the way to open images and dicoms
int fileSize;
if (filetype == vvImageReader::IMAGE || filetype == vvImageReader::IMAGEWITHTIME)
// Change filename if an image with the same already exist
int number = GetImageDuplicateFilenameNumber(files[i] + std::string("_slice"));
- if (filetype == vvImageReader::IMAGE || filetype == vvImageReader::IMAGEWITHTIME || filetype == vvImageReader::SLICED)
+ if (filetype == vvImageReader::IMAGE || filetype == vvImageReader::IMAGEWITHTIME || filetype == vvImageReader::SLICED) {
SetImageSucceed = imageManager->SetImage(files[i],filetype, number, j);
- else {
+ } else {
SetImageSucceed = imageManager->SetImages(files,filetype, number);
}
-
- if (!SetImageSucceed) {
+ if (!SetImageSucceed) {;
QApplication::restoreOverrideCursor();
QString error = "Cannot open file \n";
error += imageManager->GetLastError().c_str();
QMessageBox::information(this,tr("Reading problem"),error);
delete imageManager;
} else {
+
mSlicerManagers.push_back(imageManager);
//create an item in the tree with good settings
connect(mSlicerManagers.back(), SIGNAL(ChangeImageWithIndexOffset(vvSlicerManager*,int,int)),
this,SLOT(ChangeImageWithIndexOffset(vvSlicerManager*,int,int)));
connect(mSlicerManagers.back(),SIGNAL(LandmarkAdded()),landmarksPanel,SLOT(AddPoint()));
-
InitSlicers();
numberofsuccesulreads++;
}
}
}
+
if (numberofsuccesulreads) {
NOViewWidget->show();
NEViewWidget->show();
//------------------------------------------------------------------------------
void vvMainWindow::UpdateTree()
-{
+{ //out << __func__ << endl;
DataTree->resizeColumnToContents(COLUMN_TREE);
DataTree->resizeColumnToContents(COLUMN_UL_VIEW);
DataTree->resizeColumnToContents(COLUMN_UR_VIEW);
//------------------------------------------------------------------------------
void vvMainWindow::CurrentImageChanged(std::string id)
-{
+{ //out << __func__ << endl;
if (id == mCurrentSelectedImageId) return; // Do nothing
int selected = 0;
for (int i = 0; i < DataTree->topLevelItemCount(); i++) {
//------------------------------------------------------------------------------
void vvMainWindow::CurrentPickedImageChanged(std::string id)
-{
+{ //out << __func__ << endl;
if (id == mCurrentPickedImageId) return; // Do nothing
int selected = 0;
for (int i = 0; i < DataTree->topLevelItemCount(); i++) {
//------------------------------------------------------------------------------
void vvMainWindow::ImageInfoChanged()
-{
+{ //out << __func__ << endl;
contextActions[6]->setEnabled(1);
contextActions[5]->setEnabled(1);
actionSave_As->setEnabled(1);
//------------------------------------------------------------------------------
void vvMainWindow::ShowDocumentation()
-{
+{ //out << __func__ << endl;
documentation->show();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::PopupRegisterForm(bool checkCanPush)
-{
+{ //out << __func__ << endl;
vvRegisterForm* registerForm = new vvRegisterForm(QUrl("http://www.creatis.insa-lyon.fr/~dsarrut/vvregister/write.php"), getVVSettingsPath(), getSettingsOptionFormat());
if(!checkCanPush) {
registerForm->show();
//------------------------------------------------------------------------------
void vvMainWindow::ShowHelpDialog()
-{
+{ //out << __func__ << endl;
help_dialog->show();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::ChangeViewMode()
-{
+{ //out << __func__ << endl;
typedef struct _SIZE{
QSplitter* splitter;
QList<int> size1, size2;
//------------------------------------------------------------------------------
QString vvMainWindow::GetSizeInBytes(unsigned long size)
-{
+{ //out << __func__ << endl;
QString result = "";// QString::number(size);
//result += " bytes (";
if (size > 1000000000) {
//------------------------------------------------------------------------------
QString vvMainWindow::GetVectorDoubleAsString(std::vector<double> vectorDouble)
-{
+{ //out << __func__ << endl;
QString result;
for (unsigned int i= 0; i < vectorDouble.size(); i++) {
if (i != 0)
//------------------------------------------------------------------------------
QString vvMainWindow::GetVectorIntAsString(std::vector<int> vectorInt)
-{
+{ //out << __func__ << endl;
QString result;
for (unsigned int i= 0; i < vectorInt.size(); i++) {
if (i != 0)
//------------------------------------------------------------------------------
//this actually returns the SlicerManager index!
int vvMainWindow::GetSlicerIndexFromItem(QTreeWidgetItem* item)
-{
+{ //out << __func__ << endl;
QString id = item->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString();
for (int i = 0; i < DataTree->topLevelItemCount(); i++) {
if (DataTree->topLevelItem(i)->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString() == id)
//------------------------------------------------------------------------------
QTreeWidgetItem* vvMainWindow::GetItemFromSlicerManager(vvSlicerManager* sm)
-{
+{ //out << __func__ << endl;
QString id = sm->GetId().c_str();
for (int i = 0; i < DataTree->topLevelItemCount(); i++) {
if (DataTree->topLevelItem(i)->data(COLUMN_IMAGE_NAME,Qt::UserRole).toString() == id)
//------------------------------------------------------------------------------
void vvMainWindow::DisplayChanged(QTreeWidgetItem *clickedItem, int column)
-{
+{ //out << __func__ << endl;
if ( column >= COLUMN_CLOSE_IMAGE || column <= 0)
return;
//------------------------------------------------------------------------------
void vvMainWindow::InitSlicers()
-{
+{ //out << __func__ << endl;
if (mSlicerManagers.size()) {
mSlicerManagers.back()->GenerateDefaultLookupTable();
-
mSlicerManagers.back()->SetSlicerWindow(0,NOViewWidget->GetRenderWindow());
mSlicerManagers.back()->SetSlicerWindow(1,NEViewWidget->GetRenderWindow());
mSlicerManagers.back()->SetSlicerWindow(2,SOViewWidget->GetRenderWindow());
//------------------------------------------------------------------------------
void vvMainWindow::InitDisplay()
-{
+{ //out << __func__ << endl;
if (mSlicerManagers.size()) {
//BE CAREFUL : this is absolutely necessary to set the interactor style
//in order to have the same style instanciation for all SlicerManagers in
bool AlreadySelected = false;
for (int i = 0; i < DataTree->topLevelItemCount(); i++) {
mSlicerManagers[i]->SetInteractorStyleNavigator(j,style);
-
//select the image only if previous are not selected
if (DataTree->topLevelItem(i)->data(j+1,Qt::CheckStateRole).toInt() > 1) {
mSlicerManagers[i]->UpdateSlicer(j,1);
AlreadySelected = true;
} else if (i == DataTree->topLevelItemCount()-1 && !AlreadySelected) {
- if (DataTree->selectedItems().size() == 0)
+ if (DataTree->selectedItems().size() == 0) {
DataTree->topLevelItem(i)->setSelected(1);
+ }
DataTree->topLevelItem(i)->setData(j+1,Qt::CheckStateRole,2);
mSlicerManagers[i]->UpdateSlicer(j,1);
DisplaySliders(i,j);
//------------------------------------------------------------------------------
void vvMainWindow::DisplaySliders(int slicer, int window)
-{
+{ //out << __func__ << endl;
if(!mSlicerManagers[slicer]->GetSlicer(window)->GetRenderer()->GetDraw())
return;
//------------------------------------------------------------------------------
void vvMainWindow::CloseImage(QTreeWidgetItem* item, int column)
-{
+{ //out << __func__ << endl;
int index = GetSlicerIndexFromItem(item);
if (DataTree->topLevelItem(index) != item) {
//------------------------------------------------------------------------------
void vvMainWindow::ReloadImage(QTreeWidgetItem* item, int column)
-{
+{ //out << __func__ << endl;
// int index = GetSlicerIndexFromItem(item);
// QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
// if (item->data(1,Qt::UserRole).toString() == "vector")
//------------------------------------------------------------------------------
void vvMainWindow::MousePositionChanged(int visibility,double x, double y, double z, double X, double Y, double Z , double value)
-{
+{ //out << __func__ << endl;
infoPanel->setCurrentInfo(visibility,x,y,z,X,Y,Z,value);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::VectorChanged(int visibility,double x, double y, double z, double value)
-{
+{ //out << __func__ << endl;
overlayPanel->getCurrentVectorInfo(visibility,x,y,z,value);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::OverlayChanged(int visibility, double valueOver, double valueRef)
-{
+{ //out << __func__ << endl;
overlayPanel->getCurrentOverlayInfo(visibility,valueOver, valueRef);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::FusionChanged(int visibility, double value)
-{
+{ //out << __func__ << endl;
overlayPanel->getCurrentFusionInfo(visibility,value);
}
//------------------------------------------------------------------------------
//or when UpdateWindowLevel() is called ; when slicerManager emits WindowLevelChanged
//when ImageInfoChanged() is called
void vvMainWindow::WindowLevelChanged()
-{
+{ //out << __func__ << endl;
// Base image
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
if(index==-1) return;
//------------------------------------------------------------------------------
void vvMainWindow::WindowLevelEdited()
-{
+{ //out << __func__ << endl;
presetComboBox->setCurrentIndex(WL_USER);
UpdateWindowLevel();
}
//------------------------------------------------------------------------------
void vvMainWindow::SetWindowLevel(double w, double l)
-{
+{ //out << __func__ << endl;
windowSpinBox->setValue(w);
levelSpinBox->setValue(l);
presetComboBox->setCurrentIndex(WL_USER);
//------------------------------------------------------------------------------
void vvMainWindow::UpdateWindowLevel()
-{
+{ //out << __func__ << endl;
if (DataTree->selectedItems().size()) {
if (presetComboBox->currentIndex() == WL_VENTILATION) //For ventilation
colorMapComboBox->setCurrentIndex(5);
//------------------------------------------------------------------------------
void vvMainWindow::UpdateSlicingPreset()
-{
+{ //out << __func__ << endl;
if (DataTree->selectedItems().size()) {
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
mSlicerManagers[index]->SetSlicingPreset(vvSlicerManager::SlicingPresetType(slicingPresetComboBox->currentIndex()));
//------------------------------------------------------------------------------
void vvMainWindow::UpdateColorMap()
-{
+{ //out << __func__ << endl;
if (DataTree->selectedItems().size()) {
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
mSlicerManagers[index]->SetColorMap(colorMapComboBox->currentIndex());
}
//------------------------------------------------------------------------------
void vvMainWindow::SwitchWindowLevel()
-{
+{ //out << __func__ << endl;
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
int window = mSlicerManagers[index]->GetColorWindow();
presetComboBox->setCurrentIndex(WL_USER);
//------------------------------------------------------------------------------
void vvMainWindow::ApplyWindowLevelToAllImages()
-{
+{ //out << __func__ << endl;
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
if(index==-1) return;
double window = mSlicerManagers[index]->GetColorWindow();
//------------------------------------------------------------------------------
void vvMainWindow::ApplyWindowToSetOfImages(double window, unsigned int indexMin, unsigned int indexMax)
-{
+{ //out << __func__ << endl;
for (unsigned int i = indexMin; i <= indexMax && i < mSlicerManagers.size(); i++) {
if (mSlicerManagers[i] == NULL)
continue;
//------------------------------------------------------------------------------
void vvMainWindow::ApplyLevelToSetOfImages(double level, unsigned int indexMin, unsigned int indexMax)
-{
+{ //out << __func__ << endl;
for (unsigned int i = indexMin; i <= indexMax && i < mSlicerManagers.size(); i++) {
if (mSlicerManagers[i] == NULL)
continue;
//------------------------------------------------------------------------------
void vvMainWindow::UpdateLinkManager(std::string id, int slicer, double x, double y, double z, int temps)
-{
+{ //out << __func__ << endl;
for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
if (mSlicerManagers[i]->GetId() == id) {
mSlicerManagers[i]->GetSlicer(slicer)->SetCurrentPosition(x,y,z,temps);
//------------------------------------------------------------------------------
void vvMainWindow::UpdateLinkedNavigation(std::string id, vvSlicerManager * sm, vvSlicer* refSlicer)
-{
+{ //out << __func__ << endl;
for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
if (id == mSlicerManagers[i]->GetId()) {
mSlicerManagers[i]->UpdateLinkedNavigation(refSlicer);
//------------------------------------------------------------------------------
void vvMainWindow::ShowContextMenu(QPoint point)
-{
+{ //out << __func__ << endl;
if (!DataTree->selectedItems().size()) {
contextActions[1]->setEnabled(0);
contextActions[2]->setEnabled(0);
//------------------------------------------------------------------------------
void vvMainWindow::CloseImage()
-{
+{ //out << __func__ << endl;
CloseImage(DataTree->selectedItems()[0],0);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::ReloadImage()
-{
+{ //out << __func__ << endl;
ReloadImage(DataTree->selectedItems()[0],0);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::SelectOverlayImage()
-{
+{ //out << __func__ << endl;
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
//check if one overlay image is added
for (int i = 0; i < files.size(); i++) {
vecFileNames.push_back(files[i].toStdString());
}
+
AddOverlayImage(index,vecFileNames,vvImageReader::IMAGE);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::AddOverlayImage(int index, std::vector<std::string> fileNames, vvImageReader::LoadedImageType type)
-{
+{ //out << __func__ << endl;
QString file(fileNames[0].c_str());
if (QFile::exists(file))
{
//------------------------------------------------------------------------------
void vvMainWindow::AddROI(int index, QString file)
-{
+{ //out << __func__ << endl;
/*
// Get slice manager
//------------------------------------------------------------------------------
void vvMainWindow::SelectFusionImage()
-{
+{ //out << __func__ << endl;
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
//check if one fusion image is added
//------------------------------------------------------------------------------
void vvMainWindow::ResetTransformationToIdentity()
-{
+{ //out << __func__ << endl;
std::string actorType = DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString().toStdString();
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
mSlicerManagers[index]->ResetTransformationToIdentity(actorType);
//------------------------------------------------------------------------------
void vvMainWindow::AddFusionImage(int index, std::vector<std::string> fileNames, vvImageReader::LoadedImageType type)
-{
+{ //out << __func__ << endl;
QString file(fileNames[0].c_str());
if (QFile::exists(file))
{
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::AddLandmarks(int index, std::vector<std::string> files)
-{
+{ //out << __func__ << endl;
if (!landmarksPanel->LoadFromFile(files))
QMessageBox::information(this,tr("Problem reading Landmarks !"),"File doesn't exist!");
//------------------------------------------------------------------------------
void vvMainWindow::OpenField()
-{
+{ //out << __func__ << endl;
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
//check if a vector field has already been added
for (int child = 0; child < DataTree->topLevelItem(index)->childCount(); child++)
//------------------------------------------------------------------------------
void vvMainWindow::AddFieldEntry(QString filename,int index,bool from_disk)
-{
+{ //out << __func__ << endl;
//create an item in the tree with good settings
QTreeWidgetItem *item = new QTreeWidgetItem();
item->setData(0,Qt::UserRole,filename.toStdString().c_str());
//------------------------------------------------------------------------------
void vvMainWindow::AddField(vvImage::Pointer vf,QString file,int index)
-{
+{ //out << __func__ << endl;
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
vvSlicerManager* imageManager = mSlicerManagers[index];
if (imageManager->SetVF(vf,file.toStdString())) {
//------------------------------------------------------------------------------
void vvMainWindow::AddField(QString file,int index)
-{
+{ //out << __func__ << endl;
if (QFile::exists(file)) {
mInputPathName = itksys::SystemTools::GetFilenamePath(file.toStdString()).c_str();
//------------------------------------------------------------------------------
void vvMainWindow::SetVFProperty(int subsampling, int scale, int log, int width, double r, double g, double b)
-{
+{ //out << __func__ << endl;
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
if (mSlicerManagers[index]->GetSlicer(0)->GetVF()) {
for (int i = 0; i < 4; i++) {
//------------------------------------------------------------------------------
void vvMainWindow::SetOverlayProperty(int color, int linked, double window, double level)
-{
+{ //out << __func__ << endl;
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
if (mSlicerManagers[index]->GetSlicer(0)->GetOverlay()) {
mSlicerManagers[index]->SetOverlayColor(color);
//------------------------------------------------------------------------------
void vvMainWindow::SetFusionProperty(int opacity, int thresOpacity, int colormap,double window, double level, bool showLegend)
-{
+{ //out << __func__ << endl;
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
if (mSlicerManagers[index]->GetSlicer(0)->GetFusion()) {
mSlicerManagers[index]->SetFusionColorMap(colormap);
//------------------------------------------------------------------------------
void vvMainWindow::SelectFusionSequence()
-{
+{ //out << __func__ << endl;
//get the index of the slicer manager of the main sequence (CT)
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
//check if one overlay image is already associated
//------------------------------------------------------------------------------
-void vvMainWindow::SelectFusionSequenceCorrespondances() {
-
+void vvMainWindow::SelectFusionSequenceCorrespondances()
+{ //out << __func__ << endl;
//make sure the index is right?
//in the end, I should attach the temporal data to the right sequence!
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
bool signalOK = true;
unsigned nbFrameMain = mSlicerManagers[index]->GetImage()->GetTransform().size();
unsigned nbFrameSecondary = mSlicerManagers[index]->GetFusionSequenceNbFrames();
-std::cout<<"nbFrameMain = "<<nbFrameMain<<", nbFrameSecondary= "<<nbFrameSecondary<<", signal size: "<<tmpVect.size()<<std::endl;
+ std::cout<<"nbFrameMain = "<<nbFrameMain<<", nbFrameSecondary= "<<nbFrameSecondary<<", signal size: "<<tmpVect.size()<<std::endl;
std::vector<unsigned> temporalCorrespondances;
if ( tmpVect.size() == nbFrameMain + nbFrameSecondary ) {
for (unsigned i=0 ; i<tmpVect.size() ; i++) {
//when this function is called index is the slicer manager index corresponding to the main sequence (CT)
//the files behind fileNames points to the data for the secondary sequence
void vvMainWindow::AddFusionSequence(int index, std::vector<std::string> fileNames, vvImageReader::LoadedImageType type)
-{
+{ //out << __func__ << endl;
QString file(fileNames[0].c_str());
if (QFile::exists(file))
{
//------------------------------------------------------------------------------
//fusionSequenceFrameIndex and fusionSequenceNbFrames are relative to the secondary sequence (US)
void vvMainWindow::SetFusionSequenceProperty(int fusionSequenceFrameIndex, bool spatialSyncFlag, unsigned int fusionSequenceNbFrames, bool temporalSyncFlag)
-{
+{ //out << __func__ << endl;
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
if (!mSlicerManagers[index]->IsInvolvedInFusionSequence()) return;
//------------------------------------------------------------------------------
void vvMainWindow::SaveAs()
-{
+{ //out << __func__ << endl;
if (DataTree->selectedItems()[0]->data(1,Qt::UserRole).toString() == "vector") {
QMessageBox::warning(this,tr("Unsupported type"),tr("Sorry, saving a vector field is unsupported for the moment"));
return;
//------------------------------------------------------------------------------
void vvMainWindow::SaveCurrentState()
-{
+{ //out << __func__ << endl;
QString Extensions = "XML Files(*.xml)";
QString fileName = QFileDialog::getSaveFileName(this,
tr("Save Current Window State"),
//------------------------------------------------------------------------------
void vvMainWindow::SaveCurrentStateAs(const std::string& stateFile)
-{
+{ //out << __func__ << endl;
vvSaveState save_state;
save_state.Run(this, stateFile);
}
//------------------------------------------------------------------------------
void vvMainWindow::ReadSavedState()
-{
+{ //out << __func__ << endl;
QString Extensions = "XML Files(*.xml)";
QString fileName = QFileDialog::getOpenFileName(this,
tr("Load Window State"),
//------------------------------------------------------------------------------
void vvMainWindow::ReadSavedStateFile(const std::string& stateFile)
-{
+{ //out << __func__ << endl;
vvReadState read_state;
read_state.Run(this, stateFile);
}
//------------------------------------------------------------------------------
void vvMainWindow::LinkAllImages()
-{
+{ //out << __func__ << endl;
linkPanel->linkAll();
}
//------------------------------------------------------------------------------
void vvMainWindow::AddLink(QString image1,QString image2,bool fromPanel)
-{
+{ //out << __func__ << endl;
if (!fromPanel) {
// delegate to linkPanel if call came from elsewhere...
linkPanel->addLinkFromIds(image1, image2);
//------------------------------------------------------------------------------
void vvMainWindow::RemoveLink(QString image1,QString image2)
-{
+{ //out << __func__ << endl;
for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
if (image1.toStdString() == mSlicerManagers[i]->GetId()) {
mSlicerManagers[i]->RemoveLink(image2.toStdString());
//------------------------------------------------------------------------------
void vvMainWindow::ChangeImageWithIndexOffset(vvSlicerManager *sm, int slicer, int offset)
-{
+{ //out << __func__ << endl;
if(mSlicerManagers.size()==1)
return;
}
//------------------------------------------------------------------------------
void vvMainWindow::HorizontalSliderMoved(int value,int column, int slicer_index)
-{
+{ //out << __func__ << endl;
for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
if (DataTree->topLevelItem(i)->data(column,Qt::CheckStateRole).toInt() > 1) {
//i is the SlicerManager that is in charge of this slicer.
//------------------------------------------------------------------------------
void vvMainWindow::NOHorizontalSliderMoved()
-{
+{ //out << __func__ << endl;
// if (mCurrentTime == NOHorizontalSlider->value()) return;
HorizontalSliderMoved(NOHorizontalSlider->value(),COLUMN_UL_VIEW,0);
// mCurrentTime = NOHorizontalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::NEHorizontalSliderMoved()
-{
+{ //out << __func__ << endl;
// if (mCurrentTime == NEHorizontalSlider->value()) return;
HorizontalSliderMoved(NEHorizontalSlider->value(),COLUMN_UR_VIEW,1);
// mCurrentTime = NEHorizontalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::SOHorizontalSliderMoved()
-{
+{ //out << __func__ << endl;
// if (mCurrentTime == SOHorizontalSlider->value()) return;
HorizontalSliderMoved(SOHorizontalSlider->value(),COLUMN_DL_VIEW,2);
// mCurrentTime = SOHorizontalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::SEHorizontalSliderMoved()
-{
+{ //out << __func__ << endl;
// if (mCurrentTime == SEHorizontalSlider->value()) return;
HorizontalSliderMoved(SEHorizontalSlider->value(),COLUMN_DR_VIEW,3);
// mCurrentTime = SEHorizontalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::NOVerticalSliderChanged()
-{
+{ //out << __func__ << endl;
static int value=-1;
if (value == NOVerticalSlider->value()) return;
else value = NOVerticalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::NEVerticalSliderChanged()
-{
+{ //out << __func__ << endl;
static int value=-1;
if (value == NEVerticalSlider->value()) return;
else value = NEVerticalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::SOVerticalSliderChanged()
-{
+{ //out << __func__ << endl;
static int value=-1;
if (value == SOVerticalSlider->value()) return;
else value = SOVerticalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::SEVerticalSliderChanged()
-{
+{ //out << __func__ << endl;
static int value=-1;
if (value == SEVerticalSlider->value()) return;
else value = SEVerticalSlider->value();
//------------------------------------------------------------------------------
void vvMainWindow::UpdateSlice(int slicer, int slice)
-{
+{ //out << __func__ << endl;
// DD("vvMainWindow::UpdateSlice");
// DD(slicer);
// DD(slice);
//------------------------------------------------------------------------------
void vvMainWindow::UpdateTSlice(int slicer, int slice, int code)
-{
+{ //out << __func__ << endl;
//FusionSequence: the slider value should be updated for slicers which show the same sequence as requested
bool doUpdate=false;
if (code==-1) doUpdate=true;
//------------------------------------------------------------------------------
void vvMainWindow::UpdateSliceRange(int slicer, int min, int max, int tmin, int tmax)
-{
+{ //out << __func__ << endl;
//int position = int((min+max)/2);
int position = mSlicerManagers[mCurrentPickedImageIndex]->GetSlicer(slicer)->GetSlice();
if (slicer == 0) {
//------------------------------------------------------------------------------
void vvMainWindow::SaveNOScreenshot()
-{
+{ //out << __func__ << endl;
SaveScreenshot(NOViewWidget);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::SaveNEScreenshot()
-{
+{ //out << __func__ << endl;
SaveScreenshot(NEViewWidget);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::SaveSOScreenshot()
-{
+{ //out << __func__ << endl;
SaveScreenshot(SOViewWidget);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::SaveSEScreenshot()
-{
+{ //out << __func__ << endl;
SaveScreenshot(SEViewWidget);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvMainWindow::SaveScreenshotAllSlices()
-{
+{ //out << __func__ << endl;
QVTKWidget *widget = NOViewWidget;
int index = 0;// GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
fn = itksys::SystemTools::GetFilenamePath(filename.toStdString()) + "/"+ fn
+ "_" + num + itksys::SystemTools::GetFilenameLastExtension(filename.toStdString());
writer->SetFileName(fn.c_str());
+#if VTK_MAJOR_VERSION <= 5
writer->SetInput(windowToImageFilter->GetOutput());
+#else
+ writer->SetInputConnection(windowToImageFilter->GetOutputPort());
+#endif
writer->Write();
}
}
//------------------------------------------------------------------------------
void vvMainWindow::SaveScreenshot(QVTKWidget *widget)
-{
+{ //out << __func__ << endl;
QString Extensions = "Images( *.png);;";
Extensions += "Images( *.jpg);;";
Extensions += "Images( *.bmp);;";
// Snapshot image if not null
if(imgwriter!=NULL) {
+#if VTK_MAJOR_VERSION <= 5
imgwriter->SetInput(image);
+#else
+ imgwriter->SetInputConnection(w2i->GetOutputPort());
+#endif
imgwriter->SetFileName(fileName.toStdString().c_str());
imgwriter->Write();
return;
// FPS
bool ok;
- int fps = QInputDialog::getInteger(this, tr("Number of frames per second"),
+ int fps = QInputDialog::getInt(this, tr("Number of frames per second"),
tr("FPS:"), 5, 0, 1000, 1, &ok);
if(ok)
gif->SetRate(fps);
// Loops
- int loops = QInputDialog::getInteger(this, tr("Loops"),
+ int loops = QInputDialog::getInt(this, tr("Loops"),
tr("Number of loops (0 means infinite):"), 0, 0, 1000000000, 1, &ok);
if(ok)
gif->SetLoops(loops);
// Take video if not null
if(vidwriter!=NULL){
+#if VTK_MAJOR_VERSION <= 5
vidwriter->SetInput(image);
+#else
+ vidwriter->SetInputConnection(w2i->GetOutputPort());
+#endif
vidwriter->SetFileName(fileName.toStdString().c_str());
vidwriter->Start();
int nSlice = mSlicerManagers[smIndex]->GetSlicer(0)->GetTMax();
vtkSmartPointer<vtkWindowToImageFilter> w2i = vtkSmartPointer<vtkWindowToImageFilter>::New();
w2i->SetInput(widget->GetRenderWindow());
w2i->Update();
+#if VTK_MAJOR_VERSION <= 5
vidwriter->SetInput(w2i->GetOutput());
+#else
+ vidwriter->SetInputConnection(w2i->GetOutputPort());
+#endif
vidwriter->Write();
}
vidwriter->End();
//------------------------------------------------------------------------------
void vvMainWindow::GoToCursor()
-{
+{ //out << __func__ << endl;
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
for (int column = 1; column < 5; column++) {
if (DataTree->selectedItems()[0]->data(column,Qt::CheckStateRole).toInt() > 1) {
//------------------------------------------------------------------------------
void vvMainWindow::GoToLandmark()
-{
+{ //out << __func__ << endl;
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
for (int column = 1; column < 5; column++) {
if (DataTree->selectedItems()[0]->data(column,Qt::CheckStateRole).toInt() > 1) {
//------------------------------------------------------------------------------
void vvMainWindow::PlayPause()
-{
+{ //out << __func__ << endl;
if (playMode) {
playMode = 0;
playButton->setIcon(QIcon(QString::fromUtf8(":/common/icons/player_play.png")));
//------------------------------------------------------------------------------
void vvMainWindow::PlayNext()
-{
+{ //out << __func__ << endl;
if (playMode && !this->isHidden()) {
int image_number=DataTree->topLevelItemCount();
///Only play one slicer per SM, and only if the SM is being displayed
//------------------------------------------------------------------------------
void vvMainWindow::ShowLastImage()
-{
+{ //out << __func__ << endl;
if (mSlicerManagers.size() > 1) {
QTreeWidgetItem * item=DataTree->topLevelItem(DataTree->topLevelItemCount()-1);
CurrentImageChanged(mSlicerManagers.back()->GetId()); //select new image
item->setData(1,Qt::CheckStateRole,2); //show the new image in the first panel
+ //mSlicerManagers[GetSlicerIndexFromItem(item)]->GetSlicer(0)->SetActorVisibility("image", 0, 1); //Set the Last Image visibles
DisplayChanged(item,1);
}
}
//------------------------------------------------------------------------------
void vvMainWindow::UpdateRenderWindows()
-{
+{ //out << __func__ << endl;
for (unsigned int i = 0; i < mSlicerManagers.size(); i++) {
mSlicerManagers[i]->GetSlicer(0)->UpdateLandmarks();
mSlicerManagers[i]->GetSlicer(1)->UpdateLandmarks();
//------------------------------------------------------------------------------
void vvMainWindow::SegmentationOnCurrentImage()
-{
+{ //out << __func__ << endl;
int index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
vvSegmentationDialog segmentation;
//------------------------------------------------------------------------------
void vvMainWindow::SurfaceViewerLaunch()
-{
+{ //out << __func__ << endl;
vvSurfaceViewerDialog surfaceViewer;
surfaceViewer.exec();
}
//------------------------------------------------------------------------------
int vvMainWindow::GetImageDuplicateFilenameNumber(std::string filename)
-{
+{ //out << __func__ << endl;
int number=0;
for(unsigned int l=0; l<mSlicerManagers.size(); l++) {
vvSlicerManager * v = mSlicerManagers[l];
//------------------------------------------------------------------------------
vvSlicerManager* vvMainWindow::AddImage(vvImage::Pointer image,std::string filename)
-{
+{ //out << __func__ << endl;
// Change filename if another image exist with the same name
int number = GetImageDuplicateFilenameNumber(filename);
connect(mSlicerManagers.back(), SIGNAL(LandmarkAdded()),landmarksPanel,SLOT(AddPoint()));
+
+ InitSlicers();
UpdateTree();
qApp->processEvents();
- InitSlicers();
- ShowLastImage();
InitDisplay();
+ ShowLastImage();
qApp->processEvents();
-
// End
ImageInfoChanged();
return slicer_manager;
//------------------------------------------------------------------------------
void vvMainWindow::UpdateCurrentSlicer()
-{
+{ //out << __func__ << endl;
int index = -1;
if (DataTree->selectedItems().size() > 0) {
index = GetSlicerIndexFromItem(DataTree->selectedItems()[0]);
git://git.creatis.insa-lyon.fr / clitk.git / blobdiff