Renderer.cxx

#include "Renderer.h"

#include "vtkGPUVolumeRayCastMapper.h"
#include <vtkActor.h>
#include <vtkColorTransferFunction.h>
#include <vtkFixedPointVolumeRayCastMapper.h>
#include <vtkMarchingCubes.h>
#include <vtkMetaImageReader.h>
#include <vtkNamedColors.h>
#include <vtkNew.h>
#include <vtkOpenXRCamera.h>
#include <vtkOpenVRRenderWindow.h>
#include <vtkOpenVRRenderWindowInteractor.h>
#include <vtkOpenVRRenderer.h>
#include <vtkPiecewiseFunction.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkSmartPointer.h>
#include <vtkVolume.h>
#include <vtkVolumeProperty.h>
#include <vtkOutputWindow.h>
#include <vtkGenericOpenGLRenderWindow.h>

#include <vtkActor.h>
#include <vtkConeSource.h>
#include <vtkSphereSource.h>
#include <vtkNamedColors.h>
#include <vtkNew.h>
#include <vtkOpenXRRenderWindow.h>
#include <vtkOpenXRRenderWindowInteractor.h>
#include <vtkOpenXRRenderer.h>
#include <vtkPolyDataMapper.h>
#include <QDebug.h>
#include <vtkOpenXRManager.h>
#include <openxr/openxr.h>
#include <vtkOpenXRInteractorStyle.h>
#include "CaveInteractorStyle.h"
#include <vtkSTLReader.h>
#include <vtkPLYReader.h>
#include <vtkSmartVolumeMapper.h>
#include <thread>
#include <QMessageBox>
#include <vtkOpenXRManager.h>
#include <vtkOpenGLRenderWindow.h>
#include <vtkRendererCollection.h>
#include <vtkObjectFactory.h>

#include <qdebug.h>

Renderer::Renderer()
{
  this->renderer = vtkSmartPointer<vtkRenderer>::New();
  this->renderer->SetBackground(0.96, 0.96, 0.86);

  this->renderWindow = vtkSmartPointer<vtkGenericOpenGLRenderWindow>::New();
  this->renderWindow->AddRenderer(this->renderer);

  this->xrRenderWindow = vtkSmartPointer<vtkOpenXRRenderWindow>::New();
  this->currentDisplayMode = TWOD;
  this->filePath = "";
  this->caveRenderWindowActive = false;
  this->xrRenderWindowActive = false;
  this->xrDone = false;

  //init logger
  logger.SetLogToFile("renderer_log.txt");
  logger.Log("Renderer initialised", CaveLogger::INFO);
}

Renderer::~Renderer()
{
  logger.Log("Renderer destroyed", CaveLogger::INFO);
}

// Sets the stereo render mode for the render window based on the specified RenderMode
void Renderer::SetRenderMode(RenderMode mode)
{
  switch (mode)
  {
    case Standard:
      logger.Log("Switching to Standard mode", CaveLogger::INFO);
      this->renderWindow->SetStereoRender(false);
      break;     
    case RedBlue:
      logger.Log("Switching to RedBlue mode", CaveLogger::INFO);
      this->renderWindow->SetStereoCapableWindow(true);
      this->renderWindow->SetStereoTypeToRedBlue();
      this->renderWindow->SetStereoRender(true);
      break;
    case StereoFake:
      logger.Log("Switching to StereoFake mode", CaveLogger::INFO);
      this->renderWindow->SetStereoCapableWindow(true);
      this->renderWindow->SetStereoTypeToFake();
      this->renderWindow->SetStereoRender(true);
      break;
  }
}

// Sets the display mode to either 2D, HMD, or CAVE and configures rendering accordingly
// Returns bool which is used in GUIManager class to check or uncheck the selected option
bool Renderer::SetDisplayMode(DisplayMode displayMode)
{
  this->currentDisplayMode = displayMode;
  bool selected = false;
  switch (displayMode)
  {
    //case TWOD:
    //  //logger.Log("standard display mode: 2D", CaveLogger::INFO);
    //  currentDisplayMode = TWOD;
    //  break;
    case HMD:
        if (xrRenderWindowActive) {
            logger.Log("Closing XR render window...", CaveLogger::INFO);
            //xrRenderWindowActive = false; 
            CloseXR();
        }
        else {
            logger.Log("Selected display mode: HMD", CaveLogger::INFO);

            // Create a popup dialog asking if HMD is available
            QMessageBox::StandardButton reply;
            reply = QMessageBox::question(nullptr, "HMD Availability",
                "Do you want to start XR mode (HMD connected)?",
                QMessageBox::Yes | QMessageBox::No);

            if (reply == QMessageBox::Yes) {
                logger.Log("User confirmed HMD availability. Starting XR...", CaveLogger::INFO);
                this->currentDisplayMode = HMD;
                selected = true;
                xrRenderWindowActive = true;

                // Start XR in a new thread
                if (!xrThread.joinable()) {  
                    xrDone = false;  
                    xrThread = std::thread(&Renderer::StartXR, this);
                }
            }
            else {
                logger.Log("User denied HMD availability. Unable to switch to HMD mode.", CaveLogger::WARNING);
                this->currentDisplayMode = TWOD;
            }
        }
        break;
      case CAVE:
        if (!this->caveRenderWindowActive)
        {            
            // CAVE is being activated
            logger.Log("Selected display mode: CAVE", CaveLogger::INFO);
            selected = true;
            this->currentDisplayMode = CAVE;
            this->caveRenderWindowActive = true;
            this->StartCAVE();  
            
        }
        else
        {
            // CAVE is being deactivated
            logger.Log("Deactivating CAVE mode", CaveLogger::INFO);
            this->CloseCAVE();
            this->caveRenderWindowActive = false;
            this->currentDisplayMode = TWOD;  
        }
        break;
  }
  return selected;
}

