VtkTextureOnSurfaceFilter Class Reference

Detailed Description

Filter class for assigning a texture to a surface.

Use SetRaster() to define the texture that should be mapped on the object. The input of this class is a vtkPolyData object. It is important to call SetTexture() before calling SetInputConnection(). Texture coordinates will then be calculated automatically and the texture will also be saved in the VtkAlgorithmProperties object from which this class is derived (i.e. the texture can be returned by VtkAlgorithmProperties::GetTexture()).

For convenience this class also has a converter function ConvertImageToTexture() which uses a QImage as input.

Definition at line 37 of file VtkTextureOnSurfaceFilter.h.

#include <VtkTextureOnSurfaceFilter.h>

Inheritance diagram for VtkTextureOnSurfaceFilter:

Collaboration diagram for VtkTextureOnSurfaceFilter:

Public Member Functions
	vtkTypeMacro (VtkTextureOnSurfaceFilter, vtkPolyDataAlgorithm)
void	PrintSelf (ostream &os, vtkIndent indent) override
	Prints the object data to an output stream.
void	SetRaster (vtkImageAlgorithm *img)
	Sets the raster/image to be used as a texture map.
void	SetUserProperty (QString name, QVariant value) override
	Sets a user property. This should be implemented by subclasses.
Public Member Functions inherited from VtkAlgorithmProperties
	VtkAlgorithmProperties (QObject *parent=nullptr)
	Constructor (sets default values)
	~VtkAlgorithmProperties () override
vtkProperty *	GetProperties () const
	Returns the vtk properties.
vtkTexture *	GetTexture ()
	Returns a texture (if one has been assigned).
void	SetTexture (vtkTexture *t)
	Sets a texture for the VtkVisPipelineItem.
vtkLookupTable *	GetLookupTable (const QString &array_name)
	Returns the colour lookup table (if one has been assigned).
void	RemoveLookupTable (const QString &array_name)
	Removes the lookup table for the given scalar.
void	SetLookUpTable (const QString &array_name, vtkLookupTable *lut)
	Sets a colour lookup table for the given scalar array of the VtkVisPipelineItem.
void	SetLookUpTable (const QString &array_name, const QString &filename)
	Loads a predefined color lookup table from a file for the specified scalar array.
bool	GetScalarVisibility () const
	Returns the scalar visibility.
void	SetScalarVisibility (bool on)
	Sets the scalar visibility.
QString	GetName () const
	Returns the name. This is set to the file path if it is a source algorithm.
void	SetName (QString name)
	Sets the name.
bool	IsRemovable () const
	Is this algorithm removable from the pipeline (view).
QMap< QString, QVariant > *	GetAlgorithmUserProperties () const
	Returns a map of user properties.
QMap< QString, QList< QVariant > > *	GetAlgorithmUserVectorProperties () const
	Returns a map of vector user properties.
QVariant	GetUserProperty (QString name) const
	Returns the value of a user property.
virtual void	SetUserVectorProperty (QString name, QList< QVariant > values)
	Sets a vector user property. This should be implemented by subclasses.
QList< QVariant >	GetUserVectorProperty (QString name) const
	Returns a list of values of a vector user property.
void	SetActiveAttribute (QString name)
	Set the active attribute.
QString	GetActiveAttribute () const
	Returns the desired active attribute.

Static Public Member Functions
static VtkTextureOnSurfaceFilter *	New ()
	Create new objects with New() because of VTKs object reference counting.

Protected Member Functions
	VtkTextureOnSurfaceFilter ()
	~VtkTextureOnSurfaceFilter () override
int	RequestData (vtkInformation *request, vtkInformationVector **inputVector, vtkInformationVector *outputVector) override

Private Attributes
std::pair< double, double >	_origin {0, 0}
double	_scalingFactor {0.}

