Method ComputeMatrices

Rendering/Volume/vtkFixedPointVolumeRayCastMapper.cxx:2267–2331

}

void vtkFixedPointVolumeRayCastMapper::ComputeMatrices(double inputOrigin[3],
  double inputSpacing[3], int inputExtent[6], vtkRenderer* ren, vtkVolume* vol)
{
  // Get the camera from the renderer
  vtkCamera* cam = ren->GetActiveCamera();

  // Get the aspect ratio from the renderer. This is needed for the
  // computation of the perspective matrix
  ren->ComputeAspect();
  double* aspect = ren->GetAspect();

  // Keep track of the projection matrix - we'll need it in a couple of places
  // Get the projection matrix. The method is called perspective, but
  // the matrix is valid for perspective and parallel viewing transforms.
  // Don't replace this with the GetCompositePerspectiveTransformMatrix
  // because that turns off stereo rendering!!!
  this->PerspectiveTransform->Identity();
  this->PerspectiveTransform->Concatenate(
    cam->GetProjectionTransformMatrix(aspect[0] / aspect[1], 0.0, 1.0));
  this->PerspectiveTransform->Concatenate(cam->GetViewTransformMatrix());
  this->PerspectiveMatrix->DeepCopy(this->PerspectiveTransform->GetMatrix());

  // Compute the origin of the extent the volume origin is at voxel (0,0,0)
  // but we want to consider (0,0,0) in voxels to be at
  // (inputExtent[0], inputExtent[2], inputExtent[4]).
  double extentOrigin[3];
  extentOrigin[0] = inputOrigin[0] + inputExtent[0] * inputSpacing[0];
  extentOrigin[1] = inputOrigin[1] + inputExtent[2] * inputSpacing[1];
  extentOrigin[2] = inputOrigin[2] + inputExtent[4] * inputSpacing[2];

  // Get the volume matrix. This is a volume to world matrix right now.
  // We'll need to invert it, translate by the origin and scale by the
  // spacing to change it to a world to voxels matrix.
  vol->GetModelToWorldMatrix(this->VolumeMatrix);

  this->VoxelsToViewTransform->SetMatrix(this->VolumeMatrix);

  // Create a transform that will account for the scaling and translation of
  // the scalar data. The is the volume to voxels matrix.
  this->VoxelsTransform->Identity();
  this->VoxelsTransform->Translate(extentOrigin[0], extentOrigin[1], extentOrigin[2]);

  this->VoxelsTransform->Scale(inputSpacing[0], inputSpacing[1], inputSpacing[2]);

  // Now concatenate the volume's matrix with this scalar data matrix
  this->VoxelsToViewTransform->PreMultiply();
  this->VoxelsToViewTransform->Concatenate(this->VoxelsTransform->GetMatrix());

  // Now we actually have the world to voxels matrix - copy it out
  this->WorldToVoxelsMatrix->DeepCopy(this->VoxelsToViewTransform->GetMatrix());
  this->WorldToVoxelsMatrix->Invert();

  // We also want to invert this to get voxels to world
  this->VoxelsToWorldMatrix->DeepCopy(this->VoxelsToViewTransform->GetMatrix());

  // Compute the voxels to view transform by concatenating the
  // voxels to world matrix with the projection matrix (world to view)
  this->VoxelsToViewTransform->PostMultiply();