// Loads a file of a specified format (STL, PLY, or MHD) and delegates loading to the appropriate handler function
void Renderer::LoadFile(const std::string& fileName)
{
    this->filePath = fileName; // Store the file path

    logger.Log("File path set: " + fileName, CaveLogger::INFO);

    // Extract the file extension
    std::string extension = fileName.substr(fileName.find_last_of(".") + 1);

    if (extension == "stl")
    {
        logger.Log("Loading STL file...", CaveLogger::INFO);
        LoadSTL(fileName);
    }
    else if (extension == "ply")
    {
        logger.Log("Loading PLY file...", CaveLogger::INFO);
        LoadPLY(fileName);
    }
    else if (extension == "mhd")
    {
        logger.Log("Loading volumetric data (MHD)...", CaveLogger::INFO);
        LoadMHD(fileName);
    }
    else
    {
        logger.Log("Unsupported file format!", CaveLogger::FAULT);
    }
}

// Loads an STL file, creates an actor, and adds it to the renderer
void Renderer::LoadSTL(const std::string& fileName)
{
    vtkNew<vtkSTLReader> reader;
    reader->SetFileName(fileName.c_str());
    reader->Update();

    vtkNew<vtkPolyDataMapper> mapper;
    mapper->SetInputConnection(reader->GetOutputPort());

    vtkNew<vtkActor> actor;
    actor->SetMapper(mapper);

    this->renderer->RemoveAllViewProps();
    this->renderer->AddActor(actor);

    SetCameraForActor(actor);
}

// Loads a PLY file, creates an actor, and adds it to the renderer
void Renderer::LoadPLY(const std::string& fileName)
{
    vtkNew<vtkPLYReader> reader;
    reader->SetFileName(fileName.c_str());
    reader->Update();

    vtkNew<vtkPolyDataMapper> mapper;
    mapper->SetInputConnection(reader->GetOutputPort());

    vtkNew<vtkActor> actor;
    actor->SetMapper(mapper);

    this->renderer->RemoveAllViewProps(); 
    this->renderer->AddActor(actor);

    SetCameraForActor(actor);
    //this->renderer->GetRenderWindow()->Render(); (?)
}

// Instead of using harcoded distance, adjust camera dynamically based on object size
// Configures the camera's position and orientation based on the size and location of the given actor
void Renderer::SetCameraForActor(vtkSmartPointer<vtkActor> actor)
{
    // Compute object's bounding box
    double bounds[6];
    actor->GetBounds(bounds);
    double centerX = (bounds[0] + bounds[1]) / 2.0;
    double centerY = (bounds[2] + bounds[3]) / 2.0;
    double centerZ = (bounds[4] + bounds[5]) / 2.0;

    double diagonalLength = sqrt(
        pow(bounds[1] - bounds[0], 2) +
        pow(bounds[3] - bounds[2], 2) +
        pow(bounds[5] - bounds[4], 2)
    );

    vtkCamera* camera = this->renderer->GetActiveCamera();
    double distance = diagonalLength * 1.5;
    camera->SetPosition(centerX, centerY - distance, centerZ);
    camera->SetFocalPoint(centerX, centerY, centerZ);
    camera->Azimuth(30.0);
    camera->Elevation(30.0);

    this->renderer->ResetCamera();
}

