VtkImageDataToPointCloudFilter.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <vtkPolyDataAlgorithm.h>
 
#include "MathLib/Point3d.h"
#include "VtkAlgorithmProperties.h"
 
class vtkInformation;
class vtkInformationVector;

class VtkImageDataToPointCloudFilter : public vtkPolyDataAlgorithm
{
public:
    static VtkImageDataToPointCloudFilter* New();
 
    vtkTypeMacro(VtkImageDataToPointCloudFilter, vtkPolyDataAlgorithm);

    void PrintSelf(ostream& os, vtkIndent indent) override;
 
    void useLinearInterpolation() { SetIsLinear(true); }
    void useLogarithmicInterpolation(double gamma)
    {
        SetIsLinear(false);
        SetGamma(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);
 
protected:
    VtkImageDataToPointCloudFilter();
    ~VtkImageDataToPointCloudFilter() override = default;

    int FillInputPortInformation(int port, vtkInformation* info) override;

    int RequestData(vtkInformation* request, vtkInformationVector** inputVector,
                    vtkInformationVector* outputVector) override;
 
    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:
    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;

    double getRandomNumber(double const& min, double const& max) const;

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