Commit 8420585d authored by Sankhesh Jhaveri's avatar Sankhesh Jhaveri

[Volume] Added tests for per component light parameters

Added tests for both dependent and independent
parent 39f67ffa
......@@ -60,9 +60,12 @@ set (VolumeOpenGL2CxxTests
TestGPURayCastClipping.cxx
TestGPURayCastClippingPolyData.cxx
TestGPURayCastClippingUserTransform.cxx
TestGPURayCastDependentComponentsLightParameters.cxx
TestGPURayCastFourComponentsDependentGradient.cxx
TestGPURayCastGradientOpacity.cxx
TestGPURayCastGradientOpacityLight.cxx
TestGPURayCastIndependentComponentsLightParameters.cxx
TestGPURayCastLargeColorTransferFunction.cxx
TestGPURayCastPositionalLights.cxx
TestGPURayCastReleaseResources.cxx
TestGPURayCastRenderDepthToImage.cxx
......@@ -79,10 +82,9 @@ set (VolumeOpenGL2CxxTests
TestGPURayCastVolumePolyData.cxx
TestGPURayCastVolumeRotation.cxx
TestGPURayCastVolumeScale.cxx
TestProjectedTetrahedraTransform.cxx
TestProjectedTetrahedraOffscreen.cxx
TestProjectedTetrahedraTransform.cxx
TestRemoveVolumeNonCurrentContext.cxx
TestGPURayCastLargeColorTransferFunction.cxx
)
# everyone gets these tests
......
/*=========================================================================
Program: Visualization Toolkit
Module: TestGPURayCastDependentComponentsLightParameters.cxx
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
// This test volume renders the vase dataset with 4 dependent components the
// composite method with shading and light parameters.
#include "vtkGPUVolumeRayCastMapper.h"
#include "vtkTestUtilities.h"
#include "vtkXMLImageDataReader.h"
#include "vtkImageShiftScale.h"
#include "vtkColorTransferFunction.h"
#include "vtkPiecewiseFunction.h"
#include "vtkTransform.h"
#include "vtkRenderer.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkVolumeProperty.h"
#include "vtkCamera.h"
#include "vtkRegressionTestImage.h"
int TestGPURayCastDependentComponentsLightParameters(int argc,
char *argv[])
{
cout << "CTEST_FULL_OUTPUT (Avoid ctest truncation of output)" << endl;
char *cfname=
vtkTestUtilities::ExpandDataFileName(argc, argv, "Data/vase_4comp.vti");
vtkXMLImageDataReader *reader=vtkXMLImageDataReader::New();
reader->SetFileName(cfname);
delete [] cfname;
vtkRenderer *ren1=vtkRenderer::New();
vtkRenderWindow *renWin=vtkRenderWindow::New();
renWin->AddRenderer(ren1);
renWin->SetSize(301,300);
vtkRenderWindowInteractor *iren=vtkRenderWindowInteractor::New();
iren->SetRenderWindow(renWin);
renWin->Render();
vtkGPUVolumeRayCastMapper *volumeMapper;
vtkVolumeProperty *volumeProperty;
vtkVolume *volume;
volumeMapper=vtkGPUVolumeRayCastMapper::New();
volumeMapper->SetBlendModeToComposite();
volumeMapper->SetInputConnection(
reader->GetOutputPort());
vtkPiecewiseFunction *opacity=vtkPiecewiseFunction::New();
opacity->AddPoint(0,0);
opacity->AddPoint(255,1);
volumeProperty=vtkVolumeProperty::New();
volumeProperty->IndependentComponentsOff();
volumeProperty->ShadeOn();
volumeProperty->SetScalarOpacity(opacity);
volumeProperty->SetAmbient(0.1);
volumeProperty->SetDiffuse(0.9);
volumeProperty->SetSpecular(0.4);
volumeProperty->SetSpecularPower(10.0);
volume=vtkVolume::New();
volume->SetMapper(volumeMapper);
volume->SetProperty(volumeProperty);
ren1->AddViewProp(volume);
int valid=volumeMapper->IsRenderSupported(renWin,volumeProperty);
int retVal;
if(valid)
{
iren->Initialize();
ren1->SetBackground(0.1,0.4,0.2);
ren1->ResetCamera();
renWin->Render();
retVal = vtkTesting::Test(argc, argv, renWin, 75);
if (retVal == vtkRegressionTester::DO_INTERACTOR)
{
iren->Start();
}
}
else
{
retVal=vtkTesting::PASSED;
cout << "Required extensions not supported." << endl;
}
iren->Delete();
renWin->Delete();
ren1->Delete();
volumeMapper->Delete();
volumeProperty->Delete();
volume->Delete();
opacity->Delete();
reader->Delete();
if ((retVal == vtkTesting::PASSED) || (retVal == vtkTesting::DO_INTERACTOR))
{
return 0;
}
else
{
return 1;
}
}
/*=========================================================================
Program: Visualization Toolkit
Module: TestGPURayCastIndependentComponentsLightParameters.cxx
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
// Description
// This test creates a vtkImageData with three components.
// The data is volume rendered considering the three components as independent
// with shading and complex light parameters.
#include "vtkCamera.h"
#include "vtkColorTransferFunction.h"
#include "vtkGPUVolumeRayCastMapper.h"
#include "vtkImageData.h"
#include "vtkInteractorStyleTrackballCamera.h"
#include "vtkNew.h"
#include "vtkPiecewiseFunction.h"
#include "vtkRegressionTestImage.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkRenderer.h"
#include "vtkSphere.h"
#include "vtkVolume.h"
#include "vtkVolumeProperty.h"
int TestGPURayCastIndependentComponentsLightParameters(int argc, char *argv[])
{
cout << "CTEST_FULL_OUTPUT (Avoid ctest truncation of output)" << endl;
int dims[3] = {100, 100, 100};
// Create a vtkImageData with two components
vtkNew<vtkImageData> image;
image->SetDimensions(dims[0], dims[1], dims[2]);
image->AllocateScalars(VTK_DOUBLE, 3);
// Fill the first half rectangular parallelopiped along X with the
// first component values and the second half with second component values
double * ptr = static_cast<double *> (image->GetScalarPointer(0, 0, 0));
double center1[3], center2[3], center3[3];
center1[0] = dims[0]/3; center2[0] = center1[0]*2; center3[0] = dims[0]/2;
center1[1] = center2[1] = dims[1]/2; center3[1] = dims[1]/3;
center1[2] = center2[2] = center3[2] = dims[2]/2;
double radius;
radius = center1[0];
vtkNew<vtkSphere> sphere1;
sphere1->SetCenter(center1);
sphere1->SetRadius(radius);
vtkNew<vtkSphere> sphere2;
sphere2->SetCenter(center2);
sphere2->SetRadius(radius);
vtkNew<vtkSphere> sphere3;
sphere3->SetCenter(center3);
sphere3->SetRadius(radius);
for (int z = 0; z < dims[2]; ++z)
{
for (int y = 0; y < dims[1]; ++y)
{
for (int x = 0; x < dims[0]; ++x)
{
// Set first component
if (sphere1->EvaluateFunction(x, y, z) > 0)
{
// point outside sphere 1
*ptr++ = 0.0;
}
else
{
*ptr++ = 0.33;
}
// Set second component
if (sphere2->EvaluateFunction(x, y, z) > 0)
{
// point outside sphere 2
*ptr++ = 0.0;
}
else
{
*ptr++ = 0.33;
}
// Set third component
if (sphere3->EvaluateFunction(x, y, z) > 0)
{
// point outside sphere 2
*ptr++ = 0.0;
}
else
{
*ptr++ = 0.33;
}
}
}
}
vtkNew<vtkRenderWindow> renWin;
renWin->SetSize(301, 300); // Intentional NPOT size
renWin->SetMultiSamples(0);
vtkNew<vtkRenderer> ren;
renWin->AddRenderer(ren.GetPointer());
vtkNew<vtkRenderWindowInteractor> iren;
vtkNew<vtkInteractorStyleTrackballCamera> style;
iren->SetInteractorStyle(style.GetPointer());
iren->SetRenderWindow(renWin.GetPointer());
renWin->Render();
// Volume render the dataset
vtkNew<vtkGPUVolumeRayCastMapper> mapper;
mapper->AutoAdjustSampleDistancesOff();
mapper->SetSampleDistance(0.9);
mapper->SetInputData(image.GetPointer());
// Color transfer function
vtkNew<vtkColorTransferFunction> ctf1;
ctf1->AddRGBPoint(0.0, 0.0, 0.0, 0.0);
ctf1->AddRGBPoint(1.0, 0.0, 1.0, 0.0);
vtkNew<vtkColorTransferFunction> ctf2;
ctf2->AddRGBPoint(0.0, 0.0, 0.0, 0.0);
ctf2->AddRGBPoint(1.0, 0.0, 1.0, 0.0);
vtkNew<vtkColorTransferFunction> ctf3;
ctf3->AddRGBPoint(0.0, 0.0, 0.0, 0.0);
ctf3->AddRGBPoint(1.0, 0.0, 1.0, 0.0);
// Opacity functions
vtkNew<vtkPiecewiseFunction> pf1;
pf1->AddPoint(0.0, 0.0);
pf1->AddPoint(1.0, 0.2);
vtkNew<vtkPiecewiseFunction> pf2;
pf2->AddPoint(0.0, 0.0);
pf2->AddPoint(1.0, 0.2);
vtkNew<vtkPiecewiseFunction> pf3;
pf3->AddPoint(0.0, 0.0);
pf3->AddPoint(1.0, 0.2);
// Volume property with independent components ON
vtkNew<vtkVolumeProperty> property;
property->IndependentComponentsOn();
// Set color and opacity functions
property->SetColor(0, ctf1.GetPointer());
property->SetColor(1, ctf2.GetPointer());
property->SetColor(2, ctf3.GetPointer());
property->SetScalarOpacity(0, pf1.GetPointer());
property->SetScalarOpacity(1, pf2.GetPointer());
property->SetScalarOpacity(2, pf3.GetPointer());
// Define light parameters
property->ShadeOn();
property->SetAmbient(0, 0.2);
property->SetDiffuse(0, 0.9);
property->SetSpecular(0, 0.4);
property->SetSpecularPower(0, 10.0);
property->SetAmbient(1, 0.5);
property->SetDiffuse(1, 0.3);
property->SetSpecular(1, 0.1);
property->SetSpecularPower(1, 1.0);
property->SetAmbient(2, 0.7);
property->SetDiffuse(2, 0.9);
property->SetSpecular(2, 0.4);
property->SetSpecularPower(2, 10.0);
vtkNew<vtkVolume> volume;
volume->SetMapper(mapper.GetPointer());
volume->SetProperty(property.GetPointer());
ren->AddVolume(volume.GetPointer());
ren->ResetCamera();
iren->Initialize();
renWin->Render();
ren->GetActiveCamera()->Zoom(1.5);
int retVal = vtkTesting::Test(argc, argv, renWin.GetPointer(), 15);
if (retVal == vtkRegressionTester::DO_INTERACTOR)
{
iren->Start();
}
if ((retVal == vtkTesting::PASSED) || (retVal == vtkTesting::DO_INTERACTOR))
{
return EXIT_SUCCESS;
}
else
{
return EXIT_FAILURE;
}
}
......@@ -2996,23 +2996,23 @@ void vtkOpenGLGPUVolumeRayCastMapper::BuildShader(vtkRenderer* ren,
if (this->Impl->CurrentSelectionPass != (vtkHardwareSelector::MIN_KNOWN_PASS - 1))
{
switch(this->Impl->CurrentSelectionPass)
{
case vtkHardwareSelector::ID_LOW24:
fragmentShader = vtkvolume::replace(fragmentShader, "//VTK::Picking::Exit",
vtkvolume::PickingIdLow24PassExit(ren, this, vol), true);
break;
case vtkHardwareSelector::ID_MID24:
fragmentShader = vtkvolume::replace(fragmentShader, "//VTK::Picking::Exit",
vtkvolume::PickingIdMid24PassExit(ren, this, vol), true);
break;
default: // ACTOR_PASS, PROCESS_PASS
fragmentShader = vtkvolume::replace(fragmentShader, "//VTK::Picking::Dec",
vtkvolume::PickingActorPassDeclaration(ren, this, vol), true);
{
case vtkHardwareSelector::ID_LOW24:
fragmentShader = vtkvolume::replace(fragmentShader, "//VTK::Picking::Exit",
vtkvolume::PickingIdLow24PassExit(ren, this, vol), true);
break;
case vtkHardwareSelector::ID_MID24:
fragmentShader = vtkvolume::replace(fragmentShader, "//VTK::Picking::Exit",
vtkvolume::PickingIdMid24PassExit(ren, this, vol), true);
break;
default: // ACTOR_PASS, PROCESS_PASS
fragmentShader = vtkvolume::replace(fragmentShader, "//VTK::Picking::Dec",
vtkvolume::PickingActorPassDeclaration(ren, this, vol), true);
fragmentShader = vtkvolume::replace(fragmentShader, "//VTK::Picking::Exit",
vtkvolume::PickingActorPassExit(ren, this, vol), true);
break;
}
fragmentShader = vtkvolume::replace(fragmentShader, "//VTK::Picking::Exit",
vtkvolume::PickingActorPassExit(ren, this, vol), true);
break;
}
}
// Render to texture
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment