Commit c9af1eec authored by Ben Boeckel's avatar Ben Boeckel Committed by Kitware Robot
Browse files

Merge topic 'remove-vtkTexturePainter'

e0afd06f catalyst: fix a JSON format typo
b6f24790 vtkTexturePainter: remove
9727a2ba

 catalyst: remove referenced to the removed vtkPainterDeviceAdapter
Acked-by: Kitware Robot's avatarKitware Robot <kwrobot@kitware.com>
Acked-by: Utkarsh Ayachit's avatarUtkarsh Ayachit <utkarsh.ayachit@kitware.com>
Merge-request: !2090
parents dbddecac e0afd06f
Pipeline #84957 failed with stage
in 0 seconds
......@@ -31,7 +31,7 @@
{ "class":"vtkPVPlane" }
],
"replace":[
{ "path":"ParaViewCore/VTKExtensions/Default/CMakeLists.txt" }
{ "path":"ParaViewCore/VTKExtensions/Default/CMakeLists.txt" },
{ "path":"ParaViewCore/VTKExtensions/Default/module.cmake" }
],
"cswrap":true,
......
......@@ -396,7 +396,6 @@
{ "class": "vtkMapper" },
{ "class": "vtkMapper2D" },
{ "class": "vtkObserverMediator" },
{ "class": "vtkPainterDeviceAdapter" },
{ "class": "vtkPicker" },
{ "class": "vtkPickingManager" },
{ "class": "vtkPointGaussianMapper" },
......
/*=========================================================================
Program: Visualization Toolkit
Module: vtkTexturePainter.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.
=========================================================================*/
#include "vtkTexturePainter.h"
#include "vtkCellType.h"
#include "vtkExtractVOI.h"
#include "vtkImageData.h"
#include "vtkInformation.h"
#include "vtkInformationIntegerKey.h"
#include "vtkInformationObjectBaseKey.h"
#include "vtkInformationStringKey.h"
#include "vtkMapper.h"
#include "vtkObjectFactory.h"
#include "vtkPainterDeviceAdapter.h"
#include "vtkPointData.h"
#include "vtkRenderWindow.h"
#include "vtkRenderer.h"
#include "vtkScalarsToColors.h"
#include "vtkSmartPointer.h"
#include "vtkStreamingDemandDrivenPipeline.h"
#include "vtkStructuredData.h"
#include "vtkTexture.h"
#include "vtkgl.h"
vtkStandardNewMacro(vtkTexturePainter);
vtkCxxSetObjectMacro(vtkTexturePainter, LookupTable, vtkScalarsToColors);
vtkInformationKeyMacro(vtkTexturePainter, SLICE, Integer);
vtkInformationKeyMacro(vtkTexturePainter, SLICE_MODE, Integer);
vtkInformationKeyMacro(vtkTexturePainter, LOOKUP_TABLE, ObjectBase);
vtkInformationKeyMacro(vtkTexturePainter, MAP_SCALARS, Integer);
vtkInformationKeyMacro(vtkTexturePainter, SCALAR_MODE, Integer);
vtkInformationKeyMacro(vtkTexturePainter, SCALAR_ARRAY_NAME, String);
vtkInformationKeyMacro(vtkTexturePainter, SCALAR_ARRAY_INDEX, Integer);
vtkInformationKeyMacro(vtkTexturePainter, USE_XY_PLANE, Integer);
//----------------------------------------------------------------------------
vtkTexturePainter::vtkTexturePainter()
{
this->Texture = vtkTexture::New();
this->Slice = 0;
this->SliceMode = XY_PLANE;
float* ptr = &this->QuadPoints[0][0];
for (int cc = 0; cc < 12; cc++)
{
ptr[cc] = 0;
}
this->LookupTable = 0;
this->MapScalars = 0;
this->ScalarArrayName = 0;
this->ScalarArrayIndex = 0;
this->UseXYPlane = 0;
this->ScalarMode = vtkDataObject::FIELD_ASSOCIATION_POINTS;
this->WholeExtent[0] = 0;
this->WholeExtent[1] = -1;
this->WholeExtent[2] = 0;
this->WholeExtent[3] = -1;
this->WholeExtent[4] = 0;
this->WholeExtent[5] = -1;
}
//----------------------------------------------------------------------------
vtkTexturePainter::~vtkTexturePainter()
{
this->Texture->Delete();
this->SetLookupTable(0);
this->SetScalarArrayName(0);
}
//----------------------------------------------------------------------------
void vtkTexturePainter::ReleaseGraphicsResources(vtkWindow* win)
{
this->Texture->ReleaseGraphicsResources(win);
this->Superclass::ReleaseGraphicsResources(win);
}
//----------------------------------------------------------------------------
void vtkTexturePainter::ProcessInformation(vtkInformation* information)
{
if (information->Has(SLICE()))
{
this->SetSlice(information->Get(SLICE()));
}
if (information->Has(SLICE_MODE()))
{
this->SetSliceMode(information->Get(SLICE_MODE()));
}
if (information->Has(LOOKUP_TABLE()))
{
vtkScalarsToColors* lut = vtkScalarsToColors::SafeDownCast(information->Get(LOOKUP_TABLE()));
this->SetLookupTable(lut);
}
if (information->Has(MAP_SCALARS()))
{
this->SetMapScalars(information->Get(MAP_SCALARS()));
}
if (information->Has(SCALAR_MODE()))
{
this->SetScalarMode(information->Get(SCALAR_MODE()));
}
if (information->Has(SCALAR_ARRAY_NAME()))
{
this->SetScalarArrayName(information->Get(SCALAR_ARRAY_NAME()));
}
else
{
this->SetScalarArrayName(0);
}
if (information->Has(SCALAR_ARRAY_INDEX()))
{
this->SetScalarArrayIndex(information->Get(SCALAR_ARRAY_INDEX()));
}
if (information->Has(USE_XY_PLANE()))
{
this->SetUseXYPlane(information->Get(USE_XY_PLANE()));
}
else
{
this->SetUseXYPlane(0);
}
this->Superclass::ProcessInformation(information);
}
//----------------------------------------------------------------------------
static int vtkGetDataDimension(int inextents[6])
{
int dim[3];
dim[0] = inextents[1] - inextents[0] + 1;
dim[1] = inextents[3] - inextents[2] + 1;
dim[2] = inextents[5] - inextents[4] + 1;
int dimensionality = 0;
dimensionality += (dim[0] > 1 ? 1 : 0);
dimensionality += (dim[1] > 1 ? 1 : 0);
dimensionality += (dim[2] > 1 ? 1 : 0);
return dimensionality;
}
static const int XY_PLANE_QPOINTS_INDICES[] = { 0, 2, 4, 1, 2, 4, 1, 3, 4, 0, 3, 4 };
static const int YZ_PLANE_QPOINTS_INDICES[] = { 0, 2, 4, 0, 3, 4, 0, 3, 5, 0, 2, 5 };
static const int XZ_PLANE_QPOINTS_INDICES[] = { 0, 2, 4, 1, 2, 4, 1, 2, 5, 0, 2, 5 };
static const int* XY_PLANE_QPOINTS_INDICES_ORTHO = XY_PLANE_QPOINTS_INDICES;
static const int YZ_PLANE_QPOINTS_INDICES_ORTHO[] = { 2, 4, 0, 3, 4, 0, 3, 5, 0, 2, 5, 0 };
static const int XZ_PLANE_QPOINTS_INDICES_ORTHO[] = { 4, 0, 2, 4, 1, 2, 5, 1, 2, 5, 0, 2 };
//----------------------------------------------------------------------------
int vtkTexturePainter::SetupScalars(vtkImageData* input)
{
// Based on the scalar mode, scalar array, scalar id,
// we need to tell the vtkTexture to use the appropriate scalars.
int cellFlag = 0;
vtkDataArray* scalars = vtkAbstractMapper::GetScalars(input, this->ScalarMode,
this->ScalarArrayName ? VTK_GET_ARRAY_BY_NAME : VTK_GET_ARRAY_BY_ID, this->ScalarArrayIndex,
this->ScalarArrayName, cellFlag);
if (!scalars)
{
vtkWarningMacro("Failed to locate selected scalars. Will use image "
"scalars by default.");
// If not scalar array specified, simply use the point data (the cell
// data) scalars.
this->Texture->SetInputArrayToProcess(
0, 0, 0, vtkDataObject::FIELD_ASSOCIATION_POINTS_THEN_CELLS, vtkDataSetAttributes::SCALARS);
cellFlag = 0;
}
else
{
// Pass the scalar array choice to the texture.
this->Texture->SetInputArrayToProcess(0, 0, 0,
(cellFlag ? vtkDataObject::FIELD_ASSOCIATION_CELLS : vtkDataObject::FIELD_ASSOCIATION_POINTS),
scalars->GetName());
}
return cellFlag;
}
#define PRINT(ext) \
ext[0] << ", " << ext[1] << ", " << ext[2] << ", " << ext[3] << ", " << ext[4] << ", " \
<< ext[5]
//----------------------------------------------------------------------------
void vtkTexturePainter::RenderInternal(
vtkRenderer* renderer, vtkActor* actor, unsigned long typeflags, bool forceCompileOnly)
{
vtkImageData* input = vtkImageData::SafeDownCast(this->GetInput());
if (this->UpdateTime < input->GetMTime() || this->UpdateTime < this->MTime)
{
this->UpdateTime.Modified();
int sliceDescription = 0;
int inextent[6];
int outextent[6];
// we deliberately use whole extent here. So on processes where the slice is
// not available, the vtkExtractVOI filter will simply yield an empty
// output.
memcpy(inextent, this->WholeExtent, 6 * sizeof(int));
memcpy(outextent, inextent, sizeof(int) * 6);
int numdims = ::vtkGetDataDimension(inextent);
int dims[3];
dims[0] = inextent[1] - inextent[0] + 1;
dims[1] = inextent[3] - inextent[2] + 1;
dims[2] = inextent[5] - inextent[4] + 1;
// * Determine if we are using cell scalars or point scalars. That limits
// the extents/bounds etc.
int cellFlag = this->SetupScalars(input);
// Determine the VOI to extract:
// * If the input image is 3D, then we respect the slice number and slice
// direction the user recommended.
// * If the input image is 2D, we simply show the input image slice.
// * If the input image is 1D, we raise an error.
if (numdims == 3)
{
int slice = this->Slice;
// clamp the slice number at min val.
slice = (slice < 0) ? 0 : slice;
// if cell centered, then dimensions reduces by 1.
int curdim = cellFlag ? (dims[this->SliceMode] - 1) : dims[this->SliceMode];
// clamp the slice number at max val.
slice = (slice >= curdim) ? curdim - 1 : slice;
if (this->SliceMode == XY_PLANE) // XY plane
{
outextent[4] = outextent[5] = outextent[4] + slice;
sliceDescription = VTK_XY_PLANE;
}
else if (this->SliceMode == YZ_PLANE) // YZ plane
{
outextent[0] = outextent[1] = outextent[0] + slice;
sliceDescription = VTK_YZ_PLANE;
}
else if (this->SliceMode == XZ_PLANE) // XZ plane
{
outextent[2] = outextent[3] = outextent[2] + slice;
sliceDescription = VTK_XZ_PLANE;
}
}
else if (numdims == 2)
{
if (inextent[4] == inextent[5]) // XY plane
{
// nothing to change.
sliceDescription = VTK_XY_PLANE;
}
else if (inextent[0] == inextent[1]) /// YZ plane
{
sliceDescription = VTK_YZ_PLANE;
}
else if (inextent[2] == inextent[3]) // XZ plane
{
sliceDescription = VTK_XZ_PLANE;
}
}
else
{
vtkErrorMacro("Incorrect dimensionality.");
return;
}
vtkSmartPointer<vtkImageData> clone = vtkSmartPointer<vtkImageData>::New();
clone->ShallowCopy(input);
vtkSmartPointer<vtkExtractVOI> extractVOI = vtkSmartPointer<vtkExtractVOI>::New();
extractVOI->SetVOI(outextent);
extractVOI->SetInputData(clone);
extractVOI->Update();
int evoi[6];
extractVOI->GetOutput()->GetExtent(evoi);
if (evoi[1] < evoi[0] && evoi[3] < evoi[2] && evoi[5] < evoi[4])
{
// if vtkExtractVOI did not produce a valid output, that means there's no
// image slice to display.
this->Texture->SetInputData(0);
return;
}
// TODO: Here we would have change the input scalars if the user asked us to.
// The LUT can be simply passed to the vtkTexture. It can handle scalar
// mapping.
this->Texture->SetInputConnection(extractVOI->GetOutputPort());
double outputbounds[6];
// TODO: vtkExtractVOI is not passing correct origin. Until that's fixed, I
// will just use the input origin/spacing to compute the bounds.
clone->SetExtent(evoi);
clone->GetBounds(outputbounds);
clone = 0;
this->Texture->SetLookupTable(this->LookupTable);
this->Texture->SetColorMode(
this->MapScalars ? VTK_COLOR_MODE_MAP_SCALARS : VTK_COLOR_MODE_DEFAULT);
if (cellFlag)
{
// Structured bounds are point bounds. Shrink them to reflect cell
// center bounds.
// i.e move min bounds up by spacing/2 in that direction
// and move max bounds down by spacing/2 in that direction.
double spacing[3];
input->GetSpacing(spacing); // since spacing doesn't change, we can use
// input spacing directly.
for (int dir = 0; dir < 3; dir++)
{
double& min = outputbounds[2 * dir];
double& max = outputbounds[2 * dir + 1];
if (min + spacing[dir] <= max)
{
min += spacing[dir] / 2.0;
max -= spacing[dir] / 2.0;
}
else
{
min = max = (min + spacing[dir] / 2.0);
}
}
}
const int* indices = NULL;
switch (sliceDescription)
{
case VTK_XY_PLANE:
indices = XY_PLANE_QPOINTS_INDICES;
if (this->UseXYPlane)
{
indices = XY_PLANE_QPOINTS_INDICES_ORTHO;
outputbounds[4] = 0;
}
break;
case VTK_YZ_PLANE:
indices = YZ_PLANE_QPOINTS_INDICES;
if (this->UseXYPlane)
{
indices = YZ_PLANE_QPOINTS_INDICES_ORTHO;
outputbounds[0] = 0;
}
break;
case VTK_XZ_PLANE:
indices = XZ_PLANE_QPOINTS_INDICES;
if (this->UseXYPlane)
{
indices = XZ_PLANE_QPOINTS_INDICES_ORTHO;
outputbounds[2] = 0;
}
break;
}
for (int cc = 0; cc < 12; cc++)
{
static_cast<float*>(&this->QuadPoints[0][0])[cc] = outputbounds[indices[cc]];
}
}
if (!this->Texture->GetInput())
{
return;
}
vtkPainterDeviceAdapter* device = renderer->GetRenderWindow()->GetPainterDeviceAdapter();
// Lighting needs to be disabled since this painter always employs scalar
// coloring and when coloring with scalars we always disable lighting.
GLboolean lighting = glIsEnabled(GL_LIGHTING);
if (lighting)
{
glDisable(GL_LIGHTING);
}
this->Texture->Load(renderer);
float tcoords[4][2] = { { 0, 0 }, { 1, 0 }, { 1, 1 }, { 0, 1 } };
device->BeginPrimitive(VTK_QUAD);
for (int cc = 0; cc < 4; cc++)
{
device->SendAttribute(vtkPointData::TCOORDS, 2, VTK_FLOAT, &tcoords[cc][0], 0);
device->SendAttribute(vtkPointData::NUM_ATTRIBUTES, 3, VTK_FLOAT, &this->QuadPoints[cc][0], 0);
}
device->EndPrimitive();
// restore lighting if needed
if (lighting)
{
glEnable(GL_LIGHTING);
}
this->Superclass::RenderInternal(renderer, actor, typeflags, forceCompileOnly);
}
//----------------------------------------------------------------------------
void vtkTexturePainter::PrintSelf(ostream& os, vtkIndent indent)
{
this->Superclass::PrintSelf(os, indent);
os << indent << "Slice: " << this->Slice << endl;
os << indent << "SliceMode: " << this->SliceMode << endl;
os << indent << "MapScalars: " << this->MapScalars << endl;
os << indent << "ScalarMode: ";
switch (this->ScalarMode)
{
case VTK_SCALAR_MODE_DEFAULT:
os << "DEFAULT";
break;
case VTK_SCALAR_MODE_USE_POINT_DATA:
os << "USE POINT DATA";
break;
case VTK_SCALAR_MODE_USE_CELL_DATA:
os << "USE CELL DATA";
break;
case VTK_SCALAR_MODE_USE_POINT_FIELD_DATA:
os << "USE POINT FIELD DATA";
break;
case VTK_SCALAR_MODE_USE_CELL_FIELD_DATA:
os << "USE CELL FIELD DATA";
break;
case VTK_SCALAR_MODE_USE_FIELD_DATA:
os << "USE FIELD DATA";
break;
default:
os << "INVALID";
}
os << endl;
os << indent << "ScalarArrayName: " << (this->ScalarArrayName ? this->ScalarArrayName : "(none)")
<< endl;
os << indent << "ScalarArrayIndex: " << this->ScalarArrayIndex << endl;
os << indent << "LookupTable: " << this->LookupTable << endl;
}
/*=========================================================================
Program: Visualization Toolkit
Module: vtkTexturePainter.h
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.
=========================================================================*/
/**
* @class vtkTexturePainter
* @brief renders a slice of vtkImageData by loading the
* slice as a texture and then applying it to a quad.
*
* vtkTexturePainter is a painter for vtkImageData. It can render a slice of
* image data by loading it as an texture and then displaying it on a quad. It
* uses the bounds of the slice to position the quad. Unlike other image data
* algorithms, this painter provides API to choose the scalars to upload. If
* cell data is used, then cell centers are used to position the slice.
*/
#ifndef vtkTexturePainter_h
#define vtkTexturePainter_h
#include "vtkPVVTKExtensionsRenderingModule.h" // needed for export macro
#include "vtkPainter.h"
class vtkImageData;
class vtkInformationIntegerKey;
class vtkInformationObjectBaseKey;
class vtkInformationStringKey;
class vtkScalarsToColors;
class vtkTexture;
class VTKPVVTKEXTENSIONSRENDERING_EXPORT vtkTexturePainter : public vtkPainter
{
public:
static vtkTexturePainter* New();
vtkTypeMacro(vtkTexturePainter, vtkPainter);
void PrintSelf(ostream& os, vtkIndent indent);
/**
* Specify the X, Y or Z slice to use. The slice mode dictates how the data is
* slicde.
*/
static vtkInformationIntegerKey* SLICE();
/**
* Specify how the slices are obtained.
*/
static vtkInformationIntegerKey* SLICE_MODE();
/**
* Turn on/off the mapping of color scalars through the lookup table.
* The default is Off. If Off, unsigned char scalars will be used
* directly as texture. If On, scalars will be mapped through the
* lookup table to generate 4-component unsigned char scalars.
* This ivar does not affect other scalars like unsigned short, float,
* etc. These scalars are always mapped through lookup tables.
* Look at vtkTexture::SetColorMode for more details.
*/
static vtkInformationIntegerKey* MAP_SCALARS();
/**
* Set the lookuptable to use for scalar mapping. If none is specified and the
* scalars are not unsigned char scalars, then a default lookup table will be
* created and used.
*/
static vtkInformationObjectBaseKey* LOOKUP_TABLE();
//@{
/**
* Determines the whether the scalars are to be obtained from point data or
* cell data.
* Look at the documentation for ScalarMode in vtkMapper for the different
* possible values and their effect.
*/
static vtkInformationIntegerKey* SCALAR_MODE();
vtkSetMacro(ScalarMode, int);
vtkGetMacro(ScalarMode, int);
//@}
//@{
/**
* These three keys help identify the scalar array. If SCALAR_ARRAY_NAME is
* absent or NULL, SCALAR_ARRAY_INDEX is used.
* NOTE: We are deliberately not adding support to select a component to color
* with. That is now a property of the lookup table and ideally must be set on
* the lookup table.
*/
static vtkInformationStringKey* SCALAR_ARRAY_NAME();
vtkSetStringMacro(ScalarArrayName);
vtkGetStringMacro(ScalarArrayName);
//@}
//@{
/**
* Sepecify the index of the array to color with when scalar array name is
* absent or null.
*/
static vtkInformationIntegerKey* SCALAR_ARRAY_INDEX();
vtkSetMacro(ScalarArrayIndex, int);
vtkGetMacro(ScalarArrayIndex, int);
//@}
//@{
/**
* Get/Set the Slice that needs to be rendering. This is applicable for 3D
* images. If the Slice number is not valid, then the 0th slice is