예제 #1
0
void v3dDataFibers::generateThumbnails() const
{
    d->thumbnails.clear();

    // we must use a parent to prevent infinte recursion of the QVTKWidget
    // see: http://vtk.1045678.n5.nabble.com/qtimageviewer-example-crashes-with-vtk-5-6-0-td1249263.html
    //
    QWidget *parent = new QWidget;

    QVTKWidget *widget = new QVTKWidget (parent);
    QVBoxLayout *l = new QVBoxLayout(parent);
    l->setContentsMargins(0,0,0,0);
    l->addWidget(widget);


    vtkPolyDataMapper *mapper = vtkPolyDataMapper::New();
    vtkActor *actor = vtkActor::New();
    vtkRenderer *renderer = vtkRenderer::New();
    vtkRenderWindow *window = vtkRenderWindow::New();
    widget->SetRenderWindow(window);

    parent->setFixedSize(128,128);
    parent->show();

    mapper->SetInput (d->data->GetFibers());
    actor->SetMapper (mapper);
    renderer->AddViewProp(actor);
    window->SetSize (128,128);
    window->AddRenderer (renderer);
    //window->OffScreenRenderingOn();
    renderer->ResetCamera();

    //window->Render();
    parent->update();

    // make sure widget is shown and that openGL context is initialized
    // otherwise, an infinite loop happens when calling GetRGBACharPixelData
    qApp->processEvents();

    unsigned int w=128, h=128;
    d->thumbnail = QImage(w, h, QImage::Format_ARGB32);

    vtkUnsignedCharArray* pixels = vtkUnsignedCharArray::New();
    pixels->SetArray(d->thumbnail.bits(), w*h*4, 1);
    window->GetRGBACharPixelData(0, 0, w-1, h-1, 1, pixels);

    parent->hide();

    d->thumbnails.append (d->thumbnail);

    pixels->Delete();
    mapper->Delete();
    actor->Delete();
    renderer->Delete();
    window->Delete(); // crash if window is deleted
    parent->deleteLater();
}
예제 #2
0
void vtkDataMesh::createThumbnails()
{
    vtkPointSet * mesh = vtkPointSet::SafeDownCast(d->mesh->GetDataSet());

    unsigned int w=128, h=128;
    QImage img(w, h, QImage::Format_RGB32);
    img.fill(0);

    vtkSmartPointer <vtkDataSetSurfaceFilter> geometryextractor = vtkDataSetSurfaceFilter::New();
    vtkSmartPointer <vtkPolyDataMapper> mapper = vtkPolyDataMapper::New();
    vtkSmartPointer <vtkActor> actor = vtkActor::New();
    vtkSmartPointer <vtkProperty> prop = vtkProperty::New();
    vtkSmartPointer <vtkRenderer> renderer = vtkRenderer::New();
    vtkSmartPointer <vtkRenderWindow> window = vtkRenderWindow::New();

    //ugly trick of doom to have no popups
    QVTKWidget widget;
    widget.resize(w,h);

    geometryextractor->SetInput (mesh);
    mapper->SetInput (geometryextractor->GetOutput());
    actor->SetMapper (mapper);
    actor->SetProperty (prop);
    renderer->AddViewProp(actor);
    window->SetSize (w,h);
    window->SetOffScreenRendering(1);
    window->AddRenderer (renderer);

    renderer->ResetCamera();

    widget.SetRenderWindow(window);
    window->Render();

    vtkSmartPointer <vtkUnsignedCharArray> pixels = vtkUnsignedCharArray::New();
    pixels->SetArray(img.bits(), w*h*4, 1);
    window->GetRGBACharPixelData(0, 0, w-1, h-1, 1, pixels);

    d->thumbnails.push_back (img);
}
int main(int argc, char** argv)
{
	QApplication app(argc, argv);

	QVTKWidget widget;
	widget.resize(256,256);

	// Setup sphere
	vtkSmartPointer<vtkSphereSource> sphereSource = 
		vtkSmartPointer<vtkSphereSource>::New();
	sphereSource->Update();
	vtkSmartPointer<vtkPolyDataMapper> sphereMapper = 
		vtkSmartPointer<vtkPolyDataMapper>::New();
	sphereMapper->SetInputConnection(sphereSource->GetOutputPort());
	vtkSmartPointer<vtkActor> sphereActor = 
		vtkSmartPointer<vtkActor>::New();
	sphereActor->SetMapper(sphereMapper);

	// Setup window
	vtkSmartPointer<vtkRenderWindow> renderWindow = 
		vtkSmartPointer<vtkRenderWindow>::New();

	// Setup renderer
	vtkSmartPointer<vtkRenderer> renderer = 
		vtkSmartPointer<vtkRenderer>::New();
	renderWindow->AddRenderer(renderer);

	renderer->AddActor(sphereActor);
	renderer->ResetCamera();

	widget.SetRenderWindow(renderWindow);
	widget.show();

	app.exec();

	return EXIT_SUCCESS;
}
예제 #4
0
void KWidget_2D_left:: SetupRenderWindow() {

  kvImageRenderer = vtkSmartPointer<vtkRenderer>::New();
  // This is where multiple actors are added / multiple label maps here
  kvImageRenderer->AddActor( imageActor );
  if( bNoInputLabelFiles )
    kvImageRenderer->AddActor( multiLabelMaps[0]->labelActor2D );
  kvImageRenderer->SetBackground(0,0,0);

  renderWindowLeft = vtkSmartPointer<vtkRenderWindow>::New();
  renderWindowLeft->AddRenderer( kvImageRenderer );

  sliceViewPicker = vtkSmartPointer<vtkPropPicker>::New();
  sliceViewPicker->PickFromListOn();
  sliceViewPicker->AddPickList( imageActor );
  image_interactor_style = vtkSmartPointer<vtkInteractorStyleImage>::New();

  vtkRenderWindow* window_alias = renderWindowLeft;
  QVTKWidget* qvtk = qVTK_widget_left;
  qvtk->GetRenderWindow()->GetInteractor( )->SetInteractorStyle( image_interactor_style );
  qvtk->SetRenderWindow( window_alias );
  window_alias->GetInteractor( )->SetInteractorStyle( image_interactor_style );

}
예제 #5
0
int main(int argc, char** argv) {
  QApplication app(argc, argv);

  Tr tr;            // 3D-Delaunay triangulation
  C2t3 c2t3 (tr);   // 2D-complex in 3D-Delaunay triangulation

  // the 'function' is a 3D gray level image
  Gray_level_image image("../../../examples/Surface_mesher/data/skull_2.9.inr", 2.9);

  // Carefully choosen bounding sphere: the center must be inside the
  // surface defined by 'image' and the radius must be high enough so that
  // the sphere actually bounds the whole image.
  GT::Point_3 bounding_sphere_center(122., 102., 117.);
  GT::FT bounding_sphere_squared_radius = 200.*200.*2.;
  GT::Sphere_3 bounding_sphere(bounding_sphere_center,
                                   bounding_sphere_squared_radius);

  // definition of the surface, with 10^-2 as relative precision
  Surface_3 surface(image, bounding_sphere, 1e-5);

  // defining meshing criteria
  CGAL::Surface_mesh_default_criteria_3<Tr> criteria(30.,
                                                     5.,
                                                     1.);

  // meshing surface, with the "manifold without boundary" algorithm
  CGAL::make_surface_mesh(c2t3, surface, criteria, CGAL::Manifold_tag());

  QVTKWidget widget;
  widget.resize(256,256);

//   vtkImageData* vtk_image = CGAL::vtk_image_sharing_same_data_pointer(image);

  vtkRenderer *aRenderer = vtkRenderer::New();
  vtkRenderWindow *renWin = vtkRenderWindow::New();
    renWin->AddRenderer(aRenderer);

  widget.SetRenderWindow(renWin);

//   vtkContourFilter *skinExtractor = vtkContourFilter::New();
//     skinExtractor->SetInput(vtk_image);
//     skinExtractor->SetValue(0, isovalue);
//     skinExtractor->SetComputeNormals(0);
  vtkPolyDataNormals *skinNormals = vtkPolyDataNormals::New();
//     skinNormals->SetInputConnection(skinExtractor->GetOutputPort());
  vtkPolyData* polydata = CGAL::output_c2t3_to_vtk_polydata(c2t3);
  skinNormals->SetInput(polydata);
    skinNormals->SetFeatureAngle(60.0);
  vtkPolyDataMapper *skinMapper = vtkPolyDataMapper::New();
//     skinMapper->SetInputConnection(skinExtractor->GetOutputPort());
  skinMapper->SetInput(polydata);
    skinMapper->ScalarVisibilityOff();
  vtkActor *skin = vtkActor::New();
    skin->SetMapper(skinMapper);

  // An outline provides context around the data.
  //
//   vtkOutlineFilter *outlineData = vtkOutlineFilter::New();
//     outlineData->SetInput(vtk_image);
//   vtkPolyDataMapper *mapOutline = vtkPolyDataMapper::New();
//     mapOutline->SetInputConnection(outlineData->GetOutputPort());
//   vtkActor *outline = vtkActor::New();
//     outline->SetMapper(mapOutline);
//     outline->GetProperty()->SetColor(0,0,0);

  // It is convenient to create an initial view of the data. The FocalPoint
  // and Position form a vector direction. Later on (ResetCamera() method)
  // this vector is used to position the camera to look at the data in
  // this direction.
  vtkCamera *aCamera = vtkCamera::New();
    aCamera->SetViewUp (0, 0, -1);
    aCamera->SetPosition (0, 1, 0);
    aCamera->SetFocalPoint (0, 0, 0);
    aCamera->ComputeViewPlaneNormal();

  // Actors are added to the renderer. An initial camera view is created.
  // The Dolly() method moves the camera towards the FocalPoint,
  // thereby enlarging the image.
//   aRenderer->AddActor(outline);
  aRenderer->AddActor(skin);
  aRenderer->SetActiveCamera(aCamera);
  aRenderer->ResetCamera ();
  aCamera->Dolly(1.5);

  // Set a background color for the renderer and set the size of the
  // render window (expressed in pixels).
  aRenderer->SetBackground(1,1,1);
  renWin->SetSize(640, 480);

  // Note that when camera movement occurs (as it does in the Dolly()
  // method), the clipping planes often need adjusting. Clipping planes
  // consist of two planes: near and far along the view direction. The 
  // near plane clips out objects in front of the plane; the far plane
  // clips out objects behind the plane. This way only what is drawn
  // between the planes is actually rendered.
  aRenderer->ResetCameraClippingRange ();

  // Initialize the event loop and then start it.
//   iren->Initialize();
//   iren->Start(); 

  // It is important to delete all objects created previously to prevent
  // memory leaks. In this case, since the program is on its way to
  // exiting, it is not so important. But in applications it is
  // essential.
//   vtk_image->Delete();
//   skinExtractor->Delete();
  skinNormals->Delete();
  skinMapper->Delete();
  skin->Delete();
//   outlineData->Delete();
//   mapOutline->Delete();
//   outline->Delete();
  aCamera->Delete();
//   iren->Delete();
  renWin->Delete();
  aRenderer->Delete();
  polydata->Delete();

  widget.show();

  app.exec();
  
  return 0;
}
예제 #6
0
int main(int argc, char** argv)
{
  QApplication app(argc, argv);

  if(argc != 3)
    usage_and_exit(argv[0]);

  QVTKWidget widget;
  widget.resize(256,256);
 
#if QT_VERSION < 0x040000
  app.setMainWidget(&widget);
#endif

  CGAL::Image_3 image;
  if(!image.read(argv[1]))
  {
    std::cerr << "Cannot read image file \"" << argv[1] << "\"!\n";
    usage_and_exit(argv[0]);
  }

  std::stringstream argv2;
  argv2 << argv[2];
  double isovalue;
  if(!(argv2 >> isovalue))
  {
    std::cerr << "Invalid iso-value \"" << argv[2] << "\"!\n";
    usage_and_exit(argv[0]);
  }

  vtkImageData* vtk_image = CGAL::vtk_image_sharing_same_data_pointer(image);

  vtkRenderer *aRenderer = vtkRenderer::New();
  vtkRenderWindow *renWin = vtkRenderWindow::New();
    renWin->AddRenderer(aRenderer);

  widget.SetRenderWindow(renWin);

  vtkContourFilter *skinExtractor = vtkContourFilter::New();
    skinExtractor->SetInputData(vtk_image);
    skinExtractor->SetValue(0, isovalue);
//     skinExtractor->SetComputeNormals(0);
  vtkPolyDataNormals *skinNormals = vtkPolyDataNormals::New();
    skinNormals->SetInputConnection(skinExtractor->GetOutputPort());
    skinNormals->SetFeatureAngle(60.0);
  vtkPolyDataMapper *skinMapper = vtkPolyDataMapper::New();
    skinMapper->SetInputConnection(skinExtractor->GetOutputPort());
    skinMapper->ScalarVisibilityOff();
  vtkActor *skin = vtkActor::New();
    skin->SetMapper(skinMapper);

  // An outline provides context around the data.
  //
  vtkOutlineFilter *outlineData = vtkOutlineFilter::New();
    outlineData->SetInputData(vtk_image);
  vtkPolyDataMapper *mapOutline = vtkPolyDataMapper::New();
    mapOutline->SetInputConnection(outlineData->GetOutputPort());
  vtkActor *outline = vtkActor::New();
    outline->SetMapper(mapOutline);
    outline->GetProperty()->SetColor(0,0,0);

  // It is convenient to create an initial view of the data. The FocalPoint
  // and Position form a vector direction. Later on (ResetCamera() method)
  // this vector is used to position the camera to look at the data in
  // this direction.
  vtkCamera *aCamera = vtkCamera::New();
    aCamera->SetViewUp (0, 0, -1);
    aCamera->SetPosition (0, 1, 0);
    aCamera->SetFocalPoint (0, 0, 0);
    aCamera->ComputeViewPlaneNormal();

  // Actors are added to the renderer. An initial camera view is created.
  // The Dolly() method moves the camera towards the FocalPoint,
  // thereby enlarging the image.
  aRenderer->AddActor(outline);
  aRenderer->AddActor(skin);
  aRenderer->SetActiveCamera(aCamera);
  aRenderer->ResetCamera ();
  aCamera->Dolly(1.5);

  // Set a background color for the renderer and set the size of the
  // render window (expressed in pixels).
  aRenderer->SetBackground(1,1,1);
  renWin->SetSize(640, 480);

  // Note that when camera movement occurs (as it does in the Dolly()
  // method), the clipping planes often need adjusting. Clipping planes
  // consist of two planes: near and far along the view direction. The 
  // near plane clips out objects in front of the plane; the far plane
  // clips out objects behind the plane. This way only what is drawn
  // between the planes is actually rendered.
  aRenderer->ResetCameraClippingRange ();

  // Initialize the event loop and then start it.
//   iren->Initialize();
//   iren->Start(); 

  // It is important to delete all objects created previously to prevent
  // memory leaks. In this case, since the program is on its way to
  // exiting, it is not so important. But in applications it is
  // essential.
  vtk_image->Delete();
  skinExtractor->Delete();
  skinNormals->Delete();
  skinMapper->Delete();
  skin->Delete();
  outlineData->Delete();
  mapOutline->Delete();
  outline->Delete();
  aCamera->Delete();
//   iren->Delete();
  renWin->Delete();
  aRenderer->Delete();

  widget.show();

  app.exec();
  
  return 0;
}
예제 #7
0
void Ui::openComponentDialog()
{
    addComponentDialog = new QDialog(this); // set as child of Ui, to be sure that it will be deleted in the end.
    QVBoxLayout *dialogLayout = new QVBoxLayout; // create vertical layout

    QVTKWidget *dialogVisualizer = new QVTKWidget; // create qvtk widget
    dialogViewer = new pcl::visualization::PCLVisualizer("Dialog Viewer", false);
    dialogVisualizer->SetRenderWindow(dialogViewer->getRenderWindow()); // set as render window the render window of the dialog visualizer
    dialogViewer->setupInteractor(dialogVisualizer->GetInteractor(), dialogVisualizer->GetRenderWindow()); // tells the visualizer what interactor is using now and for what window
    dialogViewer->getInteractorStyle()->setKeyboardModifier(pcl::visualization::INTERACTOR_KB_MOD_SHIFT); // ripristina input system of original visualizer (shift+click for points)
    pcl::PointCloud<pcl::PointXYZRGB>::Ptr temp = motor->getTargetCloud();
    pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> rgb(temp);
    dialogViewer->addPointCloud<pcl::PointXYZRGB>(temp, rgb, "cloud");
    dialogViewer->setBackgroundColor(0.5, 0.5, 0.5);
    dialogViewer->initCameraParameters();
    dialogViewer->resetCamera();
    componentCallbackConnection = dialogViewer->registerPointPickingCallback(&pointPickCallback, this); // callback standard non segmenta nulla

    QLineEdit *addComponentDialogName  = new QLineEdit("Insert Component Name");
    addComponentDialogName->setObjectName("componentname");

    QHBoxLayout *dialogControlsLayout = new QHBoxLayout;

    QVBoxLayout *buttonsBox = new QVBoxLayout;
    QPushButton *selectPointButton = new QPushButton("Select Component");
    connect(selectPointButton, SIGNAL(clicked()), this, SLOT(setComponentDialogCallback()));
    QPushButton *resetButton = new QPushButton("Reset Selection");
    connect(resetButton, SIGNAL(clicked()), this, SLOT(resetComponentDialogCallback()));
    buttonsBox->addWidget(selectPointButton);
    buttonsBox->addWidget(resetButton);

    QVBoxLayout *numbersBox = new QVBoxLayout;
    QColor *selectedColor = new QColor(0, 0, 0, 255); // initialize color at black
    QPushButton *colorBox = new QPushButton("+-100");
    colorBox->setObjectName("colorbox");
    colorBox->setStyleSheet(colorToStyleSheet(selectedColor));
    colorBox->setMaximumWidth(50);
    QLineEdit *clusterBox = new QLineEdit("1");
    clusterBox->setReadOnly(true);
    clusterBox->setObjectName("clusterbox");
    clusterBox->setMaxLength(5);
    clusterBox->setMaximumWidth(50);
    numbersBox->addWidget(clusterBox);
    numbersBox->addWidget(colorBox);

    QVBoxLayout *slidersBox = new QVBoxLayout;
    QSlider *setCluThresholdBar = new QSlider(Qt::Horizontal);
    setCluThresholdBar->setRange(0,5000);
    setCluThresholdBar->setValue(1000);
    motor->setClusterSegThreshold(1000);
    setCluThresholdBar->setObjectName("sliderCluster");
    connect(setCluThresholdBar, SIGNAL(sliderReleased()), this, SLOT(setClusterThreshold()));
    QSlider *setColThresholdBar = new QSlider(Qt::Horizontal);
    setColThresholdBar->setRange(0,255);
    setColThresholdBar->setValue(100);
    motor->setColorSegThreshold(100);
    setColThresholdBar->setObjectName("sliderColor");
    connect(setColThresholdBar, SIGNAL(sliderReleased()), this, SLOT(setColorThreshold()));
    slidersBox->addWidget(setCluThresholdBar);
    slidersBox->addWidget(setColThresholdBar);

    QPushButton *showSegButton = new QPushButton("Segment!");
    connect(showSegButton, SIGNAL(clicked()), this, SLOT(segmentComponent()));

    dialogControlsLayout->addLayout(buttonsBox);
    dialogControlsLayout->addLayout(numbersBox);
    dialogControlsLayout->addLayout(slidersBox);
    dialogControlsLayout->addWidget(showSegButton);

    QPushButton *saveComponent = new QPushButton("Save to component list");
    saveComponent->setDefault(true); // default button, pressed if enter is pressed
    connect(saveComponent, SIGNAL(clicked()), this, SLOT(saveComponent()));

    dialogLayout->addWidget(dialogVisualizer);
    dialogLayout->addWidget(addComponentDialogName);
    dialogLayout->addLayout(dialogControlsLayout);
    dialogLayout->addWidget(saveComponent);
    addComponentDialog->setLayout(dialogLayout);

    // DIALOG EXECUTION
//    addComponentDialog->deleteLater(); // delete dialog when the control returns to the event loop from which deleteLater() was called (after exec i guess)
//    causa seg fault se viene attivata la callback

    dialogLayout->deleteLater(); // delete dialog layout when the control returns to the event loop from which deleteLater() was called (after exec i guess)
    addComponentDialog->resize(800,600);
    addComponentDialog->exec();
    componentCallbackConnection.disconnect(); // disconnect the callback function from the viewer
    delete dialogViewer; // finita l'esecuzione, deallocare il viewer (deallocare altra eventuale memoria non indirizzata nel QObject tree).
}
예제 #8
0
void Ui::openDiffDialog()
{
    diffDialog = new QDialog(this); // set as child of Ui, to be sure that it will be deleted in the end.
    QVBoxLayout *diffDialogLayout = new QVBoxLayout; // create vertical layout

    QVTKWidget *dialogVisualizer = new QVTKWidget; // create qvtk widget
    dialogViewer = new pcl::visualization::PCLVisualizer("Dialog Viewer", false);
    dialogVisualizer->SetRenderWindow(dialogViewer->getRenderWindow()); // set as render window the render window of the dialog visualizer
    dialogViewer->setupInteractor(dialogVisualizer->GetInteractor(), dialogVisualizer->GetRenderWindow()); // tells the visualizer what interactor is using now and for what window
    dialogViewer->getInteractorStyle()->setKeyboardModifier(pcl::visualization::INTERACTOR_KB_MOD_SHIFT); // ripristina input system of original visualizer (shift+click for points)
    pcl::PointCloud<pcl::PointXYZRGB>::Ptr regCloud = motor->getRegisteredCloud();
    pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> rgb(regCloud);
    pcl::PointCloud<pcl::PointXYZRGB>::Ptr diffCloud = motor->getSourceDiffCloud();
    pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZRGB> green(diffCloud, 0, 255, 0);
    pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZRGB> red(diffCloud, 255, 0, 0);
    int v1(0); int v2(0);
    dialogViewer->createViewPort(0.0, 0.0, 0.5, 1.0, v1);
    dialogViewer->setBackgroundColor(0.5, 0.5, 0.5, v1);
    dialogViewer->addText("TARGET CLOUD", 30, 20,"TARGET CLOUD",v1);
    dialogViewer->createViewPort(0.5, 0.0, 1.0, 1.0, v2);
    dialogViewer->setBackgroundColor(0.5, 0.5, 0.5, v2);
    dialogViewer->addText("SOURCE CLOUD", 30, 20,"SOURCE CLOUD",v2);
    dialogViewer->addPointCloud<pcl::PointXYZRGB>(motor->getTargetCloud(), rgb, "targetCloud", v1);
    dialogViewer->addPointCloud<pcl::PointXYZRGB>(diffCloud, red, "targetDiffCloud", v1);
    dialogViewer->addPointCloud<pcl::PointXYZRGB>(regCloud, rgb, "sourceCloud", v2);
    dialogViewer->addPointCloud<pcl::PointXYZRGB>(diffCloud, green, "sourceDiffCloud", v2);
    dialogViewer->initCameraParameters();
    dialogViewer->resetCamera();
    componentCallbackConnection = dialogViewer->registerPointPickingCallback(&pointPickCallback, this); // callback standard non segmenta nulla

    QHBoxLayout *dialogControlsLayout = new QHBoxLayout;

    QVBoxLayout *numbersBox = new QVBoxLayout;
    QLineEdit *segDiffBox = new QLineEdit("0.5");
    segDiffBox->setReadOnly(true);
    segDiffBox->setObjectName("segdiffbox");
    segDiffBox->setMaxLength(5);
    segDiffBox->setMaximumWidth(50);
    numbersBox->addWidget(segDiffBox);

    QVBoxLayout *slidersBox = new QVBoxLayout;
    QSlider *setSegDiffThresholdBar = new QSlider(Qt::Horizontal);
    setSegDiffThresholdBar->setRange(0, 5000);
    setSegDiffThresholdBar->setValue(500);
    motor->setSegDiffThreshold(500);
    setSegDiffThresholdBar->setObjectName("sliderSegDiff");
    connect(setSegDiffThresholdBar, SIGNAL(sliderReleased()), this, SLOT(setSegDiffThreshold()));
    slidersBox->addWidget(setSegDiffThresholdBar);

    dialogControlsLayout->addLayout(numbersBox);
    dialogControlsLayout->addLayout(slidersBox);

    QPushButton *segmentDiffButton = new QPushButton("Segment differences");
    segmentDiffButton->setDefault(true); // default button, pressed if enter is pressed
    connect(segmentDiffButton, SIGNAL(clicked()), this, SLOT(segmentDiff()));

    diffDialogLayout->addWidget(dialogVisualizer);
    diffDialogLayout->addLayout(dialogControlsLayout);
    diffDialogLayout->addWidget(segmentDiffButton);
    diffDialog->setLayout(diffDialogLayout);

    diffDialogLayout->deleteLater(); // delete dialog layout when the control returns to the event loop from which deleteLater() was called (after exec i guess)
    diffDialog->resize(800,600);
    diffDialog->exec();
    componentCallbackConnection.disconnect(); // disconnect the callback function from the viewer
    delete dialogViewer; // finita l'esecuzione, deallocare il viewer (deallocare altra eventuale memoria non indirizzata nel QObject tree).
}