Detailed Description

Creates lines that stand on top of the image with the length of the corresponding first sub-pixel value (the grey or red value). The maximum height is 0.1 * longest image dimension. Used by VtkCompositeImageDataToCylindersFilter.

Definition at line 27 of file VtkImageDataToLinePolyDataFilter.h.

#include <VtkImageDataToLinePolyDataFilter.h>

Inheritance diagram for VtkImageDataToLinePolyDataFilter:

[legend]

Collaboration diagram for VtkImageDataToLinePolyDataFilter:

[legend]

Public Member Functions
	vtkTypeMacro (VtkImageDataToLinePolyDataFilter, vtkPolyDataAlgorithm)

void	PrintSelf (ostream &os, vtkIndent indent) override
	Prints information about itself.

	ogsUserPropertyMacro (LengthScaleFactor, double)
	Sets the scaling of the length of the lines.

void	SetUserProperty (QString name, QVariant value) override
	Sets a user property.

	vtkGetMacro (ImageSpacing, double)
	Returns the space between two pixels.

	VtkImageDataToLinePolyDataFilter (const VtkImageDataToLinePolyDataFilter &)=delete

void	operator= (const VtkImageDataToLinePolyDataFilter &)=delete

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 VtkImageDataToLinePolyDataFilter *	New ()
	Create new objects with New() because of VTKs reference counting.

Protected Member Functions
	VtkImageDataToLinePolyDataFilter ()
	Constructor.

	~VtkImageDataToLinePolyDataFilter () override
	Destructor.

int	FillInputPortInformation (int port, vtkInformation *info) override
	Sets input port to vtkImageData.

int	RequestData (vtkInformation request, vtkInformationVector inputVector, vtkInformationVector outputVector) override
	Converts the image data to lines.

Protected Attributes
double	ImageSpacing {0.0}
	The spacing of the image.

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

Additional Inherited Members
Signals inherited from VtkAlgorithmProperties
void	ScalarVisibilityChanged (bool on)

Constructor & Destructor Documentation

◆ VtkImageDataToLinePolyDataFilter() [1/2]

VtkImageDataToLinePolyDataFilter::VtkImageDataToLinePolyDataFilter ( const VtkImageDataToLinePolyDataFilter & )

delete

◆ VtkImageDataToLinePolyDataFilter() [2/2]

VtkImageDataToLinePolyDataFilter::VtkImageDataToLinePolyDataFilter ( )

protected

Constructor.

Definition at line 29 of file VtkImageDataToLinePolyDataFilter.cpp.

31{

32 this->SetLengthScaleFactor(1.0);

33}

◆ ~VtkImageDataToLinePolyDataFilter()

VtkImageDataToLinePolyDataFilter::~VtkImageDataToLinePolyDataFilter ( )

overrideprotecteddefault

Destructor.

Member Function Documentation

◆ FillInputPortInformation()

int VtkImageDataToLinePolyDataFilter::FillInputPortInformation	(	int	port,
		vtkInformation *	info )

overrideprotected

Sets input port to vtkImageData.

Definition at line 43 of file VtkImageDataToLinePolyDataFilter.cpp.

45{

46 info->Set(vtkAlgorithm::INPUT_REQUIRED_DATA_TYPE(), "vtkImageData");

47 return 1;

48}

◆ New()

static VtkImageDataToLinePolyDataFilter * VtkImageDataToLinePolyDataFilter::New ( )

static

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

Referenced by VtkFilterFactory::CreateSimpleFilter(), and VtkCompositeImageToCylindersFilter::init().

◆ ogsUserPropertyMacro()

VtkImageDataToLinePolyDataFilter::ogsUserPropertyMacro	(	LengthScaleFactor	,
		double	)

Sets the scaling of the length of the lines.

◆ operator=()

void VtkImageDataToLinePolyDataFilter::operator= ( const VtkImageDataToLinePolyDataFilter & )

delete

◆ PrintSelf()

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

override

Prints information about itself.

Definition at line 37 of file VtkImageDataToLinePolyDataFilter.cpp.

38{

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

40 os << indent << "LengthScaleFactor: " << this->LengthScaleFactor << "\n";

41}