// Loads an MHD volumetric data file and sets up volume rendering
void Renderer::LoadMHD(const std::string& fileName)
{
    vtkNew<vtkMetaImageReader> reader;
    reader->SetFileName(fileName.c_str());
    reader->Update();

    vtkNew<vtkSmartVolumeMapper> volumeMapper;
    volumeMapper->SetInputConnection(reader->GetOutputPort());

    // Enable low resolution mode
    volumeMapper->SetLowResMode(vtkSmartVolumeMapper::LowResModeResample);

    vtkNew<vtkVolume> volume;
    volume->SetMapper(volumeMapper);

    vtkNew<vtkColorTransferFunction> volumeColor;
    volumeColor->AddRGBPoint(0, 0.0, 0.0, 0.0);
    volumeColor->AddRGBPoint(500, 240.0 / 255.0, 184.0 / 255.0, 160.0 / 255.0);
    volumeColor->AddRGBPoint(1000, 240.0 / 255.0, 184.0 / 255.0, 160.0 / 255.0);
    volumeColor->AddRGBPoint(1150, 1.0, 1.0, 240.0 / 255.0);

    vtkNew<vtkPiecewiseFunction> volumeScalarOpacity;
    volumeScalarOpacity->AddPoint(0, 0.00);
    volumeScalarOpacity->AddPoint(500, 0.15);
    volumeScalarOpacity->AddPoint(1000, 0.15);
    volumeScalarOpacity->AddPoint(1150, 0.85);

    vtkNew<vtkPiecewiseFunction> volumeGradientOpacity;
    volumeGradientOpacity->AddPoint(0, 0.0);
    volumeGradientOpacity->AddPoint(90, 0.5);
    volumeGradientOpacity->AddPoint(100, 1.0);

    vtkNew<vtkVolumeProperty> volumeProperty;
    volumeProperty->SetColor(volumeColor);
    volumeProperty->SetScalarOpacity(volumeScalarOpacity);
    volumeProperty->SetGradientOpacity(volumeGradientOpacity);
    volumeProperty->SetInterpolationTypeToLinear();
    volumeProperty->ShadeOn();
    volumeProperty->SetAmbient(0.5);
    volumeProperty->SetDiffuse(0.6);
    volumeProperty->SetSpecular(0.2);

    volume->SetProperty(volumeProperty);

    this->renderer->RemoveAllViewProps();
    this->renderer->AddVolume(volume);

    double* c = volume->GetCenter();
    vtkCamera* camera = renderer->GetActiveCamera();
    camera->SetPosition(c[0], c[1] - 400, c[2]);
    camera->SetFocalPoint(c[0], c[1], c[2]);
    camera->Azimuth(30.0);
    camera->Elevation(30.0);

    this->renderer->GetRenderWindow()->Render();
}

