#include <vtkCamera.h>
#include <vtkColorTransferFunction.h>
#include <vtkGPUVolumeRayCastMapper.h>
#include <vtkNamedColors.h>
#include <vtkNew.h>
#include <vtkPiecewiseFunction.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkStructuredPointsReader.h>
#include <vtkVolume.h>
#include <vtkVolumeProperty.h>
#include <vtkPolyDataMapper.h>
#include <vtkPNGWriter.h>
#include <vtkWindowToImageFilter.h>
#include <vtkMultiThreader.h>

#define OTF_ARGON()\
	opacityTransferFunction->AddPoint(0.0, 0.0);\
  	opacityTransferFunction->AddPoint(1.0, 1.0);
#define CTF_ARGON()\
	colorTransferFunction->AddRGBPoint(0.0, 0.23, 0.29, 0.75);\
	colorTransferFunction->AddRGBPoint(0.5, 0.87, 0.87, 0.87);\
	colorTransferFunction->AddRGBPoint(1.0, 0.71, 0.02, 0.15);

int main(int argc, char* argv[])
{
	vtkMultiThreader::SetGlobalMaximumNumberOfThreads(1);
	if (argc < 2)
	{
    	std::cout << "Usage: " << argv[0] << " dataset.vtk" << std::endl;
    	return EXIT_FAILURE;
	}

	// Create the standard renderer, render window and interactor
  	vtkNew<vtkRenderer> ren1;

  	vtkNew<vtkRenderWindow> renWin;
 	renWin->AddRenderer(ren1);

 	vtkNew<vtkRenderWindowInteractor> iren;
  	iren->SetRenderWindow(renWin);

  	// Create the reader for the data
  	vtkNew<vtkStructuredPointsReader> reader;
  	reader->SetFileName(argv[1]);
  	reader->Update();

  	// Create transfer mapping scalar value to opacity
  	vtkSmartPointer<vtkPiecewiseFunction> opacityTransferFunction = vtkSmartPointer<vtkPiecewiseFunction>::New();
	OTF_ARGON();

  	// Create transfer mapping scalar value to color
  	vtkNew<vtkColorTransferFunction> colorTransferFunction;
	CTF_ARGON()

  	// The property describes how the data will look
  	vtkNew<vtkVolumeProperty> volumeProperty;
  	volumeProperty->SetColor(colorTransferFunction);
  	volumeProperty->SetScalarOpacity(opacityTransferFunction);

	volumeProperty->SetInterpolationTypeToLinear();

  	// The mapper / ray cast function know how to render the data
  	vtkNew<vtkGPUVolumeRayCastMapper> volumeMapper;
  	volumeMapper->SetInputConnection(reader->GetOutputPort());
  	volumeMapper->SetSampleDistance(0.1);
  	volumeMapper->SetBlendModeToComposite();

  	// The volume holds the mapper and the property
  	vtkNew<vtkVolume> volume;
  	volume->SetMapper(volumeMapper);
  	volume->SetProperty(volumeProperty);

  	ren1->AddVolume(volume);
  	ren1->SetBackground(1, 1, 1);

  	ren1->ResetCameraClippingRange();
  	ren1->ResetCamera();
	
	// set camera parameters from arguments
	double position_x = 0;
	double position_y = 450;
	double position_z = 0;
	double focal_point_x = 0;
	double focal_point_y = 0;
	double focal_point_z = -15;
	double view_up_x = 0;
	double view_up_y = 0;
	double view_up_z = -1;
  	ren1->GetActiveCamera()->SetPosition(position_x,
										 position_y,
										 position_z);
  	ren1->GetActiveCamera()->SetFocalPoint(focal_point_x,
										   focal_point_y,
										   focal_point_z);
  	ren1->GetActiveCamera()->SetViewUp(view_up_x,
									   view_up_y,
									   view_up_z);
  	
	ren1->GetActiveCamera()->SetViewAngle(30);
  	ren1->GetActiveCamera()->SetClippingRange(0.1, 1000);
  
  	renWin->SetSize(1024, 1024);
  	renWin->SetWindowName("Rendering Result");
  	renWin->Render();

    // Screenshot
    vtkNew<vtkWindowToImageFilter> windowToImageFilter;
    windowToImageFilter->SetInput(iren->GetRenderWindow());
    windowToImageFilter->SetScale(1);
    windowToImageFilter->SetInputBufferTypeToRGB();
    windowToImageFilter->ReadFrontBufferOff();
    vtkNew<vtkPNGWriter> writer;
    std::string fileName = "../argon-bubble_gs.png";
    writer->SetFileName(fileName.c_str());
    writer->SetInputConnection(windowToImageFilter->GetOutputPort());
    writer->Write();
    std::cout << "=======Saving rendering Done!" << endl;

	// Turn on for interaction
  	// iren->Start();

  	return EXIT_SUCCESS;
}