Detailed Description

A VTK Filter that will create a point cloud with local densities based on pixel values.

Definition at line 16 of file VtkImageDataToPointCloudFilter.h.

#include <VtkImageDataToPointCloudFilter.h>

Inheritance diagram for VtkImageDataToPointCloudFilter:

Collaboration diagram for VtkImageDataToPointCloudFilter:

Public Member Functions
	vtkTypeMacro (VtkImageDataToPointCloudFilter, vtkPolyDataAlgorithm)
void	PrintSelf (ostream &os, vtkIndent indent) override
	Prints information about the filter.
void	useLinearInterpolation ()
void	useLogarithmicInterpolation (double gamma)
	vtkGetMacro (IsLinear, bool)
	vtkSetMacro (IsLinear, bool)
	vtkGetMacro (MinNumberOfPointsPerCell, vtkIdType)
	vtkSetMacro (MinNumberOfPointsPerCell, vtkIdType)
	vtkGetMacro (MaxNumberOfPointsPerCell, vtkIdType)
	vtkSetMacro (MaxNumberOfPointsPerCell, vtkIdType)
	vtkGetMacro (Gamma, double)
	vtkSetMacro (Gamma, double)
	vtkGetMacro (PointScaleFactor, double)
	vtkSetMacro (PointScaleFactor, double)
	vtkGetMacro (MinValueRange, double)
	vtkSetMacro (MinValueRange, double)
	vtkGetMacro (MaxValueRange, double)
	vtkSetMacro (MaxValueRange, double)
	vtkGetMacro (MinHeight, double)
	vtkSetMacro (MinHeight, double)
	vtkGetMacro (MaxHeight, double)
	vtkSetMacro (MaxHeight, double)

Static Public Member Functions
static VtkImageDataToPointCloudFilter *	New ()
	Create a new objects (required because of VTKs reference counting)

Protected Member Functions
	VtkImageDataToPointCloudFilter ()
	~VtkImageDataToPointCloudFilter () override=default
int	FillInputPortInformation (int port, vtkInformation *info) override
	Sets input port to vtkImageData.
int	RequestData (vtkInformation request, vtkInformationVector inputVector, vtkInformationVector outputVector) override
	Updates the graphical object.

Protected Attributes
double	Gamma {1.0}
double	PointScaleFactor {1.0}
double	MinValueRange {-1}
double	MaxValueRange {-1}
double	MinHeight {0}
double	MaxHeight {1000}
vtkIdType	MinNumberOfPointsPerCell {1}
vtkIdType	MaxNumberOfPointsPerCell {20}
bool	IsLinear {true}

Private Member Functions
void	createPoints (vtkSmartPointer< vtkPoints > &points, vtkSmartPointer< vtkCellArray > &cells, std::size_t pnt_idx, std::size_t n_points, MathLib::Point3d const &min_pnt, MathLib::Point3d const &max_pnt) const
	Creates the point objects based on the parameters set by the user.
double	getRandomNumber (double const &min, double const &max) const
	Returns a random number in [min, max].
std::size_t	interpolate (double low, double high, double p, double gamma) const

Constructor & Destructor Documentation

◆ VtkImageDataToPointCloudFilter()

VtkImageDataToPointCloudFilter::VtkImageDataToPointCloudFilter ( )

protecteddefault

Referenced by New(), and vtkTypeMacro().

◆ ~VtkImageDataToPointCloudFilter()

VtkImageDataToPointCloudFilter::~VtkImageDataToPointCloudFilter ( )

overrideprotecteddefault

Member Function Documentation

◆ createPoints()

void VtkImageDataToPointCloudFilter::createPoints	(	vtkSmartPointer< vtkPoints > &	points,
		vtkSmartPointer< vtkCellArray > &	cells,
		std::size_t	pnt_idx,
		std::size_t	n_points,
		MathLib::Point3d const &	min_pnt,
		MathLib::Point3d const &	max_pnt ) const