// Launches XR rendering in a loop that processes events until `xrDone` is true.
// HMD Mode in a separate thread
void Renderer::StartXR()
{
    logger.Log("Starting XR...", CaveLogger::INFO);

    vtkNew<vtkOpenXRRenderer> xrRenderer;
    vtkNew<vtkOpenXRRenderWindow> xrRenderWindow;
    xrRenderWindow->Initialize();
    xrRenderWindow->AddRenderer(xrRenderer);

    vtkNew<vtkOpenXRRenderWindowInteractor> xrInteractor;
    vtkNew<CaveInteractorStyle> style;
    xrInteractor->SetInteractorStyle(style);
    style->SetRendererAndWindow(xrRenderer, xrRenderWindow);
    xrInteractor->SetRenderWindow(xrRenderWindow);

    // Load the file directly into the XR renderer based on filePath
    if (!this->filePath.empty())
    {
        logger.Log("Loading file in XR mode: " + this->filePath, CaveLogger::INFO);
        std::string extension = filePath.substr(filePath.find_last_of(".") + 1);

        if (extension == "stl")
        {
            logger.Log("Loading STL file in XR mode...", CaveLogger::INFO);
            vtkNew<vtkSTLReader> reader;
            reader->SetFileName(this->filePath.c_str());
            reader->Update();
            vtkPolyData* polyData = reader->GetOutput();

            vtkNew<vtkPolyDataMapper> mapper;
            mapper->SetInputData(polyData);

            vtkNew<vtkActor> actor;
            actor->SetMapper(mapper);

            vtkNew<vtkProperty> actorProperty;
            actorProperty->SetAmbient(0.3);
            actorProperty->SetDiffuse(0.6);
            actorProperty->SetSpecular(0.5);
            actorProperty->SetSpecularPower(20);
            actor->SetProperty(actorProperty);

            xrRenderer->AddActor(actor);
        }
        else if (extension == "ply")
        {
            logger.Log("Loading PLY file in XR mode...", CaveLogger::INFO);
            vtkNew<vtkPLYReader> reader;
            reader->SetFileName(this->filePath.c_str());
            reader->Update();

            vtkNew<vtkPolyDataMapper> mapper;
            mapper->SetInputConnection(reader->GetOutputPort());

            vtkNew<vtkActor> actor;
            actor->SetMapper(mapper);

            vtkNew<vtkProperty> actorProperty;
            actorProperty->SetAmbient(0.3);
            actorProperty->SetDiffuse(0.6);
            actorProperty->SetSpecular(0.5);
            actorProperty->SetSpecularPower(20);
            actor->SetProperty(actorProperty);

            xrRenderer->AddActor(actor);
        }
        else if (extension == "mhd")
        {
            logger.Log("Loading volumetric data (MHD) in XR mode...", CaveLogger::INFO);
            vtkNew<vtkMetaImageReader> reader;
            reader->SetFileName(this->filePath.c_str());
            reader->Update();

            vtkNew<vtkGPUVolumeRayCastMapper> volumeMapper;
            volumeMapper->SetInputConnection(reader->GetOutputPort());            

            vtkNew<vtkVolume> volume;
            volume->SetMapper(volumeMapper);

            // Set volume properties
            vtkNew<vtkColorTransferFunction> volumeColor;
            volumeColor->AddRGBPoint(0, 0.0, 0.0, 0.0);
            volumeColor->AddRGBPoint(500, 240.0 / 255.0, 184.0 / 255.0, 160.0 / 255.0);
            volumeColor->AddRGBPoint(1000, 240.0 / 255.0, 184.0 / 255.0, 160.0 / 255.0);
            volumeColor->AddRGBPoint(1150, 1.0, 1.0, 240.0 / 255.0);

            vtkNew<vtkPiecewiseFunction> volumeScalarOpacity;
            volumeScalarOpacity->AddPoint(0, 0.00);
            volumeScalarOpacity->AddPoint(500, 0.15);
            volumeScalarOpacity->AddPoint(1000, 0.15);
            volumeScalarOpacity->AddPoint(1150, 0.85);

            vtkNew<vtkPiecewiseFunction> volumeGradientOpacity;
            volumeGradientOpacity->AddPoint(0, 0.0);
            volumeGradientOpacity->AddPoint(90, 0.5);
            volumeGradientOpacity->AddPoint(100, 1.0);

            vtkNew<vtkVolumeProperty> volumeProperty;
            volumeProperty->SetColor(volumeColor);
            volumeProperty->SetScalarOpacity(volumeScalarOpacity);
            volumeProperty->SetInterpolationTypeToLinear();

            volumeProperty->ShadeOff();
            volumeProperty->SetAmbient(0.1);
            volumeProperty->SetDiffuse(0.3);
            volumeProperty->SetSpecular(0.1);
            volume->SetProperty(volumeProperty);

            xrRenderer->AddVolume(volume);

            // Set camera to look at the object directly in front
            auto camera = vtkSmartPointer<vtkOpenXRCamera>::New();
            xrRenderer->SetActiveCamera(camera);

            double* c = volume->GetCenter();
            camera->SetViewUp(0, 0, -1);
            camera->SetPosition(c[0], c[1] - 400, c[2]);
            camera->SetFocalPoint(c[0], c[1], c[2]);
            camera->Azimuth(30.0);
            camera->Elevation(30.0);
        }
        else
        {
            logger.Log("Unsupported file format for XR!", CaveLogger::FAULT);
        }
    }

    while (!xrDone) {
        xrInteractor->ProcessEvents();        
        xrRenderWindow->Render();
        
        std::this_thread::sleep_for(std::chrono::milliseconds(16));        
    }

    logger.Log("Exiting XR rendering loop...", CaveLogger::INFO);

    xrRenderWindow->Finalize();
    xrRenderWindowActive = false;
    xrDone = true;
}

// Closes the HMD mode
void Renderer::CloseXR() {
    
    logger.Log("Closing XR render window...", CaveLogger::INFO);

    if (xrThread.joinable()) {
        xrDone = true; 
        xrThread.join();
        logger.Log("HMD rendering stopped", CaveLogger::INFO);
    }
}

// Activates CAVE mode by setting up the necessary windows (cave window and VR window)
// syncWindows.InitialzeWindows also handles window synchronisation
void Renderer::StartCAVE() 
{
    logger.Log("CAVE mode active. Initializing CAVE window.", CaveLogger::INFO);
    syncWindows.InitializeWindows(this->filePath);      
}

// This function ensures that all CAVE-related rendering windows are properly closed.
void Renderer::CloseCAVE()
{
    syncWindows.CloseWindows();
}

bool Renderer::IsCaveModeActive() const {
    return caveRenderWindowActive;
}

vtkSmartPointer<vtkRenderer> Renderer::GetRenderer() const
{
  return this->renderer;
}

vtkSmartPointer<vtkGenericOpenGLRenderWindow> Renderer::GetRenderWindow() const
{
  return this->renderWindow;
}

std::string Renderer::GetFilePath() const {
    return this->filePath;
}