Rename infinitiViewer to DICOMImageViewer.

src/src/IO/Export/dicomexporter.cpp

@@ -53,7 +53,7 @@ void DicomExporter::initVTK()
 	m_glrenWinExport = vtkSmartPointer<vtkRenderWindow>::New();
 	m_glrenWinExport->OffScreenRenderingOn();
 
-	m_imageViewerExport = vtkSmartPointer<infinitiViewer>::New();
+	m_imageViewerExport = vtkSmartPointer<DICOMImageViewer>::New();
 	m_imageViewerExport->SetRenderWindow(m_glrenWinExport);
 	m_imageViewerExport->SetupInteractor(m_glrenWinExport->GetInteractor());
 }

src/src/IO/Export/dicomexporter.h

@@ -23,7 +23,7 @@
 #include <qdir.h>
 #include <sstream>
 
-#include "Rendering/Viewer/infinitiViewer.h"
+#include "Rendering/Viewer/DICOMImageViewer.h"
 //#include "itkMetaDataObject.h"
 //#include "itkMetaDataDictionary.h"
 
@@ -117,7 +117,7 @@ private:
 //	ConnectorTypeExport::Pointer m_itkConnectorExport;
 //	InputNamesGeneratorTypeExport::Pointer m_inputNamesExport;
 	vtkSmartPointer<vtkRenderWindow> m_glrenWinExport;
-	vtkSmartPointer<infinitiViewer> m_imageViewerExport;
+	vtkSmartPointer<DICOMImageViewer> m_imageViewerExport;
 };
 
 #endif // DICOMEXPORTER_H

src/src/Rendering/Viewer/DICOMImageViewer.cxx

@@ -1,4 +1,4 @@
-#include "infinitiViewer.h"
+#include "DICOMImageViewer.h"
 
 #include <vector>
 #include <vtkCamera.h>
@@ -28,16 +28,16 @@
 #include "Interaction/ActorDraggableInteractorStyle.h"
 
 
-vtkStandardNewMacro(infinitiViewer);
+vtkStandardNewMacro(DICOMImageViewer);
 
 //-----------------------------------------------------------------------------
-infinitiViewer::infinitiViewer()
+DICOMImageViewer::DICOMImageViewer()
         : vtkObject(),
           RenderWindow(nullptr), Renderer(nullptr), ImageStack(vtkImageStack::New()),
           ImageActor(vtkImageSlice::New()), ImageMapper(vtkImageSliceMapper::New()), FusionActor(nullptr),
           FusionMapper(nullptr), Interactor(nullptr), InteractorStyle(nullptr), OpacityActor(nullptr),
           cornerAnnotation(vtkCornerAnnotation::New()), bar(nullptr),
-          SliceOrientation(infinitiViewer::SLICE_ORIENTATION_XY), FirstRender(1), Slice(0), loadedMeasureSlice(0),
+          SliceOrientation(DICOMImageViewer::SLICE_ORIENTATION_XY), FirstRender(1), Slice(0), loadedMeasureSlice(0),
           currentPresetIndex(1), Fusion(false), firstFusion(true), FusionOpacity(0.5), list(nullptr),
           measureStore(MeasureStore::Instance()),
           rulerActive(false){
@@ -58,22 +58,22 @@ infinitiViewer::infinitiViewer()
     cornerAnnotation->SetMaximumFontSize(FontSizeHelper::font_size);
 
     vtkRenderWindow *renwin = vtkRenderWindow::New();
-    infinitiViewer::SetRenderWindow(renwin);
+    DICOMImageViewer::SetRenderWindow(renwin);
     renwin->Delete();
 
 
     vtkRenderer *ren = vtkRenderer::New();
-    infinitiViewer::SetRenderer(ren);
+    DICOMImageViewer::SetRenderer(ren);
     ren->Delete();
 
-    infinitiViewer::InstallPipeline();
+    DICOMImageViewer::InstallPipeline();
 
     uintptr_t handler = reinterpret_cast<uintptr_t>(this);
     sprintf(SOP_UID, "%llu", handler);
 }
 
 //-----------------------------------------------------------------------------