Additional Inherited Members
Signals inherited from VtkAlgorithmProperties
void	ScalarVisibilityChanged (bool on)
Protected Attributes inherited from VtkAlgorithmProperties
vtkProperty *	_property
vtkTexture *	_texture
bool	_scalarVisibility
std::map< QString, vtkLookupTable * >	_lut
QString	_name
QString	_activeAttributeName
bool	_removable
QMap< QString, QVariant > *	_algorithmUserProperties
QMap< QString, QList< QVariant > > *	_algorithmUserVectorProperties

Constructor & Destructor Documentation

VtkTextureOnSurfaceFilter()

VtkTextureOnSurfaceFilter::VtkTextureOnSurfaceFilter ( )

protecteddefault

~VtkTextureOnSurfaceFilter()

VtkTextureOnSurfaceFilter::~VtkTextureOnSurfaceFilter ( )

overrideprotecteddefault

Member Function Documentation

New()

static VtkTextureOnSurfaceFilter * VtkTextureOnSurfaceFilter::New ( )

static

Create new objects with New() because of VTKs object reference counting.

Referenced by VtkCompositeTextureOnSurfaceFilter::init().

PrintSelf()

void VtkTextureOnSurfaceFilter::PrintSelf ( ostream & os, vtkIndent indent )

override

Prints the object data to an output stream.

Definition at line 40 of file VtkTextureOnSurfaceFilter.cpp.

{
    this->Superclass::PrintSelf(os, indent);
}

RequestData()

int VtkTextureOnSurfaceFilter::RequestData ( vtkInformation * request, vtkInformationVector ** inputVector, vtkInformationVector * outputVector )

overrideprotected