private

Creates the point objects based on the parameters set by the user.

Definition at line 156 of file VtkImageDataToPointCloudFilter.cpp.

{
    for (std::size_t i = 0; i < n_points; ++i)
    {
        double p[3];
        p[0] = getRandomNumber(min_pnt[0], max_pnt[0]);
        p[1] = getRandomNumber(min_pnt[1], max_pnt[1]);
        p[2] = getRandomNumber(min_pnt[2], max_pnt[2]);
        points->SetPoint(pnt_idx + i, p);
        cells->InsertNextCell(1);
        cells->InsertCellPoint(pnt_idx + i);
    }
}

References getRandomNumber().

Referenced by RequestData().

◆ FillInputPortInformation()

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

overrideprotected

Sets input port to vtkImageData.

Definition at line 30 of file VtkImageDataToPointCloudFilter.cpp.

{
    info->Set(vtkAlgorithm::INPUT_REQUIRED_DATA_TYPE(), "vtkImageData");
    return 1;
}

◆ getRandomNumber()

double VtkImageDataToPointCloudFilter::getRandomNumber	(	double const &	min,
		double const &	max ) const

private

Returns a random number in [min, max].

Definition at line 176 of file VtkImageDataToPointCloudFilter.cpp.

{
    return (static_cast<double>(std::rand()) / RAND_MAX) * (max - min) + min;
}

Referenced by createPoints().

◆ interpolate()

std::size_t VtkImageDataToPointCloudFilter::interpolate	(	double	low,
		double	high,
		double	p,
		double	gamma ) const

private

Interpolates the required number of points. Using gamma = 1 this is a linear interpolation, for values smaller/greater than 1 the curve becomes logarithmic/exponential, resulting in a smaller/larger difference of point densities given the same input values.

Definition at line 182 of file VtkImageDataToPointCloudFilter.cpp.

{
    p = std::clamp(p, low, high);
    double const r = (p - low) / (high - low);
    return static_cast<std::size_t>(
        (MaxNumberOfPointsPerCell - MinNumberOfPointsPerCell) *
            std::pow(r, gamma) +
        MinNumberOfPointsPerCell);
}

References MaxNumberOfPointsPerCell, and MinNumberOfPointsPerCell.

Referenced by RequestData().

◆ New()

VtkImageDataToPointCloudFilter * VtkImageDataToPointCloudFilter::New ( )

static

Create a new objects (required because of VTKs reference counting)

References VtkImageDataToPointCloudFilter().

Referenced by VtkCompositeImageToPointCloudFilter::init(), and main().

◆ PrintSelf()

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

override

Prints information about the filter.

Definition at line 25 of file VtkImageDataToPointCloudFilter.cpp.

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

◆ RequestData()

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

overrideprotected

Updates the graphical object.

Definition at line 37 of file VtkImageDataToPointCloudFilter.cpp.