-infinitiViewer::~infinitiViewer() {
+DICOMImageViewer::~DICOMImageViewer() {
     if (this->ImageMapper) {
         this->ImageMapper->SetInputData(nullptr);
         this->ImageMapper->Delete();
@@ -122,7 +122,7 @@ infinitiViewer::~infinitiViewer() {
     //delete measureStore;
 }
 
-void infinitiViewer::SetupImageViewer() {
+void DICOMImageViewer::SetupImageViewer() {
     this->SetColorLevel(m_cornerInfo.win_level);
     this->SetColorWindow(m_cornerInfo.win_width);
     //this->GetRenderer()->ResetCamera();
@@ -133,19 +133,19 @@ void infinitiViewer::SetupImageViewer() {
 }
 
 // Render Pipe line------------------------------------------------------------
-vtkImageData *infinitiViewer::GetInput() {
+vtkImageData *DICOMImageViewer::GetInput() {
     return this->ImageMapper->GetInput();
 }
 
-vtkInformation *infinitiViewer::GetInputInformation() {
+vtkInformation *DICOMImageViewer::GetInputInformation() {
     return this->ImageMapper->GetInputInformation();
 }
 
-vtkAlgorithm *infinitiViewer::GetInputAlgorithm() {
+vtkAlgorithm *DICOMImageViewer::GetInputAlgorithm() {
     return this->ImageMapper->GetInputAlgorithm();
 }
 
-void infinitiViewer::SetupInteractor(vtkRenderWindowInteractor *arg) {
+void DICOMImageViewer::SetupInteractor(vtkRenderWindowInteractor *arg) {
     if (this->Interactor == arg) {
         return;
     }
@@ -169,7 +169,7 @@ void infinitiViewer::SetupInteractor(vtkRenderWindowInteractor *arg) {
     }
 }
 
-void infinitiViewer::SetRenderWindow(vtkRenderWindow *arg) {
+void DICOMImageViewer::SetRenderWindow(vtkRenderWindow *arg) {
     if (this->RenderWindow == arg) {
         return;
     }
@@ -186,11 +186,11 @@ void infinitiViewer::SetRenderWindow(vtkRenderWindow *arg) {
         this->RenderWindow->Register(this);
     }
     //add legend to render
-    this->RenderWindow->AddObserver(vtkCommand::EventIds::RenderEvent, this, &infinitiViewer::RenderLegend);
+    this->RenderWindow->AddObserver(vtkCommand::EventIds::RenderEvent, this, &DICOMImageViewer::RenderLegend);
     this->InstallPipeline();
 }
 
-void infinitiViewer::SetRenderer(vtkRenderer *arg) {
+void DICOMImageViewer::SetRenderer(vtkRenderer *arg) {
     if (this->Renderer == arg) {
         return;
     }
@@ -211,7 +211,7 @@ void infinitiViewer::SetRenderer(vtkRenderer *arg) {
     this->UpdateOrientation();
 }
 
-void infinitiViewer::SetInputData(vtkImageData *in) {
+void DICOMImageViewer::SetInputData(vtkImageData *in) {
     if (!in) return;
 #ifdef _DEBUG
     printf("fusion imageDataOrigin:%f,%f,%f", in->GetOrigin()[0], in->GetOrigin()[1], in->GetOrigin()[2]);
@@ -226,20 +226,20 @@ void infinitiViewer::SetInputData(vtkImageData *in) {
     defaultProjection[2][2] = zVec>0.0?1.0:-1.0;
 }
 
-void infinitiViewer::SetInputConnection(vtkAlgorithmOutput *input) {
+void DICOMImageViewer::SetInputConnection(vtkAlgorithmOutput *input) {
     this->ImageMapper->SetInputConnection(input);
     this->RemoveFusionData();
 }
 
-vtkTypeBool infinitiViewer::GetOffScreenRendering() {
+vtkTypeBool DICOMImageViewer::GetOffScreenRendering() {
     return this->RenderWindow->GetOffScreenRendering();
 }
 
-void infinitiViewer::SetOffScreenRendering(vtkTypeBool i) {
+void DICOMImageViewer::SetOffScreenRendering(vtkTypeBool i) {
     this->RenderWindow->SetOffScreenRendering(i);
 }
 
-void infinitiViewer::InstallPipeline() {
+void DICOMImageViewer::InstallPipeline() {
     if (this->RenderWindow && this->Renderer) {
         this->RenderWindow->AddRenderer(this->Renderer);
     }
@@ -252,20 +252,20 @@ void infinitiViewer::InstallPipeline() {
             this->InteractorStyle->SetCornerAnnotation(cornerAnnotation);
 
             this->InteractorStyle->AddObserver(ActorDraggableInteractorStyle::DraggableStyleEvents::EndMeasureEvent,
-                                               this, &infinitiViewer::AddMeasures);
+                                               this, &DICOMImageViewer::AddMeasures);
             this->InteractorStyle->AddObserver(ActorDraggableInteractorStyle::DraggableStyleEvents::DeleteMeasureEvent,
-                                               this, &infinitiViewer::RemoveMeasures);
+                                               this, &DICOMImageViewer::RemoveMeasures);
             this->InteractorStyle->AddObserver(ActorDraggableInteractorStyle::DraggableStyleEvents::SliceEvent, this,
-                                               &infinitiViewer::ChangeSlice);
+                                               &DICOMImageViewer::ChangeSlice);
 
             //for convert vtkEvent to Qt signal
             this->InteractorStyle->AddObserver(ActorDraggableInteractorStyle::DraggableStyleEvents::SlicedEvent, this,
-                                               &infinitiViewer::raiseEvent);
+                                               &DICOMImageViewer::raiseEvent);
             this->InteractorStyle->AddObserver(ActorDraggableInteractorStyle::DraggableStyleEvents::EndDollyEvent, this,
-                                               &infinitiViewer::raiseEvent);
+                                               &DICOMImageViewer::raiseEvent);
             this->InteractorStyle->AddObserver(vtkCommand::EventIds::EndWindowLevelEvent, this,
-                                               &infinitiViewer::raiseEvent);
-            this->InteractorStyle->AddObserver(vtkCommand::EventIds::EndPanEvent, this, &infinitiViewer::raiseEvent);
+                                               &DICOMImageViewer::raiseEvent);
+            this->InteractorStyle->AddObserver(vtkCommand::EventIds::EndPanEvent, this, &DICOMImageViewer::raiseEvent);
         }
 
         this->Interactor->SetInteractorStyle(this->InteractorStyle);
@@ -287,7 +287,7 @@ void infinitiViewer::InstallPipeline() {
     loadedMeasureSlice = -1;
 }
 
-void infinitiViewer::UnInstallPipeline() {
+void DICOMImageViewer::UnInstallPipeline() {
     if (this->ImageActor && this->ImageMapper) {
         // this->ImageActor->SetMapper(nullptr);
     }
@@ -308,7 +308,7 @@ void infinitiViewer::UnInstallPipeline() {
     }
 }
 
-void infinitiViewer::Render() {
+void DICOMImageViewer::Render() {
     if (this->FirstRender) {
         //   // Initialize the size if not set yet
 
@@ -320,18 +320,18 @@ void infinitiViewer::Render() {
             int xs = 0, ys = 0;
 
             switch (this->SliceOrientation) {
-                case infinitiViewer::SLICE_ORIENTATION_XY:
+                case DICOMImageViewer::SLICE_ORIENTATION_XY:
                 default:
                     xs = w_ext[1] - w_ext[0] + 1;
                     ys = w_ext[3] - w_ext[2] + 1;
                     break;
 
-                case infinitiViewer::SLICE_ORIENTATION_XZ:
+                case DICOMImageViewer::SLICE_ORIENTATION_XZ:
                     xs = w_ext[1] - w_ext[0] + 1;
                     ys = w_ext[5] - w_ext[4] + 1;
                     break;
 
-                case infinitiViewer::SLICE_ORIENTATION_YZ:
+                case DICOMImageViewer::SLICE_ORIENTATION_YZ:
                     xs = w_ext[3] - w_ext[2] + 1;
                     ys = w_ext[5] - w_ext[4] + 1;
                     break;
@@ -381,7 +381,7 @@ void infinitiViewer::Render() {
 }
 
 // slice about-----------------------------------------------------------------
-void infinitiViewer::GetSliceRange(int &min, int &max) {
+void DICOMImageViewer::GetSliceRange(int &min, int &max) {
     vtkAlgorithm *input = this->GetInputAlgorithm();
     if (input) {
         input->UpdateInformation();
@@ -392,7 +392,7 @@ void infinitiViewer::GetSliceRange(int &min, int &max) {
     }
 }
 
-int *infinitiViewer::GetSliceRange() {
+int *DICOMImageViewer::GetSliceRange() {
     vtkAlgorithm *input = this->GetInputAlgorithm();
     if (input) {
         input->UpdateInformation();
@@ -402,7 +402,7 @@ int *infinitiViewer::GetSliceRange() {
     return nullptr;
 }
 
-int infinitiViewer::GetSliceMin() {
+int DICOMImageViewer::GetSliceMin() {
     int *range = this->GetSliceRange();
     if (range) {
         return range[0];
@@ -410,7 +410,7 @@ int infinitiViewer::GetSliceMin() {
     return 0;
 }
 
-int infinitiViewer::GetSliceMax() {
+int DICOMImageViewer::GetSliceMax() {
     int *range = this->GetSliceRange();
     if (range) {
         return range[1];
@@ -418,11 +418,11 @@ int infinitiViewer::GetSliceMax() {
     return 0;
 }
 
-int infinitiViewer::GetSlice() {
+int DICOMImageViewer::GetSlice() {
     return this->ImageMapper->GetSliceNumber();
 }
 
-void infinitiViewer::SetSlice(int slice) {
+void DICOMImageViewer::SetSlice(int slice) {
     int *range = this->GetSliceRange();
     if (range) {
         if (slice < range[0]) {
@@ -470,7 +470,7 @@ void infinitiViewer::SetSlice(int slice) {
     }
 }
 
-void infinitiViewer::ChangeSlice(vtkObject *, unsigned long eventid, void *calldata) {
+void DICOMImageViewer::ChangeSlice(vtkObject *, unsigned long eventid, void *calldata) {
     int lastSlice = GetSlice();
     int *p = (int *) calldata;
     int newSlice = lastSlice + (*p);
@@ -478,7 +478,7 @@ void infinitiViewer::ChangeSlice(vtkObject *, unsigned long eventid, void *calld
     SetSlice(newSlice);
 }
 
-void infinitiViewer::GetSlicePoint(double *point) {
+void DICOMImageViewer::GetSlicePoint(double *point) {
     double focusPoint[4] = {point[0], point[1], point[2], 1.0};
     Renderer->GetActiveCamera()->GetFocalPoint(focusPoint);
     ModelToWorldMatrix->MultiplyPoint(focusPoint, focusPoint);
@@ -487,7 +487,7 @@ void infinitiViewer::GetSlicePoint(double *point) {
     point[2] = focusPoint[2];
 }
 
-void infinitiViewer::applySliceOffset(double offset, double direction){
+void DICOMImageViewer::applySliceOffset(double offset, double direction){
     double projV = Renderer->GetActiveCamera()->GetDirectionOfProjection()[SliceOrientation];
     double defaultProjV = defaultProjection[SliceOrientation][SliceOrientation];
     // 根据投影向量判断当前镜头方向, innerDirection>0 与默认同向, innerDirection<0 与默认反向
@@ -502,7 +502,7 @@ void infinitiViewer::applySliceOffset(double offset, double direction){
     UpdateTopLeftCornerInfo();
 }
 
-vtkPoints* infinitiViewer::GetSliceBoundPoints() {
+vtkPoints* DICOMImageViewer::GetSliceBoundPoints() {
     double bounds[6] = {.0, .0, .0, .0, .0, .0};
     ImageMapper->GetBounds(bounds);
     vtkCamera *camera = this->Renderer->GetActiveCamera();
@@ -541,7 +541,7 @@ vtkPoints* infinitiViewer::GetSliceBoundPoints() {
     return worldPts;
 }
 
-void infinitiViewer::updateReferenceLine(vtkPoints* worldPts){
+void DICOMImageViewer::updateReferenceLine(vtkPoints* worldPts){
     //model to world
     for (vtkIdType i = 0; i < worldPts->GetNumberOfPoints(); ++i) {
         double temp[4] = {.0, .0, .0, 1.};
@@ -552,13 +552,13 @@ void infinitiViewer::updateReferenceLine(vtkPoints* worldPts){
     Render();
 }
 
-void infinitiViewer::modifiedReferenceLine(){
+void DICOMImageViewer::modifiedReferenceLine(){
     //model to world
     referenceLine->Modified();
     Render();
 }
 
-void infinitiViewer::SyncSlicePoint(double *point) {
+void DICOMImageViewer::SyncSlicePoint(double *point) {
     double focusPoint[4] = {point[0], point[1], point[2], 1.0};
     WorldToModelMatrix->MultiplyPoint(focusPoint, focusPoint);
     double f[3] = {.0, .0, .0};
@@ -572,20 +572,20 @@ void infinitiViewer::SyncSlicePoint(double *point) {
 }
 
 // zoom------------------------------------------------------------------------
-void infinitiViewer::SetZoomScale(double scale) {
+void DICOMImageViewer::SetZoomScale(double scale) {
     if (Renderer) {
         Renderer->GetActiveCamera()->SetParallelScale(scale);
     }
 }
 
-double infinitiViewer::GetZoomScale(){
+double DICOMImageViewer::GetZoomScale(){
     if (Renderer) {
         return Renderer->GetActiveCamera()->GetParallelScale();
     }
     return 0.0;
 }
 
-void infinitiViewer::ResetZoomScaleToFitWindowSize() {
+void DICOMImageViewer::ResetZoomScaleToFitWindowSize() {
     vtkImageData *inputData = nullptr;
     if (Renderer && (inputData = GetInput())) {
         double proj[4] = {0, 0, 0, 1};
@@ -616,7 +616,7 @@ void infinitiViewer::ResetZoomScaleToFitWindowSize() {
 }
 
 // pan------------------------------------------------------------------------- 
-void infinitiViewer::applyPanOffset(const double *point) {
+void DICOMImageViewer::applyPanOffset(const double *point) {
     double fp[3] = {0.0, 0.0, 0.0};
     Renderer->GetActiveCamera()->GetPosition(fp);
     fp[0] = fp[0] + point[0];
@@ -631,7 +631,7 @@ void infinitiViewer::applyPanOffset(const double *point) {
 
 }
 
-void infinitiViewer::shiftCamera(const double *point) {
+void DICOMImageViewer::shiftCamera(const double *point) {
     double fp[3] = {0.0, 0.0, 0.0};
     double newP[3] = {point[0], point[1], point[2]};
     Renderer->GetActiveCamera()->GetPosition(fp);
@@ -644,23 +644,23 @@ void infinitiViewer::shiftCamera(const double *point) {
 }
 
 // window----------------------------------------------------------------------
-double infinitiViewer::GetColorWindow() {
+double DICOMImageViewer::GetColorWindow() {
     return this->ImageActor->GetProperty()->GetColorWindow();
 }
 
-double infinitiViewer::GetColorLevel() {
+double DICOMImageViewer::GetColorLevel() {
     return this->ImageActor->GetProperty()->GetColorLevel();
 }
 
-void infinitiViewer::SetColorWindow(double s) {
+void DICOMImageViewer::SetColorWindow(double s) {
     this->ImageActor->GetProperty()->SetColorWindow(s);
 }
 
-void infinitiViewer::SetColorLevel(double s) {
+void DICOMImageViewer::SetColorLevel(double s) {
     this->ImageActor->GetProperty()->SetColorLevel(s);
 }
 
-void infinitiViewer::SetNegativeMode(bool negative) {
+void DICOMImageViewer::SetNegativeMode(bool negative) {
     if (negative) {
         double window = this->ImageActor->GetProperty()->GetColorWindow();
         double level = this->ImageActor->GetProperty()->GetColorLevel();
@@ -680,7 +680,7 @@ void infinitiViewer::SetNegativeMode(bool negative) {
     }
 }
 
-void infinitiViewer::SetLookupTable(vtkLookupTable *lut) {
+void DICOMImageViewer::SetLookupTable(vtkLookupTable *lut) {
     this->ImageActor->GetProperty()->SetLookupTable(lut);
 }
 
@@ -691,7 +691,7 @@ bool simpleFusionableCheck(vtkImageData *a, vtkImageData *b) {
     return (origin1[0] == origin2[0]) && (origin1[1] == origin2[1]) && (origin1[2] == origin2[2]);
 }
 
-void infinitiViewer::SetFusionInputData(vtkImageData *data, vtkMatrix4x4* matrix) {
+void DICOMImageViewer::SetFusionInputData(vtkImageData *data, vtkMatrix4x4* matrix) {
     if (!this->GetInput()) return;
     if (!simpleFusionableCheck(data, this->GetInput())) return;
     if (!this->FusionMapper) {
@@ -770,28 +770,28 @@ void infinitiViewer::SetFusionInputData(vtkImageData *data, vtkMatrix4x4* matrix
 
 }
 
-void infinitiViewer::SetFusionColorLeveL(double level) {
+void DICOMImageViewer::SetFusionColorLeveL(double level) {
     if (FusionActor) {
         FusionActor->GetProperty()->SetColorLevel(level);
         PrepareFusionColorTable(FusionActor->GetProperty()->GetLookupTable());
     }
 }
 
-void infinitiViewer::SetFusionColorWindow(double window) {
+void DICOMImageViewer::SetFusionColorWindow(double window) {
     if (FusionActor) {
         FusionActor->GetProperty()->SetColorWindow(window);
         PrepareFusionColorTable(FusionActor->GetProperty()->GetLookupTable());
     }
 }
 
-void infinitiViewer::SetScalarBarTitle(double FusionOpa) {
+void DICOMImageViewer::SetScalarBarTitle(double FusionOpa) {
     int opa = int(FusionOpa * 100);
     std::string str_opa = std::to_string(opa);
     str_opa.append("%");
     OpacityActor->SetInput(str_opa.c_str());
 }
 
-void infinitiViewer::IncreFusionOpacity(double percent) {
+void DICOMImageViewer::IncreFusionOpacity(double percent) {
     if (FusionActor) {
         FusionOpacity += percent;
         FusionOpacity = FusionOpacity > 1.0 ? 1.0 : FusionOpacity;
@@ -802,7 +802,7 @@ void infinitiViewer::IncreFusionOpacity(double percent) {
     }
 }
 
-void infinitiViewer::SetFusionOpacity(double opacity) {
+void DICOMImageViewer::SetFusionOpacity(double opacity) {
     if (FusionActor) {
         opacity = opacity > 1.0 ? 1.0 : opacity;
         opacity = opacity < 0.0 ? 0.0 : opacity;
@@ -842,7 +842,7 @@ void prepareTransferFunction(vtkDiscretizableColorTransferFunction *table, vtkIm
     table->EnableOpacityMappingOn();
 }
 
-void infinitiViewer::SetFusionColorTable(vtkScalarsToColors *table) {
+void DICOMImageViewer::SetFusionColorTable(vtkScalarsToColors *table) {
     if (!FusionActor) return;
     PrepareFusionColorTable(table, true);
     FusionActor->GetProperty()->SetLookupTable(table);
@@ -851,7 +851,7 @@ void infinitiViewer::SetFusionColorTable(vtkScalarsToColors *table) {
 #endif
 }
 
-void infinitiViewer::SetFusionColorPreset(const char *preset) {
+void DICOMImageViewer::SetFusionColorPreset(const char *preset) {
     auto values = ColorMapReader::DefaultPresets()->GetPresetValues(preset);
     auto PresetType = ColorMapReader::DefaultPresets()->GetPresetType(preset);
 
@@ -888,7 +888,7 @@ void infinitiViewer::SetFusionColorPreset(const char *preset) {
     }
 }
 
-void infinitiViewer::PrepareFusionColorTable(vtkScalarsToColors *table, bool reset) {
+void DICOMImageViewer::PrepareFusionColorTable(vtkScalarsToColors *table, bool reset) {
     const auto prop = FusionActor->GetProperty();
     table->SetAlpha(FusionOpacity);
     if (table->IsA("vtkLookupTable")) {
@@ -913,7 +913,7 @@ void infinitiViewer::PrepareFusionColorTable(vtkScalarsToColors *table, bool res
     table->Build();
 }
 
-void infinitiViewer::RemoveFusionActor() {
+void DICOMImageViewer::RemoveFusionActor() {
     this->Renderer->RemoveActor(bar);
     bar->Delete();
     bar = nullptr;
@@ -922,7 +922,7 @@ void infinitiViewer::RemoveFusionActor() {
     OpacityActor = nullptr;
 }
 
-void infinitiViewer::RemoveFusionData() {
+void DICOMImageViewer::RemoveFusionData() {
     if (!FusionMapper) return;
     if (ImageStack->HasImage(FusionActor)) {
         ImageStack->RemoveImage(FusionActor);
@@ -938,7 +938,7 @@ void infinitiViewer::RemoveFusionData() {
     //this->Render();
 }
 
-void infinitiViewer::SwitchToNextPreset() {
+void DICOMImageViewer::SwitchToNextPreset() {
     if (ColorMapReader::DefaultPresets()) {
 
         //const char* preset3 = ColorMapReader::DefaultPresets()->GetPresetNames().at(currentPresetIndex).data();
@@ -952,40 +952,40 @@ void infinitiViewer::SwitchToNextPreset() {
 }
 
 // window about----------------------------------------------------------------
-void infinitiViewer::SetPosition(int x, int y) {
+void DICOMImageViewer::SetPosition(int x, int y) {
     this->RenderWindow->SetPosition(x, y);
 }
 
-int *infinitiViewer::GetPosition() {
+int *DICOMImageViewer::GetPosition() {
     return this->RenderWindow->GetPosition();
 }
 
-void infinitiViewer::SetDisplayId(void *a) {
+void DICOMImageViewer::SetDisplayId(void *a) {
     this->RenderWindow->SetDisplayId(a);
 }
 
-void infinitiViewer::SetWindowId(void *a) {
+void DICOMImageViewer::SetWindowId(void *a) {
     this->RenderWindow->SetWindowId(a);
 }
 
-const char *infinitiViewer::GetWindowName() {
+const char *DICOMImageViewer::GetWindowName() {
     return this->RenderWindow->GetWindowName();
 }
 
-void infinitiViewer::SetParentId(void *a) {
+void DICOMImageViewer::SetParentId(void *a) {
     this->RenderWindow->SetParentId(a);
 }
 
 // measure--------------------------------------------------------------------
-void infinitiViewer::ActiveMeasure(Measure *m) {
+void DICOMImageViewer::ActiveMeasure(Measure *m) {
     this->InteractorStyle->ActiveMeasure(m);
 }
 
-void infinitiViewer::UnActiveMeasure() {
+void DICOMImageViewer::UnActiveMeasure() {
     this->InteractorStyle->UnActiveMeasure();
 }
 
-void infinitiViewer::LoadMeasures(bool forceReload) {
+void DICOMImageViewer::LoadMeasures(bool forceReload) {
     if (!forceReload && this->loadedMeasureSlice == this->ImageMapper->GetSliceNumber()) return;
 
     this->loadedMeasureSlice = this->ImageMapper->GetSliceNumber();
@@ -993,7 +993,7 @@ void infinitiViewer::LoadMeasures(bool forceReload) {
     ReloadCurrentSliceMeasure();
 }
 
-void infinitiViewer::ReloadCurrentSliceMeasure() {
+void DICOMImageViewer::ReloadCurrentSliceMeasure() {
     list = measureStore->GetMeasures(SOP_UID, this->SliceOrientation, ImageMapper->GetSliceNumber());
 
     if (list) {
@@ -1005,7 +1005,7 @@ void infinitiViewer::ReloadCurrentSliceMeasure() {
     }
 }
 
-void infinitiViewer::ClearCurrentSliceMeasure() const {
+void DICOMImageViewer::ClearCurrentSliceMeasure() const {
     if (list) {
         for (int i = 0; i < list->length(); i++) {
             auto item = list->value(i);
@@ -1015,7 +1015,7 @@ void infinitiViewer::ClearCurrentSliceMeasure() const {
     }
 }
 
-void infinitiViewer::AddMeasures(vtkObject *, unsigned long eventid, void *calldata) {
+void DICOMImageViewer::AddMeasures(vtkObject *, unsigned long eventid, void *calldata) {
     auto m = static_cast<Measure *>(calldata);
     if (m->Valid()) {
         measureStore->Store(SOP_UID, this->SliceOrientation, this->ImageMapper->GetSliceNumber(), m);
@@ -1024,7 +1024,7 @@ void infinitiViewer::AddMeasures(vtkObject *, unsigned long eventid, void *calld
     this->Render();
 }
 
-void infinitiViewer::RemoveMeasures(vtkObject *, unsigned long eventid, void *calldata) {
+void DICOMImageViewer::RemoveMeasures(vtkObject *, unsigned long eventid, void *calldata) {
     auto p = static_cast<vtkProp *>(calldata);
     auto da = DraggableActor::SafeDownCast(p);
     auto m = dynamic_cast<Measure *>(da);
@@ -1035,13 +1035,13 @@ void infinitiViewer::RemoveMeasures(vtkObject *, unsigned long eventid, void *ca
     this->Render();
 }
 
-void infinitiViewer::DeleteSelectedMeasure() {
+void DICOMImageViewer::DeleteSelectedMeasure() {
     if (this->InteractorStyle->GetSelectedProp()) {
         RemoveMeasures(nullptr, 0, this->InteractorStyle->GetSelectedProp());
     }
 }
 
-void infinitiViewer::DeleteCurrentSliceMeasure() {
+void DICOMImageViewer::DeleteCurrentSliceMeasure() {
     this->InteractorStyle->ClearSelectedProp();
     ClearCurrentSliceMeasure();
     measureStore->RemoveAllInSlice(SOP_UID, this->SliceOrientation, this->ImageMapper->GetSliceNumber());
@@ -1049,7 +1049,7 @@ void infinitiViewer::DeleteCurrentSliceMeasure() {
     this->Render();
 }
 
-void infinitiViewer::DeleteCurrentSeriesMeasure() {
+void DICOMImageViewer::DeleteCurrentSeriesMeasure() {
     this->InteractorStyle->ClearSelectedProp();
     ClearCurrentSliceMeasure();
     measureStore->RemoveAllInSeries(SOP_UID);
@@ -1075,7 +1075,7 @@ public:
 
 };
 
-void infinitiViewer::InitCornerInfo(ExtendMedicalImageProperties *pSeries) {
+void DICOMImageViewer::InitCornerInfo(ExtendMedicalImageProperties *pSeries) {
     // mono and has preset
     if (pSeries->GetNumberOfWindowLevelPresets() > 0 && pSeries->GetSamplePerPixel() == 1) {
         double *wwwl = pSeries->GetNthWindowLevelPreset(0);
@@ -1116,19 +1116,19 @@ void infinitiViewer::InitCornerInfo(ExtendMedicalImageProperties *pSeries) {
     m_cornerInfo.ConstAnno[TOP_RIGHT_PRIVACY].append("\n");
 }
 
-void infinitiViewer::SetCoordsTransformMatrix(ExtendMedicalImageProperties *pSeries) const {
+void DICOMImageViewer::SetCoordsTransformMatrix(ExtendMedicalImageProperties *pSeries) const {
     OrientationMatrix->DeepCopy(pSeries->GetOrientationMatrix());
     WorldToModelMatrix->DeepCopy(pSeries->GetWorldToModelMatrix());
     ModelToWorldMatrix->DeepCopy(pSeries->GetModelToWorldMatrix());
 }
 
-void infinitiViewer::InitTopLeftCornerInfo(const std::string &lbl_ser_num, const std::string &ser_num) {
+void DICOMImageViewer::InitTopLeftCornerInfo(const std::string &lbl_ser_num, const std::string &ser_num) {
     m_cornerInfo.ConstAnno[TOP_LEFT].append(lbl_ser_num);
     m_cornerInfo.ConstAnno[TOP_LEFT].append(" ");
     m_cornerInfo.ConstAnno[TOP_LEFT].append(ser_num);
 }
 
-void infinitiViewer::UpdateCornerInfo(int index) {
+void DICOMImageViewer::UpdateCornerInfo(int index) {
     if (AnnoHelper::GetVisibility()) {
 
         if (index == TOP_LEFT) {
@@ -1166,7 +1166,7 @@ void infinitiViewer::UpdateCornerInfo(int index) {
     this->Render();
 }
 
-void infinitiViewer::UpdateCornerInfoAll() {
+void DICOMImageViewer::UpdateCornerInfoAll() {
     if (AnnoHelper::GetVisibility()) {
         UpdateCornerInfo(TOP_LEFT);
         UpdateCornerInfo(BOTTOM_RIGHT);
@@ -1183,7 +1183,7 @@ void infinitiViewer::UpdateCornerInfoAll() {
     }
 }
 
-void infinitiViewer::UpdateTopLeftCornerInfo() {
+void DICOMImageViewer::UpdateTopLeftCornerInfo() {
     if (AnnoHelper::GetVisibility()) {
         int maxSlice = this->GetSliceMax();
         int currentSlice = this->GetSlice();
@@ -1196,9 +1196,9 @@ void infinitiViewer::UpdateTopLeftCornerInfo() {
 }
 
 // SliceOrientation------------------------------------------------------------
-void infinitiViewer::SetSliceOrientation(int orientation) {
-    if (orientation < infinitiViewer::SLICE_ORIENTATION_YZ ||
-        orientation > infinitiViewer::SLICE_ORIENTATION_XY) {
+void DICOMImageViewer::SetSliceOrientation(int orientation) {
+    if (orientation < DICOMImageViewer::SLICE_ORIENTATION_YZ ||
+        orientation > DICOMImageViewer::SLICE_ORIENTATION_XY) {
         vtkErrorMacro("Error - invalid slice orientation " << orientation);
         return;
     }
@@ -1231,7 +1231,7 @@ void infinitiViewer::SetSliceOrientation(int orientation) {
 }
 
 //TODO：暂时只有正交数据！！！否则强制转型会有一些问题
-int infinitiViewer::GetWorldSliceOrientation() {
+int DICOMImageViewer::GetWorldSliceOrientation() {
     double orientations[4] = {.0, .0, .0, 1.0};
     orientations[SliceOrientation] = 1.0;
     OrientationMatrix->MultiplyPoint(orientations, orientations);
@@ -1239,13 +1239,13 @@ int infinitiViewer::GetWorldSliceOrientation() {
 }
 
 // Orientation (with corner text)----------------------------------------------
-void infinitiViewer::UpdateOrientation() {
+void DICOMImageViewer::UpdateOrientation() {
     // Set the camera position
 
     vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : nullptr;
     if (cam) {
         switch (SliceOrientation) {
-            case infinitiViewer::SLICE_ORIENTATION_XY: {
+            case DICOMImageViewer::SLICE_ORIENTATION_XY: {
                 cam->SetFocalPoint(0, 0, 0);
                 cam->SetPosition(0, 0, -1);
                 cam->SetViewUp(0, -1, 0);
@@ -1253,7 +1253,7 @@ void infinitiViewer::UpdateOrientation() {
             }
             //Z轴负数间隔，则Z轴的slice为反方向堆叠
             //初始的朝向和ViewUp都需要调整
-            case infinitiViewer::SLICE_ORIENTATION_XZ: {
+            case DICOMImageViewer::SLICE_ORIENTATION_XZ: {
                 double zVec = GetInput()->GetSpacing()[2];
                 double upVal = (zVec > 0.0 ? 1.0 : -1.0);
                 cam->SetFocalPoint(0, 0, 0);
@@ -1261,7 +1261,7 @@ void infinitiViewer::UpdateOrientation() {
                 cam->SetViewUp(0, 0, -1.0 * upVal);
                 break;
             }
-            case infinitiViewer::SLICE_ORIENTATION_YZ: {
+            case DICOMImageViewer::SLICE_ORIENTATION_YZ: {
                 double zVec = GetInput()->GetSpacing()[2];
                 double upVal = (zVec > 0.0 ? 1.0 : -1.0);
                 cam->SetFocalPoint(0, 0, 0);
@@ -1290,7 +1290,7 @@ int getOppositeOrientation(int f) {
     return f + 1 - inner_idx * 2;
 }
 
-void infinitiViewer::UpdateOrientationInfo() {
+void DICOMImageViewer::UpdateOrientationInfo() {
     static const char *dds[6] = {"R", "L", "A", "P", "F", "H"};
     double proj[4] = {0, 0, 0, 1};
     Renderer->GetActiveCamera()->GetDirectionOfProjection(proj);
@@ -1317,23 +1317,23 @@ void infinitiViewer::UpdateOrientationInfo() {
 }
 
 // ruler legend----------------------------------------------------------------
-void infinitiViewer::ActiveRuler() {
+void DICOMImageViewer::ActiveRuler() {
     rulerActive = true;
 }
 
-void infinitiViewer::UnActiveRuler() {
+void DICOMImageViewer::UnActiveRuler() {
     rulerActive = false;
 }
 
-void infinitiViewer::ActiveReferenceLine() {
+void DICOMImageViewer::ActiveReferenceLine() {
     referenceLine->SetVisibility(true);
 }
 
-void infinitiViewer::UnActiveReferenceLine() {
+void DICOMImageViewer::UnActiveReferenceLine() {
     referenceLine->SetVisibility(false);
 }
 
-void infinitiViewer::RenderLegend() {
+void DICOMImageViewer::RenderLegend() {
     if (AnnoHelper::GetVisibility()) {
         if (Renderer) {
             if (rulerActive)ruler->RenderOverlay(Renderer);
@@ -1343,16 +1343,16 @@ void infinitiViewer::RenderLegend() {
 }
 
 // size------------------------------------------------------------------------
-void infinitiViewer::SetSize(int width, int height) {
+void DICOMImageViewer::SetSize(int width, int height) {
     this->RenderWindow->SetSize(width, height);
 }
 
-int *infinitiViewer::GetSize() {
+int *DICOMImageViewer::GetSize() {
     return this->RenderWindow->GetSize();
 }
 
 //print self-------------------------------------------------------------------
-void infinitiViewer::PrintSelf(ostream &os, vtkIndent indent) {
+void DICOMImageViewer::PrintSelf(ostream &os, vtkIndent indent) {
     this->Superclass::PrintSelf(os, indent);
 
     os << indent << "RenderWindow:\n";

src/src/Rendering/Viewer/DICOMImageViewer.h

@@ -57,11 +57,11 @@ class vtkCornerAnnotation;
 
 class Measure;
 
-class infinitiViewer : public vtkObject {
+class DICOMImageViewer : public vtkObject {
 public:
-    static infinitiViewer *New();
+    static DICOMImageViewer *New();
 
-    vtkTypeMacro(infinitiViewer, vtkObject);
+    vtkTypeMacro(DICOMImageViewer, vtkObject);
 
     void PrintSelf(ostream &os, vtkIndent indent) override;
 
@@ -120,15 +120,15 @@ public:
     virtual void SetSliceOrientation(int orientation);
 
     virtual void SetSliceOrientationToXY() {
-        this->SetSliceOrientation(infinitiViewer::SLICE_ORIENTATION_XY);
+        this->SetSliceOrientation(DICOMImageViewer::SLICE_ORIENTATION_XY);
     }
 
     virtual void SetSliceOrientationToYZ() {
-        this->SetSliceOrientation(infinitiViewer::SLICE_ORIENTATION_YZ);
+        this->SetSliceOrientation(DICOMImageViewer::SLICE_ORIENTATION_YZ);
     }
 
     virtual void SetSliceOrientationToXZ() {
-        this->SetSliceOrientation(infinitiViewer::SLICE_ORIENTATION_XZ);
+        this->SetSliceOrientation(DICOMImageViewer::SLICE_ORIENTATION_XZ);
     }
 
     int GetWorldSliceOrientation();
@@ -396,9 +396,9 @@ public:
     void SetCoordsTransformMatrix(ExtendMedicalImageProperties *pSeries) const;
 
 protected:
-    infinitiViewer();
+    DICOMImageViewer();
 
-    ~infinitiViewer() override;
+    ~DICOMImageViewer() override;
 
     vtkAlgorithm *GetInputAlgorithm();
 
@@ -421,9 +421,9 @@ protected:
     void RemoveMeasures(vtkObject *, unsigned long eventid, void *calldata);
 
 private:
-    infinitiViewer(const infinitiViewer &) = delete;
+    DICOMImageViewer(const DICOMImageViewer &) = delete;
 
-    void operator=(const infinitiViewer &) = delete;
+    void operator=(const DICOMImageViewer &) = delete;
 
     std::vector<std::vector<double>> fusion_tf_vector;
 

src/src/UI/Widget/ImageView/dicomimageview.cpp

@@ -100,7 +100,7 @@ void DicomImageView::initScrollbar() {
 
 void DicomImageView::initImageViewer() {
     if (!mImageViewer) {
-        mImageViewer = infinitiViewer::New();
+        mImageViewer = DICOMImageViewer::New();
         mImageViewer->SetRenderWindow(mGLRenWin);
         mImageViewer->SetupInteractor(mGLRenWin->GetInteractor());
     }

src/src/UI/Widget/ImageView/dicomimageview.h

@@ -8,7 +8,7 @@
 
 #include "Common/SeriesImageSet.h"
 #include "UI/Widget/Component/ClickableScrollBar.h"
-#include "Rendering/Viewer/infinitiViewer.h"
+#include "Rendering/Viewer/DICOMImageViewer.h"
 
 class vtkCornerAnnotation;
 
@@ -38,7 +38,7 @@ public:
         return mGLWidget;
     }
 
-    infinitiViewer *getImageViewer() {
+    DICOMImageViewer *getImageViewer() {
         return mImageViewer;
     }
 
@@ -323,7 +323,7 @@ private:
 
     vtkSmartPointer<vtkGenericOpenGLRenderWindow> mGLRenWin;
 
-    infinitiViewer *mImageViewer;
+    DICOMImageViewer *mImageViewer;
     SeriesImageSet *mSeries;
     ClickableScrollBar *mScrollBar;
     MyTitleBar *mTitleBar;