"""
This type stub file was generated by pyright.
"""

import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel

class vtkFitToHeightMapFilter(__vtkmodules_vtkCommonExecutionModel.vtkPolyDataAlgorithm):
    """
    vtkFitToHeightMapFilter - adjust polydata to fit image height map
    
    Superclass: vtkPolyDataAlgorithm
    
    vtkFitToHeightMapFilter "drapes" or "covers" a height map image by
    determining new point coordinates of an input polydata by projecting
    (in the z-direction) onto the height map. Different projection
    approaches can be used including projecting points, or averaging /
    taking the minimum / taking the maximum of the cell's points or
    sampled interior points.  The filter passes the input to the output,
    however new new point coordinates are generated, and point normals
    are not passed through. Note that the draping supports verts, lines,
    polygons, and triangle strips.
    
    @warning
    Since new point coordinates are generated, planar polygons may become
    non-planar. To guarantee planarity, use a triangle mesh as input.
    Also note that strategies based on averaging across a cell, or the
    points of a cell, set the z-value for all of the cell's points to the
    same value. However, as currently written, depending on the order in
    which cells are processed, the last z-value set is the final value
    (since points may be shared by multiple cells). Thus the filter works
    best with triangle meshes, or if cells are topologically disconnected
    (i.e., points are only used by one cell - use vtkShrinkFilter to
    topologically disconnect the cells in a mesh).
    
    @warning
    The point normals are not passed through to the output as the
    projection process may distort the projected polydata surface.
    
    @warning
    The interior cell sampling is currently carried out by triangulating
    the cells, and then taking the centroid of each resulting triangle.
    Thus the number of samples for each cell is (number of cell points -
    2). Future implementations may use a different sampling strategy.
    
    @warning
    Points outside of the height map image are clamped to the boundary of
    the height map. This may produce unexpected behavior in some cases.
    
    @warning
    This class has been threaded with vtkSMPTools. Using TBB or other
    non-sequential type (set in the CMake variable
    VTK_SMP_IMPLEMENTATION_TYPE) may improve performance significantly.
    
    @sa
    vtkTrimmedExtrusionFilter vtkShrinkFilter vtkShrinkPolyData
    """
    def GetFittingStrategy(self):
        """
        V.GetFittingStrategy() -> int
        C++: virtual int GetFittingStrategy()
        
        Specify a strategy for fitting, or projecting, the polydata to
        the height field.  By default the points of the polydata are
        projected onto the height field (POINT_PROJECTION).  However, to
        preserve planarity, or to fit the polydata cells at the
        average/minimum/maximum height to the height field, different
        strategies can be used (i.e., placing the cells). The point-based
        strategies (e.g, POINT_MINIMUM_HEIGHT) set the cell at the
        minimum height of the cell's points (and so on). The cell-based
        strategies (e.g., CELL_MINIMUM_HEIGHT) sample the interior of the
        cell and place the cell at the minimum height (and so on) of the
        cell's sampled interior points.
        """
        ...
    
    def GetHeightMap(self):
        """
        V.GetHeightMap() -> vtkImageData
        C++: vtkImageData *GetHeightMap()
        V.GetHeightMap(vtkInformationVector) -> vtkImageData
        C++: vtkImageData *GetHeightMap(vtkInformationVector *sourceInfo)
        
        Get a pointer to the height map.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Standard methods for construction, type and printing.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Standard methods for construction, type and printing.
        """
        ...
    
    def GetUseHeightMapOffset(self):
        """
        V.GetUseHeightMapOffset() -> int
        C++: virtual vtkTypeBool GetUseHeightMapOffset()
        
        Indicate whether the z-offset from the image height map should be
        added to the final result. Some height map images are offset in
        z-coordinate which is independent of the height map values. By
        default this value is true.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Standard methods for construction, type and printing.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Standard methods for construction, type and printing.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkFitToHeightMapFilter
        C++: vtkFitToHeightMapFilter *NewInstance()
        
        Standard methods for construction, type and printing.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkFitToHeightMapFilter
        C++: static vtkFitToHeightMapFilter *SafeDownCast(
            vtkObjectBase *o)
        
        Standard methods for construction, type and printing.
        """
        ...
    
    def SetFittingStrategy(self, p_int):
        """
        V.SetFittingStrategy(int)
        C++: virtual void SetFittingStrategy(int _arg)
        
        Specify a strategy for fitting, or projecting, the polydata to
        the height field.  By default the points of the polydata are
        projected onto the height field (POINT_PROJECTION).  However, to
        preserve planarity, or to fit the polydata cells at the
        average/minimum/maximum height to the height field, different
        strategies can be used (i.e., placing the cells). The point-based
        strategies (e.g, POINT_MINIMUM_HEIGHT) set the cell at the
        minimum height of the cell's points (and so on). The cell-based
        strategies (e.g., CELL_MINIMUM_HEIGHT) sample the interior of the
        cell and place the cell at the minimum height (and so on) of the
        cell's sampled interior points.
        """
        ...
    
    def SetFittingStrategyToAverageHeight(self):
        """
        V.SetFittingStrategyToAverageHeight()
        C++: void SetFittingStrategyToAverageHeight()
        
        Specify a strategy for fitting, or projecting, the polydata to
        the height field.  By default the points of the polydata are
        projected onto the height field (POINT_PROJECTION).  However, to
        preserve planarity, or to fit the polydata cells at the
        average/minimum/maximum height to the height field, different
        strategies can be used (i.e., placing the cells). The point-based
        strategies (e.g, POINT_MINIMUM_HEIGHT) set the cell at the
        minimum height of the cell's points (and so on). The cell-based
        strategies (e.g., CELL_MINIMUM_HEIGHT) sample the interior of the
        cell and place the cell at the minimum height (and so on) of the
        cell's sampled interior points.
        """
        ...
    
    def SetFittingStrategyToCellAverageHeight(self):
        """
        V.SetFittingStrategyToCellAverageHeight()
        C++: void SetFittingStrategyToCellAverageHeight()
        
        Specify a strategy for fitting, or projecting, the polydata to
        the height field.  By default the points of the polydata are
        projected onto the height field (POINT_PROJECTION).  However, to
        preserve planarity, or to fit the polydata cells at the
        average/minimum/maximum height to the height field, different
        strategies can be used (i.e., placing the cells). The point-based
        strategies (e.g, POINT_MINIMUM_HEIGHT) set the cell at the
        minimum height of the cell's points (and so on). The cell-based
        strategies (e.g., CELL_MINIMUM_HEIGHT) sample the interior of the
        cell and place the cell at the minimum height (and so on) of the
        cell's sampled interior points.
        """
        ...
    
    def SetFittingStrategyToCellMaximumHeight(self):
        """
        V.SetFittingStrategyToCellMaximumHeight()
        C++: void SetFittingStrategyToCellMaximumHeight()
        
        Specify a strategy for fitting, or projecting, the polydata to
        the height field.  By default the points of the polydata are
        projected onto the height field (POINT_PROJECTION).  However, to
        preserve planarity, or to fit the polydata cells at the
        average/minimum/maximum height to the height field, different
        strategies can be used (i.e., placing the cells). The point-based
        strategies (e.g, POINT_MINIMUM_HEIGHT) set the cell at the
        minimum height of the cell's points (and so on). The cell-based
        strategies (e.g., CELL_MINIMUM_HEIGHT) sample the interior of the
        cell and place the cell at the minimum height (and so on) of the
        cell's sampled interior points.
        """
        ...
    
    def SetFittingStrategyToCellMinimumHeight(self):
        """
        V.SetFittingStrategyToCellMinimumHeight()
        C++: void SetFittingStrategyToCellMinimumHeight()
        
        Specify a strategy for fitting, or projecting, the polydata to
        the height field.  By default the points of the polydata are
        projected onto the height field (POINT_PROJECTION).  However, to
        preserve planarity, or to fit the polydata cells at the
        average/minimum/maximum height to the height field, different
        strategies can be used (i.e., placing the cells). The point-based
        strategies (e.g, POINT_MINIMUM_HEIGHT) set the cell at the
        minimum height of the cell's points (and so on). The cell-based
        strategies (e.g., CELL_MINIMUM_HEIGHT) sample the interior of the
        cell and place the cell at the minimum height (and so on) of the
        cell's sampled interior points.
        """
        ...
    
    def SetFittingStrategyToPointMaximumHeight(self):
        """
        V.SetFittingStrategyToPointMaximumHeight()
        C++: void SetFittingStrategyToPointMaximumHeight()
        
        Specify a strategy for fitting, or projecting, the polydata to
        the height field.  By default the points of the polydata are
        projected onto the height field (POINT_PROJECTION).  However, to
        preserve planarity, or to fit the polydata cells at the
        average/minimum/maximum height to the height field, different
        strategies can be used (i.e., placing the cells). The point-based
        strategies (e.g, POINT_MINIMUM_HEIGHT) set the cell at the
        minimum height of the cell's points (and so on). The cell-based
        strategies (e.g., CELL_MINIMUM_HEIGHT) sample the interior of the
        cell and place the cell at the minimum height (and so on) of the
        cell's sampled interior points.
        """
        ...
    
    def SetFittingStrategyToPointMinimumHeight(self):
        """
        V.SetFittingStrategyToPointMinimumHeight()
        C++: void SetFittingStrategyToPointMinimumHeight()
        
        Specify a strategy for fitting, or projecting, the polydata to
        the height field.  By default the points of the polydata are
        projected onto the height field (POINT_PROJECTION).  However, to
        preserve planarity, or to fit the polydata cells at the
        average/minimum/maximum height to the height field, different
        strategies can be used (i.e., placing the cells). The point-based
        strategies (e.g, POINT_MINIMUM_HEIGHT) set the cell at the
        minimum height of the cell's points (and so on). The cell-based
        strategies (e.g., CELL_MINIMUM_HEIGHT) sample the interior of the
        cell and place the cell at the minimum height (and so on) of the
        cell's sampled interior points.
        """
        ...
    
    def SetFittingStrategyToPointProjection(self):
        """
        V.SetFittingStrategyToPointProjection()
        C++: void SetFittingStrategyToPointProjection()
        
        Specify a strategy for fitting, or projecting, the polydata to
        the height field.  By default the points of the polydata are
        projected onto the height field (POINT_PROJECTION).  However, to
        preserve planarity, or to fit the polydata cells at the
        average/minimum/maximum height to the height field, different
        strategies can be used (i.e., placing the cells). The point-based
        strategies (e.g, POINT_MINIMUM_HEIGHT) set the cell at the
        minimum height of the cell's points (and so on). The cell-based
        strategies (e.g., CELL_MINIMUM_HEIGHT) sample the interior of the
        cell and place the cell at the minimum height (and so on) of the
        cell's sampled interior points.
        """
        ...
    
    def SetHeightMapConnection(self, vtkAlgorithmOutput):
        """
        V.SetHeightMapConnection(vtkAlgorithmOutput)
        C++: void SetHeightMapConnection(vtkAlgorithmOutput *algOutput)
        
        Specify the pipeline connection to the height map.
        """
        ...
    
    def SetHeightMapData(self, vtkImageData):
        """
        V.SetHeightMapData(vtkImageData)
        C++: void SetHeightMapData(vtkImageData *idata)
        
        Set the height map for the filter.  Note that this method does
        not connect the pipeline. The algorithm will work on the input
        data as it is without updating the producer of the data.  See
        SetHeightMapConnection() for connecting the pipeline.
        """
        ...
    
    def SetUseHeightMapOffset(self, p_int):
        """
        V.SetUseHeightMapOffset(int)
        C++: virtual void SetUseHeightMapOffset(vtkTypeBool _arg)
        
        Indicate whether the z-offset from the image height map should be
        added to the final result. Some height map images are offset in
        z-coordinate which is independent of the height map values. By
        default this value is true.
        """
        ...
    
    def UseHeightMapOffsetOff(self):
        """
        V.UseHeightMapOffsetOff()
        C++: virtual void UseHeightMapOffsetOff()
        
        Indicate whether the z-offset from the image height map should be
        added to the final result. Some height map images are offset in
        z-coordinate which is independent of the height map values. By
        default this value is true.
        """
        ...
    
    def UseHeightMapOffsetOn(self):
        """
        V.UseHeightMapOffsetOn()
        C++: virtual void UseHeightMapOffsetOn()
        
        Indicate whether the z-offset from the image height map should be
        added to the final result. Some height map images are offset in
        z-coordinate which is independent of the height map values. By
        default this value is true.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    CELL_AVERAGE_HEIGHT = ...
    CELL_MAXIMUM_HEIGHT = ...
    CELL_MINIMUM_HEIGHT = ...
    FittingStrategy = ...
    POINT_AVERAGE_HEIGHT = ...
    POINT_MAXIMUM_HEIGHT = ...
    POINT_MINIMUM_HEIGHT = ...
    POINT_PROJECTION = ...
    __dict__ = ...
    __vtkname__ = ...