{
    vtkDebugMacro(<< "Executing VtkImageDataToPointCloudFilter");
 
    vtkInformation* input_info = inputVector[0]->GetInformationObject(0);
    vtkInformation* output_info = outputVector->GetInformationObject(0);
    vtkImageData* input = vtkImageData::SafeDownCast(
        input_info->Get(vtkDataObject::DATA_OBJECT()));
    vtkPolyData* output = vtkPolyData::SafeDownCast(
        output_info->Get(vtkDataObject::DATA_OBJECT()));
 
    if (input->GetScalarSize() != sizeof(float))
    {
        vtkDebugMacro(
            "Existing data does not have float-type and cannot be processed. "
            "Aborting filter process...");
        return 0;
    }
    float* pixvals = static_cast<float*>(input->GetScalarPointer());
    int const n_comp = input->GetNumberOfScalarComponents();
    if (n_comp < 1)
    {
        vtkDebugMacro("Error reading number of components.");
    }
    if (n_comp > 2)
    {
        vtkDebugMacro(
            "RGB colours detected. Using only first channel for computation.");
    }
 
    vtkIdType const n_points = input->GetNumberOfPoints();
    if (n_points == 0)
    {
        vtkDebugMacro("No data found!");
        return -1;
    }
 
    double spacing[3];
    input->GetSpacing(spacing);
 
    if (MinValueRange == -1 || MaxValueRange == -1)
    {
        double range[2];
        vtkPointData* input_data = input->GetPointData();
        input_data->GetArray(0)->GetRange(range);
        MinValueRange = range[0];
        MaxValueRange = range[1];
    }
 
    std::vector<vtkIdType> density;
    density.reserve(n_points);
    for (vtkIdType i = 0; i < n_points; ++i)
    {
        // Skip transparent pixels
        if (n_comp == 2 || n_comp == 4)
        {
            if (pixvals[(i + 1) * n_comp - 1] < 0.00000001f)
            {
                density.push_back(0);
                continue;
            }
        }
        double const val(pixvals[i * n_comp]);
        double const calc_gamma = (IsLinear) ? 1 : Gamma;
        std::size_t const pnts_per_cell =
            interpolate(MinValueRange, MaxValueRange, val, calc_gamma);
        density.push_back(static_cast<vtkIdType>(
            std::floor(pnts_per_cell * GetPointScaleFactor())));
    }
 
    // Allocate the space needed for output objects
    auto const sum =
        std::accumulate(density.begin(), density.end(), vtkIdType{0});
    vtkSmartPointer<vtkPoints> new_points = vtkSmartPointer<vtkPoints>::New();
    new_points->SetNumberOfPoints(sum);
    vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
    cells->Allocate(sum);
    vtkSmartPointer<vtkDoubleArray> intensity =
        vtkSmartPointer<vtkDoubleArray>::New();
    intensity->Allocate(sum);
    intensity->SetName("Intensity");
    double const half_cellsize(spacing[0] / 2.0);
    std::size_t pnt_idx(0);
    for (std::size_t i = 0; i < static_cast<std::size_t>(n_points); ++i)
    {
        if (density[i] == 0)
        {
            continue;
        }
        double p[3];
        input->GetPoint(i, p);
 
        MathLib::Point3d min_pnt{std::array<double, 3>{
            {p[0] - half_cellsize, p[1] - half_cellsize, MinHeight}}};
        MathLib::Point3d max_pnt{std::array<double, 3>{
            {p[0] + half_cellsize, p[1] + half_cellsize, MaxHeight}}};
        createPoints(new_points, cells, pnt_idx, density[i], min_pnt, max_pnt);
        for (vtkIdType j = 0; j < density[i]; ++j)
        {
            intensity->InsertValue(pnt_idx + j, pixvals[i * n_comp]);
        }
        pnt_idx += density[i];
    }
 
    output->SetPoints(new_points);
    output->SetVerts(cells);
    output->GetPointData()->AddArray(intensity);
    output->GetPointData()->SetActiveAttribute("Intensity",
                                               vtkDataSetAttributes::SCALARS);
    output->Squeeze();
 
    vtkDebugMacro(<< "Created " << new_points->GetNumberOfPoints()
                  << " points.");
    return 1;
}

References createPoints(), Gamma, interpolate(), IsLinear, MaxHeight, MaxValueRange, MinHeight, and MinValueRange.

◆ useLinearInterpolation()

void VtkImageDataToPointCloudFilter::useLinearInterpolation ( )

inline

Definition at line 27 of file VtkImageDataToPointCloudFilter.h.

27{ SetIsLinear(true); }

◆ useLogarithmicInterpolation()

void VtkImageDataToPointCloudFilter::useLogarithmicInterpolation ( double gamma )

inline

Definition at line 28 of file VtkImageDataToPointCloudFilter.h.

    {
        SetIsLinear(false);
        SetGamma(gamma);
    }