Copies the input data and calculates texture coordinates (this requires that SetRaster() has been called before this method is executed.

Definition at line 45 of file VtkTextureOnSurfaceFilter.cpp.

{
    (void)request;
 
    if (this->GetTexture() == nullptr)
    {
        ERR("VtkTextureOnSurfaceFilter::RequestData() - No texture specified.");
        return 0;
    }
 
    vtkInformation* inInfo = inputVector[0]->GetInformationObject(0);
    vtkPolyData* input =
        vtkPolyData::SafeDownCast(inInfo->Get(vtkDataObject::DATA_OBJECT()));
 
    int dims[3];
    this->GetTexture()->GetInput()->GetDimensions(dims);
    std::size_t imgWidth = dims[0];
    std::size_t imgHeight = dims[1];
 
    std::pair<int, int> min(static_cast<int>(_origin.first),
                            static_cast<int>(_origin.second));
    std::pair<int, int> max(
        static_cast<int>(_origin.first + (imgWidth * _scalingFactor)),
        static_cast<int>(_origin.second + (imgHeight * _scalingFactor)));
 
    // calculate texture coordinates
    vtkPoints* points = input->GetPoints();
    vtkSmartPointer<vtkFloatArray> textureCoordinates =
        vtkSmartPointer<vtkFloatArray>::New();
    textureCoordinates->SetNumberOfComponents(2);
    std::size_t nPoints = points->GetNumberOfPoints();
    textureCoordinates->SetNumberOfTuples(nPoints);
    textureCoordinates->SetName("textureCoords");
    /*  // adaptation for netcdf-curtain for TERENO Demo
        double dist(0.0);
        for (std::size_t i = 0; i < nPoints; i++)
        {
            double coords[3];
            if ((i==0) || (i==173))
            {
                if (i==0) dist=0;
            }
            else
            {
                points->GetPoint(i-1, coords);
                GeoLib::Point* pnt = new GeoLib::Point(coords);
                points->GetPoint(i, coords);
                GeoLib::Point* pnt2 = new GeoLib::Point(coords);
                if (i<173)
                    dist += std::sqrt(MathLib::sqrDist(pnt, pnt2));
                else
                    dist -= std::sqrt(MathLib::sqrDist(pnt, pnt2));
            }
            points->GetPoint(i, coords);
            double x = MathLib::normalize(0, 8404, dist);
            double z = MathLib::normalize(-79.5, 1.5, coords[2]);
            float newcoords[2] = {x, z};
            textureCoordinates->InsertNextTuple(newcoords);
        }
    */
 
    int const range[2] = {max.first - min.first, max.second - min.second};
    // Scale values relative to the range.
 
    double coords[3];
    for (std::size_t i = 0; i < nPoints; i++)
    {
        points->GetPoint(i, coords);
 
        textureCoordinates->SetTuple2(i,
                                      (coords[0] - min.first) / range[0],
                                      (coords[1] - min.second) / range[1]);
    }
 
    // put it all together
    vtkInformation* outInfo = outputVector->GetInformationObject(0);
    vtkPolyData* output =
        vtkPolyData::SafeDownCast(outInfo->Get(vtkDataObject::DATA_OBJECT()));
    output->CopyStructure(input);
    output->GetPointData()->PassData(input->GetPointData());
    output->GetCellData()->PassData(input->GetCellData());
    output->GetPointData()->SetTCoords(textureCoordinates);
    output->Squeeze();
 
    return 1;
}

References _origin, _scalingFactor, ERR(), and VtkAlgorithmProperties::GetTexture().

SetRaster()

void VtkTextureOnSurfaceFilter::SetRaster

(

vtkImageAlgorithm *

img

)

Sets the raster/image to be used as a texture map.

Definition at line 134 of file VtkTextureOnSurfaceFilter.cpp.

{
    double range[2];
    img->Update();
    img->GetOutput()->GetPointData()->GetScalars()->GetRange(range);
    vtkSmartPointer<vtkImageShiftScale> scale =
        vtkSmartPointer<vtkImageShiftScale>::New();
    scale->SetInputConnection(img->GetOutputPort());
    scale->SetShift(-range[0]);
    scale->SetScale(255.0 / (range[1] - range[0]));
    scale->SetOutputScalarTypeToUnsignedChar();  // Comment this out to get
                                                 // colored grayscale textures
    scale->Update();
 
    vtkTexture* texture = vtkTexture::New();
    texture->InterpolateOff();
    texture->RepeatOff();
    // texture->EdgeClampOn(); // does not work
    texture->SetInputData(scale->GetOutput());
    this->SetTexture(texture);
 
    double* origin = img->GetOutput()->GetOrigin();
    _origin = {origin[0], origin[1]};
    _scalingFactor = img->GetOutput()->GetSpacing()[0];
}

References _origin, _scalingFactor, and VtkAlgorithmProperties::SetTexture().

Referenced by VtkCompositeTextureOnSurfaceFilter::init().

SetUserProperty()

void VtkTextureOnSurfaceFilter::SetUserProperty ( QString name, QVariant value )

overridevirtual

Sets a user property. This should be implemented by subclasses.

Reimplemented from VtkAlgorithmProperties.

Definition at line 160 of file VtkTextureOnSurfaceFilter.cpp.

{
    VtkAlgorithmProperties::SetUserProperty(name, value);
}

References VtkAlgorithmProperties::SetUserProperty().

vtkTypeMacro()

VtkTextureOnSurfaceFilter::vtkTypeMacro	(	VtkTextureOnSurfaceFilter	,
		vtkPolyDataAlgorithm	)

Member Data Documentation

_origin

std::pair<double, double> VtkTextureOnSurfaceFilter::_origin {0, 0}

private

Definition at line 64 of file VtkTextureOnSurfaceFilter.h.

{0, 0};

Referenced by RequestData(), and SetRaster().

_scalingFactor

double VtkTextureOnSurfaceFilter::_scalingFactor {0.}

private

Definition at line 65 of file VtkTextureOnSurfaceFilter.h.

{0.};

Referenced by RequestData(), and SetRaster().

---

The documentation for this class was generated from the following files:

• Applications/DataExplorer/VtkVis/VtkTextureOnSurfaceFilter.h
• Applications/DataExplorer/VtkVis/VtkTextureOnSurfaceFilter.cpp