◆ RequestData()

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

overrideprotected

Converts the image data to lines.

Definition at line 50 of file VtkImageDataToLinePolyDataFilter.cpp.

{
    vtkDebugMacro(<< "Executing VtkImageDataToPolyDataFilter");
 
    vtkInformation* inInfo = inputVector[0]->GetInformationObject(0);
    vtkInformation* outInfo = outputVector->GetInformationObject(0);
    vtkImageData* input =
        vtkImageData::SafeDownCast(inInfo->Get(vtkDataObject::DATA_OBJECT()));
    vtkPolyData* output =
        vtkPolyData::SafeDownCast(outInfo->Get(vtkDataObject::DATA_OBJECT()));
 
    void* inScalarPtr = input->GetScalarPointer();
    int numScalarComponents = input->GetNumberOfScalarComponents();
 
    double spacing[3];
    input->GetSpacing(spacing);
    this->ImageSpacing = spacing[0];
 
    int dimensions[3];
    input->GetDimensions(dimensions);
 
    // Skip execution if there are no points
    vtkIdType numPts = input->GetNumberOfPoints();
    if (numPts < 1)
    {
        vtkDebugMacro("No data to extract lines!");
        return 1;
    }
 
    // Allocate the space needed for the output cells.
    output->Allocate(numPts);
 
    // Allocate space for a new set of points
    vtkSmartPointer<vtkPoints> newPts = vtkSmartPointer<vtkPoints>::New();
    newPts->SetNumberOfPoints(numPts * 2);
 
    // Allocate space for the data associated with the new set of points
    vtkPointData* inPD = input->GetPointData();
    vtkPointData* outPD = output->GetPointData();
    outPD->CopyAllocate(inPD, numPts * 16, numPts);
 
    // Compute scaling factor that max height is 0.1 * longest image dimension
    double range[2];
    inPD->GetArray(0)->GetRange(range);
    double const scalingFactor =
        (std::max(dimensions[0], dimensions[1]) * spacing[0] * 0.1) /
        std::max(range[0], range[1]);
 
    double dir[3] = {0, 0, 1};
 
    // Traverse all points creating another point with scalar distance in Z
    // direction
    for (vtkIdType ptId = 0; ptId < numPts; ++ptId)
    {
        // Skip translucent pixels
        float opacity =
            (static_cast<float*>(inScalarPtr))[ptId * numScalarComponents + 1];
        if (opacity < 0.00000001f)
        {
            continue;
        }
 
        // Compute length of the new line (scalar * LengthScaleFactor)
        double const length =
            (static_cast<float*>(inScalarPtr))[ptId * numScalarComponents] *
            scalingFactor * this->LengthScaleFactor;
 
        // Skip this line if length is zero
        if (length < 0.00000001f)
        {
            continue;
        }
 
        // Get the old point location
        double p[3];
        input->GetPoint(ptId, p);
 
        // Compute the new point location
        double newPt[3];
        for (std::size_t i = 0; i < 3; ++i)
        {
            newPt[i] = p[i] + dir[i] * length;
        }
 
        // Copy the old point
        newPts->SetPoint(ptId * 2, p);
        outPD->CopyData(inPD, ptId, ptId * 2);
 
        // Create the new point
        newPts->SetPoint(ptId * 2 + 1, newPt);
        outPD->CopyData(inPD, ptId, ptId * 2 + 1);
 
        // Create the line
        vtkSmartPointer<vtkLine> line = vtkSmartPointer<vtkLine>::New();
        line->GetPointIds()->SetId(0, ptId * 2);
        line->GetPointIds()->SetId(1, ptId * 2 + 1);
        output->InsertNextCell(line->GetCellType(), line->GetPointIds());
    }
 
    // Store the new set of points in the output
    output->SetPoints(newPts);
    output->GetPointData()->GetArray(0)->SetName("Colors");
 
    // Avoid keeping extra memory around
    output->Squeeze();
 
    vtkDebugMacro(<< "Created: " << newPts->GetNumberOfPoints() << " points, "
                  << output->GetNumberOfCells() << " lines");
 
    return 1;
}