# Volume render using ExternalVTKWidget

**URL:** https://discourse.vtk.org/t/volume-render-using-externalvtkwidget/883
**Category:** Support
**Created:** [April 30, 2019, 6:51pm UTC](https://discourse.vtk.org/t/volume-render-using-externalvtkwidget/883 "2019-04-30T18:51:20Z")
**Posts on this page:** 1
**Page:** 1

<div class="post-metadata">

### Author: ![Kmilo9999](https://discourse.vtk.org/letter_avatar_proxy/v4/letter/k/cc9497/32.png) [@Kmilo9999](https://discourse.vtk.org/u/Kmilo9999)
#### Post date: [April 30, 2019, 6:51pm UTC](https://discourse.vtk.org/t/volume-render-using-externalvtkwidget/883/1 "2019-04-30T18:51:20Z")

</div>

Hello,

I am trying to modify the TestGLUTRenderWindow example in order to render voume data using glut. I’m not getting anything on screen. I wonder if someone could check the code and see what I might be missing. Thanks!

This is my display function:

```
void display()
{
 
  if (!initialized)
  {
	  myCamera = new Camera(glm::vec3(0, 0, -4), glm::vec3(0, 0, 1));
	  projectionMatrix = glm::perspective(glm::radians(45.f), 4.0f / 3.0f, 0.1f, 100.0f );
	 
      auto renWin = externalVTKWidget->GetRenderWindow();

      // since our example here is not setting up the `glViewport`, we don't want
      // the vtkExternalOpenGLRenderWindow to update its size based on the
      // glViewport hence we must disable automatic position and size.
       renWin->AutomaticWindowPositionAndResizeOff();

 
 	    vtkNew<vtkCallbackCommand> callback;
        callback->SetCallback(MakeCurrentCallback);
	    renWin->AddObserver(vtkCommand::WindowMakeCurrentEvent,
		callback);
        vtkNew<vtkPolyDataMapper> mapper;

        myRenderer = externalVTKWidget->AddRenderer();

   	 std::string filePath =std::string("D:\\VTK\\Rendering\\External\\Testing\\Cxx\\data\\FullHead.mhd");

	vtkSmartPointer<vtkFixedPointVolumeRayCastMapper> volumeMapper =
		vtkSmartPointer<vtkFixedPointVolumeRayCastMapper>::New();

	vtkSmartPointer<vtkMetaImageReader> metaReader =
		vtkSmartPointer<vtkMetaImageReader>::New();
	metaReader->SetFileName(filePath.c_str());
	metaReader->Update();

	vtkSmartPointer<vtkAlgorithm> reader =
		vtkSmartPointer<vtkAlgorithm>::New();
	vtkSmartPointer<vtkImageData> input =
		vtkSmartPointer<vtkImageData>::New();

	input = metaReader->GetOutput();
	reader = metaReader;

	vtkSmartPointer<vtkTransform> transform =
		vtkSmartPointer<vtkTransform>::New();
	transform->Scale(1,1, 1);

	volumeMapper->SetInputConnection(reader->GetOutputPort());

	vtkSmartPointer<vtkVolumeProperty> volumeProperty =
		vtkSmartPointer<vtkVolumeProperty>::New();
	//volumeProperty->ShadeOff();
	volumeProperty->SetInterpolationTypeToLinear();
	volumeProperty->SetIndependentComponents(true);

	vtkSmartPointer<vtkPiecewiseFunction> opacityFun =
		vtkSmartPointer<vtkPiecewiseFunction>::New();
	volumeProperty->SetScalarOpacity(opacityFun); // composite first.

	vtkSmartPointer<vtkColorTransferFunction> colorFun =
		vtkSmartPointer<vtkColorTransferFunction>::New();
	volumeProperty->SetColor(colorFun);

    volume = vtkSmartPointer<vtkVolume>::New();
	volume->SetMapper(volumeMapper);
	volume->SetProperty(volumeProperty);
	volume->SetUserTransform(transform);
	

	colorFun->AddRGBSegment(0.0, 1.0, 1.0, 1.0, 255.0, 1.0, 1.0, 1.0);
	opacityFun->AddSegment(opacityLevel - 0.5*opacityWindow, 0.0,
		opacityLevel + 0.5*opacityWindow, 1.0);
	volumeMapper->SetBlendModeToMaximumIntensity();

	myRenderer->AddVolume(volume);
    myRenderer->ResetCamera();

    initialized = true;
  }

  // Enable depth testing. Demonstrates OpenGL context being managed by external
  // application i.e. GLUT in this case.
  glEnable(GL_DEPTH_TEST);

  // Buffers being managed by external application i.e. GLUT in this case.
  glClearColor(1.0f, 0.0f, 0.0f, 1.0f); // Set background color to black and opaque
  glClearDepth(1.0f);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear the color buffer

  vtkExternalOpenGLCamera* camera = (vtkExternalOpenGLCamera *)myRenderer->GetActiveCamera();

  double view[16];
  for (int i = 0; i < 16; i++) {
	  //view[i] = glm::value_ptr(viewMatrix)[i];
	  glm::mat4 mat = myCamera->GetView();
	  view[i] = glm::value_ptr(mat)[i];
  }

  camera->SetViewTransformMatrix(view);

  double proj[16];
  for (int i = 0; i < 16; i++) {
	  proj[i] = glm::value_ptr(projectionMatrix)[i];
  }
  camera->SetProjectionTransformMatrix(proj);

  glFlush(); // Render now

  vtkLogScopeF(INFO, "do-vtk-render");
  externalVTKWidget->GetRenderWindow()->Render();
  glutSwapBuffers();
}

void test()
{
  vtkExternalOpenGLCamera* camera = (vtkExternalOpenGLCamera *)myRenderer->GetActiveCamera();

  double view[16];
  for (int i = 0; i < 16; i++) {
	  //view[i] = glm::value_ptr(viewMatrix)[i];
	  glm::mat4 mat = myCamera->GetView();
	  view[i] = glm::value_ptr(mat)[i];
  }

  camera->SetViewTransformMatrix(view);
  glm::mat4 userM = glm::mat4(1.0f);
  glm::mat4 translate = glm::translate(glm::vec3(0, 0, 0));
  glm::mat4 rotate = glm::translate(glm::vec3(0, 0, 0));
  glm::mat4 scale = glm::translate(glm::vec3(1, 1, 1));

  userM = translate * rotate * scale;

  double model[16];
  for (int i = 0; i < 16; i++) {
	  //view[i] = glm::value_ptr(viewMatrix)[i];
	  model[i] = glm::value_ptr(userM)[i];
  }
  
  vtkSmartPointer<vtkMatrix4x4> sm = vtkSmartPointer<vtkMatrix4x4>::New();
  sm->DeepCopy(model);
  sm->Transpose();
  volume->SetUserMatrix(sm);

  double proj[16];
  for (int i = 0; i < 16; i++) {
	  proj[i] = glm::value_ptr(projectionMatrix)[i];
  }

 externalVTKWidget->GetRenderWindow()->Render();
 camera->SetProjectionTransformMatrix(proj);
 }
```