◆ vtkGetMacro() [1/9]

VtkImageDataToPointCloudFilter::vtkGetMacro	(	Gamma	,
		double	)

References Gamma.

◆ vtkGetMacro() [2/9]

VtkImageDataToPointCloudFilter::vtkGetMacro	(	IsLinear	,
		bool	)

References IsLinear.

◆ vtkGetMacro() [3/9]

VtkImageDataToPointCloudFilter::vtkGetMacro	(	MaxHeight	,
		double	)

References MaxHeight.

◆ vtkGetMacro() [4/9]

VtkImageDataToPointCloudFilter::vtkGetMacro	(	MaxNumberOfPointsPerCell	,
		vtkIdType	)

References MaxNumberOfPointsPerCell.

◆ vtkGetMacro() [5/9]

VtkImageDataToPointCloudFilter::vtkGetMacro	(	MaxValueRange	,
		double	)

References MaxValueRange.

◆ vtkGetMacro() [6/9]

VtkImageDataToPointCloudFilter::vtkGetMacro	(	MinHeight	,
		double	)

References MinHeight.

◆ vtkGetMacro() [7/9]

VtkImageDataToPointCloudFilter::vtkGetMacro	(	MinNumberOfPointsPerCell	,
		vtkIdType	)

References MinNumberOfPointsPerCell.

◆ vtkGetMacro() [8/9]

VtkImageDataToPointCloudFilter::vtkGetMacro	(	MinValueRange	,
		double	)

References MinValueRange.

◆ vtkGetMacro() [9/9]

VtkImageDataToPointCloudFilter::vtkGetMacro	(	PointScaleFactor	,
		double	)

References PointScaleFactor.

◆ vtkSetMacro() [1/9]

VtkImageDataToPointCloudFilter::vtkSetMacro	(	Gamma	,
		double	)

References Gamma.

◆ vtkSetMacro() [2/9]

VtkImageDataToPointCloudFilter::vtkSetMacro	(	IsLinear	,
		bool	)

References IsLinear.

◆ vtkSetMacro() [3/9]

VtkImageDataToPointCloudFilter::vtkSetMacro	(	MaxHeight	,
		double	)

References MaxHeight.

◆ vtkSetMacro() [4/9]

VtkImageDataToPointCloudFilter::vtkSetMacro	(	MaxNumberOfPointsPerCell	,
		vtkIdType	)

References MaxNumberOfPointsPerCell.

◆ vtkSetMacro() [5/9]

VtkImageDataToPointCloudFilter::vtkSetMacro	(	MaxValueRange	,
		double	)

References MaxValueRange.

◆ vtkSetMacro() [6/9]

VtkImageDataToPointCloudFilter::vtkSetMacro	(	MinHeight	,
		double	)

References MinHeight.

◆ vtkSetMacro() [7/9]

VtkImageDataToPointCloudFilter::vtkSetMacro	(	MinNumberOfPointsPerCell	,
		vtkIdType	)

References MinNumberOfPointsPerCell.

◆ vtkSetMacro() [8/9]

VtkImageDataToPointCloudFilter::vtkSetMacro	(	MinValueRange	,
		double	)

References MinValueRange.

◆ vtkSetMacro() [9/9]

VtkImageDataToPointCloudFilter::vtkSetMacro	(	PointScaleFactor	,
		double	)

References PointScaleFactor.

◆ vtkTypeMacro()

VtkImageDataToPointCloudFilter::vtkTypeMacro	(	VtkImageDataToPointCloudFilter	,
		vtkPolyDataAlgorithm	)

References VtkImageDataToPointCloudFilter().

Member Data Documentation

◆ Gamma

double VtkImageDataToPointCloudFilter::Gamma {1.0}

protected

Definition at line 72 of file VtkImageDataToPointCloudFilter.h.

72{1.0};

Referenced by RequestData(), vtkGetMacro(), and vtkSetMacro().

