#include "vtkPolyDataMapper.h"
#include <vtkSmartPointer.h>
#include <vtkCallbackCommand.h>
#include <vtkRenderer.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkMath.h>
#include <vtkRenderWindow.h>
#include <vtkGPUVolumeRayCastMapper.h>
#include <vtkVolumeProperty.h>
#include <vtkColorTransferFunction.h>
#include <vtkPiecewiseFunction.h>
#include <vtkImageShiftScale.h>
#include <vtkLookupTable.h>
#include <vtkImageMapToColors.h>
#include <vtkImageSliceMapper.h>
#include <vtkImageSlice.h>
#include <vtkMarchingCubes.h>
#include <vtkOutlineFilter.h>
#include <vtkImageStack.h>
#include <vtkPlanes.h>
#include <vtkFrustumSource.h>
#include <vtkProperty.h>
#include <vtkImageProperty.h>
#include <vtkCamera.h>
#include <vtkTimerLog.h>
#include <vtkTransform.h>
#include <vtkInteractorObserver.h>
#include <vtkInteractorStyleTrackballCamera.h>
#include <vtkAutoInit.h>


VTK_MODULE_INIT(vtkInteractionStyle);

void CallbackFunction(vtkObject* caller, long unsigned int vtkNotUsed(eventId), void* vtkNotUsed(clientData), void* vtkNotUsed(callData) )
{
  vtkRenderer* renderer = static_cast<vtkRenderer*>(caller);

  double timeInSeconds = renderer->GetLastRenderTimeInSeconds();
  double fps = double(1.0)/timeInSeconds;
 //printf("FPS_GPU: %f \n" ,fps);
  //std::cout << "FPS: " << fps << std::endl;

 
}


int main(int argc, char *argv[])
{

   // Reading data and obtaining an implicit representation

         // isosurface
         vtkMarchingCubes*shellE = vtkMarchingCubes::New();
        // ...
         //processing implicit data. Triangles generation

         shellE->Update(); //make sure from this point we deal with triangles only
	  std::cout << "Cells number "<<shellE->GetOutput()->GetNumberOfCells()<< std::endl;
         vtkPolyDataMapper *shellM = vtkPolyDataMapper::New();
         shellM->SetInputConnection(shellE->GetOutputPort());
         shellM->ScalarVisibilityOff();

    
         vtkSmartPointer<vtkActor> actor =
           vtkSmartPointer<vtkActor>::New();
         actor->SetMapper(shellM);

         renderer->AddActor(actor);
         


     


      vtkRenderWindow* renderWindow =
       vtkRenderWindow::New();
      renderWindow->AddRenderer(renderer);
      
      renderWindow->SetSize(1600,1600);

      vtkRenderWindowInteractor* renderWindowInteractor =
      vtkRenderWindowInteractor::New();
      renderWindowInteractor->SetRenderWindow(renderWindow);
      
  vtkSmartPointer<vtkInteractorStyleTrackballCamera> style = 
    vtkSmartPointer<vtkInteractorStyleTrackballCamera>::New(); //like paraview
  
  renderWindowInteractor->SetInteractorStyle( style );

      vtkSmartPointer<vtkCallbackCommand> callback =
        vtkSmartPointer<vtkCallbackCommand>::New();

      callback->SetCallback(CallbackFunction);
      renderer->AddObserver(vtkCommand::EndEvent, callback);

      renderer->SetBackground(.3, .6, .3); // Background color green

      // Render and interact
    //  renderWindow->Render();
   //   renderWindowInteractor->Initialize();
   // 
     
  double bounds[6];
  shellE->GetOutput()->GetBounds(bounds);
  
  renderer->ResetCamera();
  auto cam=renderer->GetActiveCamera();
  double pos[3];
 
       double time=0;
       int endCount=120;
  for (int i=0;i<endCount;i++)
  {
 
 double max[3]={bounds[1]+vtkMath::Random(0,10),bounds[3]+vtkMath::Random(0,10),bounds[5]+vtkMath::Random(0,10)};
  double min[3]={bounds[0]+vtkMath::Random(0,10),bounds[2]+vtkMath::Random(0,10),bounds[4]+vtkMath::Random(0,10)};
 

    
    renderer->ResetCamera(min[0],max[0],min[1],max[1],min[2],max[2]);
    renderWindow->Render();
    double sec=renderer->GetLastRenderTimeInSeconds();
  time+=double(1.0)/(sec);
  std::cout<<"seconds "<< sec<<std::endl;
  
  }
  std::cout<< "Total FPS: " << time/double(endCount) << std::endl;
  // Check the average frame rate when rotating the actor
 
  vtkSmartPointer<vtkTimerLog> clock =
    vtkSmartPointer<vtkTimerLog>::New();

  clock->StartTimer();
  for (int i = 0; i < endCount; i++)
    {
double max[3]={bounds[1]+vtkMath::Random(0,10),bounds[3]+vtkMath::Random(0,10),bounds[5]+vtkMath::Random(0,10)};
  double min[3]={bounds[0]+vtkMath::Random(0,10),bounds[2]+vtkMath::Random(0,10),bounds[4]+vtkMath::Random(0,10)};
 

    
    renderer->ResetCamera(min[0],max[0],min[1],max[1],min[2],max[2]);
    renderWindow->Render();
    }
  clock->StopTimer();
  double frameRate = (double)endCount / clock->GetElapsedTime();
  std::cout << "AVERAGE FRAME RATE: " << frameRate << " fps" << std::endl;

   renderWindowInteractor->Start();
}