◆ IsLinear

bool VtkImageDataToPointCloudFilter::IsLinear {true}

protected

Definition at line 80 of file VtkImageDataToPointCloudFilter.h.

80{true};

Referenced by RequestData(), vtkGetMacro(), and vtkSetMacro().

◆ MaxHeight

double VtkImageDataToPointCloudFilter::MaxHeight {1000}

protected

Definition at line 77 of file VtkImageDataToPointCloudFilter.h.

77{1000};

Referenced by RequestData(), vtkGetMacro(), and vtkSetMacro().

◆ MaxNumberOfPointsPerCell

vtkIdType VtkImageDataToPointCloudFilter::MaxNumberOfPointsPerCell {20}

protected

Definition at line 79 of file VtkImageDataToPointCloudFilter.h.

79{20};

Referenced by interpolate(), vtkGetMacro(), and vtkSetMacro().

◆ MaxValueRange

double VtkImageDataToPointCloudFilter::MaxValueRange {-1}

protected

Definition at line 75 of file VtkImageDataToPointCloudFilter.h.

75{-1};

Referenced by RequestData(), vtkGetMacro(), and vtkSetMacro().

◆ MinHeight

double VtkImageDataToPointCloudFilter::MinHeight {0}

protected

Definition at line 76 of file VtkImageDataToPointCloudFilter.h.

76{0};

Referenced by RequestData(), vtkGetMacro(), and vtkSetMacro().

◆ MinNumberOfPointsPerCell

vtkIdType VtkImageDataToPointCloudFilter::MinNumberOfPointsPerCell {1}

protected

Definition at line 78 of file VtkImageDataToPointCloudFilter.h.

78{1};

Referenced by interpolate(), vtkGetMacro(), and vtkSetMacro().

◆ MinValueRange

double VtkImageDataToPointCloudFilter::MinValueRange {-1}

protected

Definition at line 74 of file VtkImageDataToPointCloudFilter.h.

74{-1};

Referenced by RequestData(), vtkGetMacro(), and vtkSetMacro().

◆ PointScaleFactor

double VtkImageDataToPointCloudFilter::PointScaleFactor {1.0}

protected

Definition at line 73 of file VtkImageDataToPointCloudFilter.h.

73{1.0};

Referenced by vtkGetMacro(), and vtkSetMacro().

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

Detailed Description

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Constructor & Destructor Documentation

◆ VtkImageDataToPointCloudFilter()

◆ ~VtkImageDataToPointCloudFilter()

Member Function Documentation

◆ createPoints()

◆ FillInputPortInformation()

◆ getRandomNumber()

◆ interpolate()

◆ New()

◆ PrintSelf()

◆ RequestData()

◆ useLinearInterpolation()

◆ useLogarithmicInterpolation()

◆ vtkGetMacro() [1/9]

◆ vtkGetMacro() [2/9]

◆ vtkGetMacro() [3/9]

◆ vtkGetMacro() [4/9]

◆ vtkGetMacro() [5/9]

◆ vtkGetMacro() [6/9]

◆ vtkGetMacro() [7/9]

◆ vtkGetMacro() [8/9]

◆ vtkGetMacro() [9/9]

◆ vtkSetMacro() [1/9]

◆ vtkSetMacro() [2/9]

◆ vtkSetMacro() [3/9]

◆ vtkSetMacro() [4/9]

◆ vtkSetMacro() [5/9]

◆ vtkSetMacro() [6/9]

◆ vtkSetMacro() [7/9]

◆ vtkSetMacro() [8/9]

◆ vtkSetMacro() [9/9]

◆ vtkTypeMacro()

Member Data Documentation

◆ Gamma

◆ IsLinear

◆ MaxHeight

◆ MaxNumberOfPointsPerCell

◆ MaxValueRange

◆ MinHeight

◆ MinNumberOfPointsPerCell

◆ MinValueRange

◆ PointScaleFactor