WbW Application Programming Interface (API)

The following is a listing of function signatures, including argument names and default values, for the purpose of serving as a quick reference. The tool function documentation contains this same information as well as associated help docs. Notice that the WbEnvironment class information lists both the WbW and WbW-Pro tier product functions.

• module whitebox_workflows
• class AttributeField
• class AttributeHeader
• class BoundingBox
• class ColourData
• class DateData
• class FieldData
• class FieldDataType
• class GlobalEncodingField
• class LicenseType
• class LidarHeader
• class LidarPointData
• class Lidar
• class PhotometricInterpretation
• class Point2D
• class Point3D
• class RasterDataType
• class RasterConfigs
• class RasterType
• class Raster
• class VariableLengthRecord
• class VectorAttributes
• class VectorGeometry
• class VectorGeometryType
• class VectorGeometryTypeDimension
• class VectorHeader
• class Vector
• class WaveformPacket
• class WbEnvironment
• class WbPalette

module whitebox_workflows

def activate_license(key: str, firstname: str, lastname: str, email: str, agree_to_license_terms: bool) -> None: ...

def check_in_license(key: str) -> str: ...

def deactivate_license() -> None: ...

def download_sample_data(data_set: str) -> str: ...

def license_info() -> None: ...

def show(obj, ax=None, title=None, figsize=None, skip=None, clip_percent=None, plot_as_surface=False, vert_exaggeration=None, colorbar_kwargs=None, **kwargs) -> matplotlib.axes.Axes: ...

def transfer_license() -> None: ...

class AttributeField

@property
def name(self) -> str: ...

@property
def field_type(self) -> int: ...

@property
def field_length(self) -> int: ...

@property
def decimal_count(self) -> int: ...

@staticmethod
def new(name: str, field_type: FieldDataType, field_length: int, decimal_count: int) -> AttributeField: ...

class AttributeHeader

@property
def version(self) -> int: ...

@property
def year(self) -> int: ...

@property
def month(self) -> int: ...

@property
def day(self) -> int: ...

@property
def num_records(self) -> int: ...

@property
def num_fields(self) -> int: ...

@property
def bytes_in_header(self) -> int: ...

@property
def bytes_in_record(self) -> int: ...

@property
def incomplete_tansaction(self) -> int: ...

@property
def encryption_flag(self) -> int: ...

@property
def mdx_flag(self) -> int: ...

@property
def language_driver_id(self) -> int: ...

class BoundingBox

@property
def min_x(self) -> float: ...

@min_x.setter
def min_x(self, value: float) -> None: ...

@property
def min_y(self) -> float: ...

@min_y.setter
def min_y(self, value: float) -> None: ...

@property
def max_x(self) -> float: ...

@max_x.setter
def max_x(self, value: float) -> None: ...

@property
def max_y(self) -> float: ...

@max_y.setter
def max_y(self, value: float) -> None: ...

@staticmethod
def new(min_x: float, max_x: float, min_y: float, max_y: float) -> Point2D: ...

@staticmethod
def from_two_points(p1: Point2D, p2: Point2D) -> BoundingBox: ...

def initialize_to_inf(self) -> None: ...

def get_height(self) -> float: ...

def get_width(self) -> float: ...

def is_point_in_box(self, x: float, y: float) -> bool: ...

def overlaps(self, other: BoundingBox) -> bool: ...

def nearly_overlaps(self, other: BoundingBox) -> bool: ...

def intersects_edge_of(self, other: BoundingBox) -> bool: ...

def entirely_contained_within(self, other: BoundingBox) -> bool: ...

def within(self, other: BoundingBox) -> bool: ...

def entirely_contains(self, other: BoundingBox) -> bool: ...

def contains(self, other: BoundingBox) -> bool: ...

def intersect(self, other: BoundingBox) -> BoundingBox: ...

def expand_to(self, other: BoundingBox) -> None: ...

def contract_to(self, other: BoundingBox) -> None: ...

def expand_by(self, value: float) -> None: ...

def contract_by(self, value: float) -> None: ...

class ColourData

@property
def red(self) -> int: ...

@red.setter
def red(self, value: int) -> None: ...

@property
def green(self) -> int: ...

@green.setter
def green(self, value: int) -> None: ...

@property
def blue(self) -> int: ...

@blue.setter
def blue(self, value: int) -> None: ...

@property
def nir(self) -> int: ...

@nir.setter
def nir(self, value: int) -> None: ...

class DateData

@property
def year(self) -> int: ...

@property
def month(self) -> int: ...

@property
def day(self) -> int: ...

class FieldData

@staticmethod
def new() -> FieldData: ...

@staticmethod
def new_int(value: int) -> FieldData: ...

@staticmethod
def new_real(value: float) -> FieldData: ...

@staticmethod
def new_text(value: str) -> FieldData: ...

@staticmethod
def new_date(value: DateData) -> FieldData: ...

@staticmethod
def new_bool(value: bool) -> FieldData: ...

@staticmethod
def new_null() -> FieldData: ...

def get_type(self) -> FieldDataType: ...

def get_value_as_f64(self) -> float: ...

def get_as_string(self) -> str: ...

class FieldDataType

Bool: int
Date: int
Int: int
Real: int
Text: int

class GlobalEncodingField

def __init__(self):

class LicenseType

WbW: str
WbWPro: str

class LidarHeader

@property
def file_signature(self) -> str: ...

@property
def file_source_id(self) -> int: ...

@property
def global_encoding(self) -> GlobalEncodingField: ...

@property
def project_id_used(self) -> bool: ...

@property
def project_id1(self) -> int: ...

@property
def project_id2(self) -> int: ...

@property
def project_id3(self) -> int: ...

@property
def project_id4(self) -> Tuple[int]: ...

@property
def version_major(self) -> int: ...

@property
def version_minor(self) -> int: ...

@property
def system_id(self) -> str: ...

@property
def generating_software(self) -> str: ...

@property
def file_creation_day(self) -> int: ...

@property
def file_creation_year(self) -> int: ...

@property
def header_size(self) -> int: ...

@property
def offset_to_points(self) -> int: ...

@property
def number_of_vlrs(self) -> int: ...

@property
def number_of_extended_vlrs(self) -> int: ...

@property
def offset_to_ex_vlrs(self) -> int: ...

@property
def point_record_length(self) -> int: ...

@property
def point_format(self) -> int: ...

@property
def number_of_points_old(self) -> int: ...

@property
def number_of_points(self) -> int: ...

@property
def number_of_points_by_return_old(self) -> Tuple[int, int, int, int, int]: ...

@property
def number_of_points_by_return(self) -> Tuple[int, int, int, int, int, int, int, int, int, int, int, int, int, int, int]: ...

@property
def x_scale_factor(self) -> float: ...

@property
def y_scale_factor(self) -> float: ...

@property
def z_scale_factor(self) -> float: ...

@property
def x_offset(self) -> float: ...

@property
def y_offset(self) -> float: ...

@property
def z_offset(self) -> float: ...

@property
def max_x(self) -> float: ...

@property
def min_x(self) -> float: ...

@property
def max_y(self) -> float: ...

@property
def min_y(self) -> float: ...

@property
def max_z(self) -> float: ...

@property
def min_z(self) -> float: ...

@property
def waveform_data_start(self) -> int: ...

def get_num_points(self) -> int: ...

class LidarPointData

@property
def x(self) -> int: ...

@property
def y(self) -> int: ...

@property
def z(self) -> int: ...

@property
def intensity(self) -> int: ...

@property
def point_bit_field(self) -> int: ...

@property
def class_bit_field(self) -> int: ...

@property
def scan_angle(self) -> int: ...

@property
def user_data(self) -> int: ...

@property
def point_source_id(self) -> int: ...

@property
def is_64bit(self) -> bool: ...

def get_32bit_from_64bit(self) -> Tuple[int, int]: ...

def return_number(self) -> int: ...

def set_return_number(self, value: int) -> None: ...

def number_of_returns(self) -> int: ...

def set_number_of_returns(self, value: int) -> None: ...

def is_only_return(self) -> bool: ...

def is_multiple_return(self) -> bool: ...

def is_early_return(self) -> bool: ...

def is_late_return(self) -> bool: ...

def is_last_return(self) -> bool: ...

def is_first_return(self) -> bool: ...

def is_intermediate_return(self) -> bool: ...

def scan_direction_flag(self) -> bool: ...

def set_scan_direction_flag(self, value: bool) -> None: ...

def edge_of_flightline_flag(self) -> bool: ...

def set_edge_of_flightline_flag(self, value: bool) -> None: ...

def classification(self) -> int: ...

def set_classification(self, value: int) -> None: ...

def classification_string(self) -> str: ...

def is_classified_vegetation(self) -> bool: ...

def synthetic(self) -> bool: ...

def set_synthetic(self, value: bool) -> None: ...

def keypoint(self) -> bool: ...

def set_keypoint(self, value: bool) -> None: ...

def withheld(self) -> bool: ...

def set_withheld(self, value: bool) -> None: ...

def overlap(self) -> bool: ...

def set_overlap(self, value: bool) -> None: ...

def is_classified_noise(self) -> bool: ...

def scanner_channel(self) -> int: ...

def set_scanner_channel(self, value: int) -> None: ...

class Lidar

@property
def file_name(self) -> str: ...

@file_name.setter
def file_name(self, value: str): ...

def get_short_filename(self) -> str: ...

@property
def header(self) -> LidarHeader: ...

@property
def vlr_data(self) -> List[VariableLengthRecord]: ...

@vlr_data.setter
def vlr_data(self, value: List[VariableLengthRecord]): ...

@property
def wkt(self) -> str: ...

@property
def use_point_intensity(self) -> bool: ...

@property
def use_point_userdata(self) -> bool: ...

def get_point_record(self, index: int) -> Tuple[LidarPointData, Optional[float], Optional[ColourData], Optional[WaveformPacket]]: ...

def get_transformed_xyz(self, index: int) -> Tuple[float, float, float]: ...

def add_point(self, point_data: LidarPointData, time: Optional[float] = None, colour_data: Optional[ColourData] = None, waveform_data: Optional[WaveformPacket] = None) -> None: ...

def has_time_data(self) -> bool: ...

def has_colour_data(self) -> bool: ...

def has_waveform_data(self) -> bool: ...

def get_well_known_text(self) -> str: ...

def print_variable_length_records(self) -> str: ...

class PhotometricInterpretation

Continuous: int
Categorical: int
Boolean: int
RGB: int
Paletted: int
Unknown: int

class Point2D

@property
def x(self) -> float: ...

@x.setter
def x(self, value: float) -> None: ...

@property
def y(self) -> float: ...

@y.setter
def y(self, value: float) -> None: ...

@staticmethod
def new(x: float, y: float) -> Point2D: ...

class Point3D

@property
def x(self) -> float: ...

@x.setter
def x(self, value: float) -> None: ...

@property
def y(self) -> float: ...

@y.setter
def y(self, value: float) -> None: ...

@property
def z(self) -> float: ...

@z.setter
def z(self, value: float) -> None: ...

@staticmethod
def new(x: float, y: float, z: float) -> Point2D: ...

class RasterDataType

F64: int
F32: int
I64: int
U64: int
RGB48: int
I32: int
U32: int
RGB24: int
RGBA32: int
I16: int
U16: int
I8: int
U8: int
Unknown: int
def get_data_size(self) -> int: ...

def is_float(self) -> bool: ...

def is_integer(self) -> bool: ...

def is_unsigned_integer(self) -> bool: ...

def is_signed_integer(self) -> bool: ...

def is_colour_data(self) -> bool: ...

def return_wider(self, other: RasterDataType) -> RasterDataType: ...

class RasterConfigs

@property
def title(self) -> str: ...

@title.setter
def title(self, value): ...

@property
def rows(self) -> int: ...

@rows.setter
def rows(self, value: int) -> None: ...

@property
def columns(self) -> int: ...

@columns.setter
def columns(self, value: int) -> None: ...

@property
def nodata(self) -> float: ...

@nodata.setter
def nodata(self, value: float) -> None: ...

@property
def north(self) -> float: ...

@north.setter
def north(self, value: float) -> None: ...

@property
def south(self) -> float: ...

@south.setter
def south(self, value: float) -> None: ...

@property
def east(self) -> float: ...

@east.setter
def east(self, value: float) -> None: ...

@property
def west(self) -> float: ...

@west.setter
def west(self, value: float) -> None: ...

@property
def resolution_x(self) -> float: ...

@resolution_x.setter
def resolution_x(self, value: float) -> None: ...

@property
def resolution_y(self) -> float: ...

@resolution_y.setter
def resolution_y(self, value: float) -> None: ...

@property
def minimum(self) -> float: ...

@minimum.setter
def minimum(self, value: float) -> None: ...

@property
def maximum(self) -> float: ...

@maximum.setter
def maximum(self, value: float) -> None: ...

@property
def palette(self) -> str: ...

@property
def projection(self) -> str: ...

@projection.setter
def projection(self, value: str) -> None: ...

@property
def photometric_interp(self) -> PhotometricInterpretation: ...

@photometric_interp.setter
def photometric_interp(self, value: PhotometricInterpretation) -> None: ...

@property
def data_type(self) -> RasterDataType: ...

@data_type.setter
def data_type(self, value: RasterDataType) -> None: ...

@property
def z_units(self) -> str: ...

@z_units.setter
def z_units(self, value: str) -> None: ...

@property
def xy_units(self) -> str: ...

@xy_units.setter
def xy_units(self, value: str) -> None: ...

@property
def reflect_at_edges(self) -> bool: ...

@reflect_at_edges.setter
def reflect_at_edges(self, value: bool) -> None: ...

@property
def pixel_is_area(self) -> bool: ...

@pixel_is_area.setter
def pixel_is_area(self, value: bool) -> None: ...

@property
def epsg_code(self) -> int: ...

@epsg_code.setter
def epsg_code(self, value: int) -> None: ...

@property
def coordinate_ref_system_wkt(self) -> str: ...

@epsg_code.setter
def coordinate_ref_system_wkt(self, value: str) -> None: ...

@staticmethod
def new() -> RasterConfigs: ...

class RasterType

Unknown: int
ArcAscii: int
ArcBinary: int
EsriBil: int
GeoTiff: int
GrassAscii: int
IdrisiBinary: int
SagaBinary: int
Surfer7Binary: int
SurferAscii: int
Whitebox: int

class Raster

@property
def file_name(self) -> str: ...

@file_name.setter
def file_name(self, value: str) -> None: ...

@property
def file_mode(self) -> str: ...

@property
def raster_type(self) -> RasterType: ...

@property
def configs(self) -> RasterConfigs: ...

@staticmethod
def new_from_other(other: Raster, data_type: Optional[RasterDataType]) -> Raster: ...

def get_value(self, row: int, column: int) -> float: ...

def set_value(self, row: int, column: int, value: float) -> None: ...

def decrement(self, row: int, column: int, value: float) -> None: ...

def increment(self, row: int, column: int, value: float) -> None: ...

def get_file_extension(self) -> str: ...

def get_short_filename(self) -> str: ...

def set_row_data(self, row: int, values: List[float]) -> None: ...

def get_row_data(self, row: int) -> List[float]: ...

def increment_row_data(self, row: int, values: List[float]) -> None: ...

def decrement_row_data(self, row: int, values: List[float]) -> None: ...

def set_data_from_raster(self, other: Raster) -> Optional[str]: ...

def reinitialize_values(self, value: float) -> None: ...

def get_value_as_rgba(self, row: int, column: int) -> Tuple[int, int, int, int]: ...

def get_row_data_as_rgba(self, row: int, column: int) -> List[Tuple[int, int, int, int]]: ...

def get_value_as_hsi(self, row: int, column: int) -> Tuple[float, float, float]: ...

def set_value_from_rgba(self, row: int, column: int, rgba: Tuple[int, int, int, int]) -> None: ...

def get_data_size_in_bytes(self) -> int: ...

def get_x_from_column(self, column: int) -> float: ...

def get_y_from_row(self, row: int) -> float: ...

def get_column_from_x(self, x: float) -> int: ...

def get_row_from_y(self, y: float) -> int: ...

def size_of(self) -> int: ...

def __add__(self, other: Union[Raster, float]) -> Raster: ...

def __sub__(self, other: Union[Raster, float]) -> Raster: ...

def __mul__(self, other: Union[Raster, float]) -> Raster: ...

def __truediv__(self, other: Union[Raster, float]) -> Raster: ...

def __floordiv__(self, other: Union[Raster, float]) -> Raster: ...

def __mod__(self, other: Union[Raster, float]) -> Raster: ...

def __pow__(self, other: Union[Raster, float], modulo: Optional[float] = None) -> Raster: ...

def __neg__(self) -> Raster: ...

def __abs__(self) -> Raster: ...

def __iadd__(self, other: Union[Raster, float]) -> None: ...

def __isub__(self, other: Union[Raster, float]) -> None: ...

def __imul__(self, other: Union[Raster, float]) -> None: ...

def __idiv__(self, other: Union[Raster, float]) -> None: ...

def __getitem__(self, row_column: Tuple[int, int]) -> float: ...

def __setitem__(self, row_column: Tuple[int, int], value: float) -> None: ...

def __gt__(self, other: Union[Raster, float]) -> Raster: ...

def __ge__(self, other: Union[Raster, float]) -> Raster: ...

def __lt__(self, other: Union[Raster, float]) -> Raster: ...

def __le__(self, other: Union[Raster, float]) -> Raster: ...

def __eq__(self, other: Union[Raster, float]) -> Raster: ...

def __ne__(self, other: Union[Raster, float]) -> Raster: ...

def acos(self) -> Raster: ...

def acosh(self) -> Raster: ...

def asin(self) -> Raster: ...

def asinh(self) -> Raster: ...

def atan(self) -> Raster: ...

def atan2(self, other: Union[Raster, float]) -> Raster: ...

def atanh(self) -> Raster: ...

def ceil(self) -> Raster: ...

def con(self, con_statement: str, true_raster_or_float: Union[Raster, float, str], false_raster_or_float: Union[Raster, float, str]) -> Raster: ...

def cos(self) -> Raster: ...

def cosh(self) -> Raster: ...

def exp(self) -> Raster: ...

def exp2(self) -> Raster: ...

def floor(self) -> Raster: ...

def is_nodata(self) -> Raster: ...

def ln(self) -> Raster: ...

def log2(self) -> Raster: ...

def log10(self) -> Raster: ...

def max(self, other: Union[Raster, float]) -> Raster: ...

def min(self, other: Union[Raster, float]) -> Raster: ...

def normalize(self) -> Raster: ...

def signum(self) -> Raster: ...

def sin(self) -> Raster: ...

def sinh(self) -> Raster: ...

def sqrt(self) -> Raster: ...

def square(self) -> Raster: ...

def tan(self) -> Raster: ...

def tanh(self) -> Raster: ...

def to_degrees(self) -> Raster: ...

def to_radians(self) -> Raster: ...

def trunc(self) -> Raster: ...

def num_cells(self) -> int: ...

def num_valid_cells(self) -> int: ...

def calculate_mean(self) -> float: ...

def calculate_mean_and_stdev(self) -> Tuple[float, float]: ...

def calculate_clip_values(self, percent: float) -> Tuple[float, float]: ...

def deep_copy(self) -> Raster: ...

def update_min_max(self) -> None: ...

class VariableLengthRecord

@property
def reserved(self) -> int: ...

@property
def user_id(self) -> str: ...

@property
def record_id(self) -> int: ...

@property
def record_length_after_header(self) -> int: ...

@property
def description(self) -> str: ...

@property
def binary_data(self) -> List[int]: ...

class VectorAttributes

@property
def header(self) -> AttributeHeader: ...

@property
def fields(self) -> List[AttributeField]: ...

@property
def is_deleted(self) -> List[bool]: ...

def get_num_fields(self) -> int: ...

class VectorGeometry

@property
def shape_type(self) -> VectorGeometryType: ...

@property
def x_min(self) -> float: ...

@property
def x_max(self) -> float: ...

@property
def y_min(self) -> float: ...

@property
def y_max(self) -> float: ...

@property
def num_parts(self) -> int: ...

@property
def num_points(self) -> int: ...

@property
def parts(self) -> List[int]: ...

@property
def points(self) -> List[Point2D]: ...

@property
def z_min(self) -> float: ...

@property
def z_max(self) -> float: ...

@property
def z_array(self) -> List[float]: ...

@property
def m_min(self) -> float: ...

@property
def m_max(self) -> float: ...

@property
def m_array(self) -> List[float]: ...

@staticmethod
def new_vector_geometry(shape_type: VectorGeometryType) -> VectorGeometry: ...

def add_point(self, p: Point2D) -> None: ...

def add_pointm(self, p: Point2D, m: float) -> None: ...

def add_pointz(self, p: Point2D, m: float, z: float) -> None: ...

def add_geom_part(self, points: List[Point2D]) -> None: ...

def add_geom_partm(self, points: List[Point2D], measures: List[float]) -> None: ...

def add_geom_partz(self, points: List[Point2D], measures: List[float], z_values: List[float]) -> None: ...

def get_bounding_box(self) -> BoundingBox: ...

def get_length(self) -> int: ...

def has_m_data(self) -> bool: ...

def has_z_data(self) -> bool: ...

def is_hole(self, part_num: int) -> bool: ...

class VectorGeometryType

Null: int
Point: int
PolyLine: int
Polygon: int
MultiPoint: int
PointZ: int
PolyLineZ: int
PolygonZ: int
MultiPointZ: int
PointM: int
PolyLineM: int
PolygonM: int
MultiPointM: int
def base_shape_type(self) -> VectorGeometryType: ...

def dimension(self) -> VectorGeometryTypeDimension: ...

class VectorGeometryTypeDimension

XY: int
Measure: int
Z: int

class VectorHeader

@property
def file_length(self) -> int: ...

@property
def version(self) -> int: ...

@property
def shape_type(self) -> VectorGeometryType: ...

@property
def x_min(self) -> float: ...

@property
def y_min(self) -> float: ...

@property
def x_max(self) -> float: ...

@property
def y_max(self) -> float: ...

@property
def z_min(self) -> float: ...

@property
def z_max(self) -> float: ...

@property
def m_min(self) -> float: ...

@property
def m_max(self) -> float: ...

class Vector

@property
def file_name(self) -> str: ...

@file_name.setter
def file_name(self, value: str) -> None: ...

@property
def file_mode(self) -> str: ...

@property
def header(self) -> VectorHeader: ...

@property
def num_records(self) -> int: ...

@property
def records(self) -> List[VectorGeometry]: ...

@property
def attributes(self) -> VectorAttributes: ...

@property
def projection(self) -> str: ...

def __getitem__(self, index: int) -> VectorGeometry: ...

def add_record(self, geometry: VectorGeometry) -> None: ...

def add_attribute_field(self, field: AttributeField) -> None: ...

def add_attribute_fields(self, fields: List[AttributeField]) -> None: ...

def add_attribute_record(self, rec: List[FieldData], deleted: bool) -> None: ...

def contains_attribute_field(self, field: AttributeField) -> bool: ...

def get_attribute_fields(self) -> List[AttributeField]: ...

def get_attribute_record(self, index: int) -> List[FieldData]: ...

def get_attribute_field_info(self, index: int) -> AttributeField: ...

def get_attribute_field_num(self, name: str) -> Optional[int]: ...

def get_num_attributes_fields(self) -> int: ...

def get_attribute_value(self, record_index: int, field_name: str) -> FieldData: ...

def is_attribute_field_numeric(self, index: int) -> bool: ...

def reinitialize_attributes(self) -> None: ...

def set_attribute_value(self, record_index: int, field_name: str, field_data: FieldData) -> None: ...

class WaveformPacket

@property
def packet_descriptor_index(self) -> int: ...

@packet_descriptor_index.setter
def packet_descriptor_index(self, value: int) -> None: ...

@property
def offset_to_waveform_data(self) -> int: ...

@offset_to_waveform_data.setter
def offset_to_waveform_data(self, value: int) -> None: ...

@property
def waveform_packet_size(self) -> int: ...

@waveform_packet_size.setter
def waveform_packet_size(self, value: int) -> None: ...

@property
def ret_point_waveform_loc(self) -> float: ...

@ret_point_waveform_loc.setter
def ret_point_waveform_loc(self, value: float) -> None: ...

@property
def xt(self) -> float: ...

@xt.setter
def xt(self, value: float) -> None: ...

@property
def yt(self) -> float: ...

@yt.setter
def yt(self, value: float) -> None: ...

@property
def zt(self) -> float: ...

@zt.setter
def zt(self, value: float) -> None: ...

class WbEnvironment

@property
def max_procs(self) -> int: ...

@max_procs.setter
def max_procs(self, value: int) -> None: ...

@property
def verbose(self) -> bool: ...

@verbose.setter
def verbose(self, value: bool) -> None: ...

@property
def working_directory(self) -> str: ...

@working_directory.setter
def working_directory(self, value: str) -> None: ...

def __new__(cls, user_id: str = "") -> WbEnvironment: ...

def version(self) -> str: ...

def read_lidar(self, file_name: str, file_mode: str = "r") -> Lidar: ...

def read_lidars(self, file_names: List[str], parallel: bool = True) -> List[Lidar]: ...

def new_lidar(self, header: LidarHeader) -> Lidar: ...

def write_lidar(self, lidar: Lidar, file_name: str) -> None: ...

def read_raster(self, file_name: str) -> Raster: ...

def read_rasters(self, file_name: List[str], parallel: bool = True) -> List[Raster]: ...

def new_raster(self, configs: RasterConfigs) -> Raster: ...

def write_raster(self, raster: Raster, file_name: str, compress: bool = False) -> None: ...

def read_vector(self, file_name: str) -> Vector: ...

def read_vectors(self, file_name: List[str], parallel: bool = True) -> List[Vector]: ...

def new_vector(self,  shape_type: VectorGeometryType, attributes: Optional[List[AttributeField]] = None, proj: str = "") -> Vector: ...

def write_vector(self, vector: Vector, file_name: str) -> None: ...

def write_text(self, text: str, file_name: str) -> None: ...

# Requires WbW-Pro license
def accumulation_curvature(self, dem: Raster, log_transform: bool = False, z_factor: float = 1.0) -> Raster: ...

def adaptive_filter(self, raster: Raster, filter_size_x: int = 11, filter_size_y: int = 11, threshold: float = 2.0) -> Raster: ...

def add_point_coordinates_to_table(self, input: Vector) -> Vector: ...

def aggregate_raster(self, raster: Raster, aggregation_factor: int = 2, aggregation_type: str = "mean") -> Raster: ...

def anova(self, input_raster: Raster, features_raster: Raster, output_html_file: str) -> None: ...

def ascii_to_las(self, input_ascii_files: List[str], pattern: str, epsg_code: int) -> None: ...

def aspect(self, dem: Raster, z_factor: float = 1.0) -> Raster: ...

# Requires WbW-Pro license
def assess_route(self, routes: Vector, dem: Raster, segment_length: float = 100.0, search_radius: int = 15) -> Vector: ...

def attribute_correlation(self, input: Vector, output_html_file: str) -> None: ...

def attribute_histogram(self, input: Vector, field_name: str, output_html_file: str) -> None: ...

def attribute_scattergram(self, input: Vector, field_name_x: str, field_name_y: str, output_html_file: str, add_trendline: bool = False) -> None: ...

def average_flowpath_slope(self, dem: Raster) -> Raster: ...

# Requires WbW-Pro license
def average_horizon_distance(self, dem: Raster, az_fraction: float = 5.0, max_dist: float = float('inf'), observer_hgt_offset: float = 0.05) -> Raster: ...

def average_normal_vector_angular_deviation(self, dem: Raster, filter_size: int = 11) -> Raster: ...

def average_overlay(self, input_rasters: List[Raster]) -> Raster: ...

def average_upslope_flowpath_length(self, dem: Raster) -> Raster: ...

def balance_contrast_enhancement(self, image: Raster, band_mean: float = 100.0) -> Raster: ...

def basins(self, d8_pntr: Raster, esri_pntr: bool = False) -> Raster: ...

def bilateral_filter(self, raster: Raster, sigma_dist: float = 0.75, sigma_int: float = 1.0) -> Raster: ...

def block_maximum(self, points: Vector, field_name: str = "FID", use_z: bool = False, cell_size: float = 0.0, base_raster: Optional[Raster] = None) -> Raster: ...

def block_minimum(self, points: Vector, field_name: str = "FID", use_z: bool = False, cell_size: float = 0.0, base_raster: Optional[Raster] = None) -> Raster: ...

def bool_and(self, input1: Raster, input2: Raster) -> Raster: ...

def bool_not(self, input1: Raster, input2: Raster) -> Raster: ...

def bool_or(self, input1: Raster, input2: Raster) -> Raster: ...

def bool_xor(self, input1: Raster, input2: Raster) -> Raster: ...

def boundary_shape_complexity(self, raster: Raster) -> Raster: ...

def breach_depressions_least_cost(self, dem: Raster, max_cost: float = float('inf'), max_dist: int = 100, flat_increment: float = float('nan'), fill_deps: bool = False, minimize_dist: bool = False) -> Raster: ...

def breach_single_cell_pits(self, dem: Raster) -> Raster: ...

# Requires WbW-Pro license
def breakline_mapping(self, dem: Raster, threshold: float = 0.8, min_length: int = 3) -> Vector: ...

def buffer_raster(self, input: Raster, buffer_size: float, grid_cells_units: bool = False) -> Raster: ...

def burn_streams_at_roads(self, dem: Raster, streams: Vector, roads: Vector, road_width: float) -> Raster: ...

# Requires WbW-Pro license
def canny_edge_detection(self, input: Raster, sigma: float = 0.5, low_threshold: float = 0.05, high_threshold: float = 0.15, add_back_to_image: bool = False) -> Raster: ...

def centroid_raster(self, input: Raster) -> Tuple[Raster, str]: ...

def centroid_vector(self, input: Vector) -> Vector: ...

def change_vector_analysis(self, date1_rasters: List[Raster], date2_rasters: List[Raster]) -> Tuple[Raster, Raster, str]: ...

def check_in_license(self, key: str) -> str: ...

def circular_variance_of_aspect(self, dem: Raster, filter_size: int = 11) -> Raster: ...

def classify_buildings_in_lidar(self, in_lidar: Lidar, building_footprints: Vector) -> Lidar: ...

# Requires WbW-Pro license
def classify_lidar(self, input_lidar: Optional[Lidar], search_radius: float = 2.5, grd_threshold: float = 0.1, oto_threshold: float = 1.0, linearity_threshold: float = 0.5, planarity_threshold: float = 0.85, num_iter: int = 30, facade_threshold: float = 0.5) -> Optional[Lidar]: ...

# Requires WbW-Pro license
def colourize_based_on_class(self, input_lidar: Optional[Lidar], intensity_blending_amount: float = 50.0, clr_str: str = "", use_unique_clrs_for_buildings: bool = False, search_radius: float = 2.0) -> Optional[Lidar]: ...

# Requires WbW-Pro license
def colourize_based_on_point_returns(self, input_lidar: Optional[Lidar], intensity_blending_amount: float = 50.0, only_ret_colour: str = "(230,214,170)", first_ret_colour:str = "(0,140,0)", intermediate_ret_colour: str = "(255,0,255)", last_ret_colour: str = "(0,0,255)") -> Optional[Lidar]: ...

def classify_overlap_points(self, in_lidar: Lidar, resolution: float = 1.0, overlap_criterion: str = "max scan angle", filter: bool = False) -> Lidar: ...

def clean_vector(self, input: Vector) -> Vector: ...

def clip(self, input: Vector, clip_layer: Vector) -> Vector: ...

def clip_lidar_to_polygon(self, input: Lidar, polygons: Vector) -> Lidar: ...

def clip_raster_to_polygon(self, raster: Raster, polygons: Vector, maintain_dimensions: bool = False) -> Raster: ...

def closing(self, raster: Raster, filter_size_x: int = 11, filter_size_y: int = 11) -> Raster: ...

def clump(self, raster: Raster, diag: bool = False, zero_background: bool = False) -> Raster: ...

def compactness_ratio(self, input: Vector) -> Vector: ...

def conservative_smoothing_filter(self, raster: Raster, filter_size_x: int = 3, filter_size_y: int = 3) -> Raster: ...

def construct_vector_tin(self, input_points: Vector, field_name: str = "FID", use_z: bool = False, max_triangle_edge_length: float = float('inf')) -> Vector: ...

def contours_from_points(self, input: Vector, field_name: str = "", use_z_values: bool = False, max_triangle_edge_length: float = float('inf'), contour_interval: float = 10.0, base_contour: float = 0.0, smoothing_filter_size: int = 9) -> Vector: ...

def contours_from_raster(self, raster_surface: Raster, contour_interval: float = 10.0, base_contour: float = 0.0, smoothing_filter_size: int = 9, deflection_tolerance: float = 10.0) -> Vector: ...

def convergence_index(self, dem: Raster, z_factor: float = 1.0) -> Raster: ...

def convert_nodata_to_zero(self, raster: Raster) -> Raster: ...

def corner_detection(self, raster: Raster) -> Raster: ...

def correct_vignetting(self, image: Raster, principal_point: Vector, focal_length: float = 304.8, image_width: float = 228.6, n_param: float = 4.0) -> Raster: ...

def cost_allocation(self, source: Raster, backlink: Raster) -> Raster: ...

def cost_distance(self, source: Raster, cost: Raster) -> Tuple[Raster, Raster]: ...

def cost_pathway(self, destination: Raster, backlink: Raster, zero_background: bool = False) -> Raster: ...

def count_if(self, input_rasters: List[Raster], comparison_value: float) -> Raster: ...

def create_colour_composite(self, red: Raster, green: Raster, blue: Raster, opacity: Optional[Raster] = None, enhance: bool = True, treat_zeros_as_nodata: bool = False) -> Raster: ...

def create_plane(self, base_file: Raster, gradient: float, aspect: float, constant: float) -> Raster: ...

def crispness_index(self, raster: Raster, output_html_file: str) -> None: ...

def cross_tabulation(self, raster1: Raster, raster2: Raster, output_html_file: str) -> None: ...

def csv_points_to_vector(self, input_file: str, x_field_num: int = 0, y_field_num: int = 1, epsg: int = 0) -> Vector: ...

def cumulative_distribution(self, raster: Raster) -> Raster: ...

# Requires WbW-Pro license
def curvedness(self, dem: Raster, log_transform: bool = False, z_factor: float = 1.0) -> Raster: ...

def d8_flow_accum(self, raster: Raster, out_type: str = "SCA", log_transform: bool = False, clip: bool = False, input_is_pointer: bool = False, esri_pntr: bool = False) -> Raster: ...

def d8_mass_flux(self, dem: Raster, loading: Raster, efficiency: Raster, absorption: Raster) -> Raster: ...

def d8_pointer(self, dem: Raster, esri_pointer: bool = False) -> Raster: ...

# Requires WbW-Pro license
def dbscan(self, input_rasters: List[Raster], scaling_method: str = "none", search_distance: float = 1.0, min_points: int = 5) -> Raster: ...

# Requires WbW-Pro license
def dem_void_filling(self, dem: Raster, fill: Raster, mean_plane_dist: int = 20, edge_treatment: str = "use DEM", weight_value: float = 2.0) -> Raster: ...

def depth_in_sink(self, dem: Raster, zero_background: bool = False) -> Raster: ...

# Requires WbW-Pro license
def depth_to_water(self, dem: Raster, streams: Optional[Vector] = None, lakes: Optional[Vector] = None) -> Raster: ...

def deviation_from_mean_elevation(self, dem: Raster, filter_size_x: int = 11, filter_size_y: int = 11) -> Raster: ...

def deviation_from_regional_direction(self, input: Vector, elongation_threshold: float = 0.75) -> Vector: ...

def diff_of_gaussians_filter(self, raster: Raster, sigma1: float = 2.0, sigma2: float = 4.0) -> Raster: ...

def difference(self, input: Vector, overlay: Vector) -> Vector: ...

# Requires WbW-Pro license
def difference_curvature(self, dem: Raster, log_transform: bool = False, z_factor: float = 1.0) -> Raster: ...

def difference_from_mean_elevation(self, dem: Raster, filter_size_x: int = 11, filter_size_y: int = 11) -> Raster: ...

def dinf_flow_accum(self, dem: Raster, out_type: str = "SCA", convergence_threshold: float = float('inf'), log_transform: bool = False, clip: bool = False, input_is_pointer: bool = False) -> Raster: ...

def dinf_mass_flux(self, dem: Raster, loading: Raster, efficiency: Raster, absorption: Raster) -> Raster: ...

def dinf_pointer(self, dem: Raster) -> Raster: ...

def direct_decorrelation_stretch(self, image: Raster, achromatic_factor: float = 0.5, clip_percent: float = 1.0) -> Raster: ...

def directional_relief(self, dem: Raster, azimuth: float = 0.0, max_dist: float = float('inf')) -> Raster: ...

def dissolve(self, input: Vector, dissolve_field: str = "", snap_tolerance: float = 2.220446049250313e-16) -> Vector: ...

def distance_to_outlet(self, d8_pointer: Raster, streams_raster: Raster, esri_pointer: bool = False, zero_background: bool = False) -> Raster: ...

def diversity_filter(self, raster: Raster, filter_size_x: int = 11, filter_size_y: int = 11) -> Raster: ...

def downslope_distance_to_stream(self, dem: Raster, streams: Raster, use_dinf: bool = False) -> Raster: ...

def downslope_flowpath_length(self, d8_pointer: Raster, watersheds: Raster, weights: Raster, esri_pntr: bool = False) -> Raster: ...

def downslope_index(self, dem: Raster, vertical_drop: float, output_type: str = "tangent") -> Raster: ...

def edge_contamination(self, dem: Raster, flow_type: str = "mfd", z_factor: float = -1.0) -> Raster: ...

def edge_density(self, dem: Raster, filter_size: int = 11, normal_diff_threshold: float = 5.0, z_factor: float = 1.0) -> Raster: ...

def edge_preserving_mean_filter(self, raster: Raster, filter_size: int = 11, threshold: float = 15.0) -> Raster: ...

def edge_proportion(self, raster: Raster) -> Tuple[Raster, str]: ...

def elev_relative_to_min_max(self, dem: Raster) -> Raster: ...

def elev_relative_to_watershed_min_max(self, dem: Raster, watersheds: Raster) -> Raster: ...

def elevation_above_pit(self, dem: Raster) -> Raster: ...

def elevation_above_stream(self, dem: Raster, streams: Raster) -> Raster: ...

def elevation_above_stream_euclidean(self, dem: Raster, streams: Raster) -> Raster: ...

def elevation_percentile(self, dem: Raster, filter_size_x: int = 11, filter_size_y: int = 11, sig_digits: int = 2) -> Raster: ...

def eliminate_coincident_points(self, input: Vector, tolerance_dist: float) -> Vector: ...

def elongation_ratio(self, input: Vector) -> Vector: ...

def embankment_mapping(self, dem: Raster, roads_vector: Vector, search_dist: float = 2.5, min_road_width: float = 6.0, typical_embankment_width: float = 30.0, typical_embankment_max_height: float = 2.0, embankment_max_width: float = 60.0, max_upwards_increment: float = 0.05, spillout_slope: float = 4.0, remove_embankments: bool = False) -> Tuple[Raster, Optional[Raster]]: ...

def emboss_filter(self, raster: Raster, direction: str = "n", clip_amount: float = 0.0) -> Raster: ...

def erase(self, input: Vector, erase_layer: Vector) -> Vector: ...

def erase_polygon_from_lidar(self, input: Lidar, polygons: Vector) -> Lidar: ...

def erase_polygon_from_raster(self, raster: Raster, polygons: Vector) -> Raster: ...

def euclidean_allocation(self, input: Raster) -> Raster: ...

def euclidean_distance(self, input: Raster) -> Raster: ...

# Requires WbW-Pro license
def evaluate_training_sites(self, input_rasters: List[Raster], training_polygons: Vector, class_field_name: str, output_html_file: str) -> None: ...

def export_table_to_csv(self, input: Vector, output_csv_file: str, headers: bool = True) -> None: ...

def exposure_towards_wind_flux(self, dem: Raster, azimuth: float = 0.0, max_dist: float = float('inf'), z_factor: float = 1.0) -> Raster: ...

def extend_vector_lines(self, input: Vector, distance: float, extend_direction: str = "both ends") -> Vector: ...

def extract_by_attribute(self, input: Vector, statement: str) -> Vector: ...

def extract_nodes(self, input: Vector) -> Vector: ...

def extract_raster_values_at_points(self, rasters: List[Raster], points: Vector) -> Tuple[Vector, str]: ...

def extract_streams(self, flow_accumulation: Raster, threshold: float = 0.0, zero_background: bool = False) -> Raster: ...

def extract_valleys(self, dem: Raster, variant: str = "LQ", line_thin: bool = False, filter_size: int = 5) -> Raster: ...

def farthest_channel_head(self, d8_pointer: Raster, streams_raster: Raster, esri_pointer: bool = False, zero_background: bool = False) -> Raster: ...

def fast_almost_gaussian_filter(self, raster: Raster, sigma: float = 1.8) -> Raster: ...

def fd8_flow_accum(self, dem: Raster, out_type: str = "SCA", exponent: float = 1.1, convergence_threshold: float = float('inf'), log_transform: bool = False, clip: bool = False) -> Raster: ...

def fd8_pointer(self, dem: Raster) -> Raster: ...

def feature_preserving_smoothing(self, dem: Raster, filter_size: int = 11, normal_diff_threshold: float = 8.0, iterations: int = 3, max_elevation_diff: float = float('inf'), z_factor: float = 1.0) -> Raster: ...

def fetch_analysis(self, dem: Raster, azimuth: float = 0.0, height_increment: float = 0.05) -> Raster: ...

def fill_burn(self, dem: Raster, streams: Vector) -> Raster: ...

def fill_depressions(self, dem: Raster, fix_flats: bool = True, flat_increment: float = float('nan'), max_depth: float = float('inf')) -> Raster: ...

def fill_depressions_planchon_and_darboux(self, dem: Raster, fix_flats: bool = True, flat_increment: float = float('nan')) -> Raster: ...

def fill_depressions_wang_and_liu(self, dem: Raster, fix_flats: bool = True, flat_increment: float = float('nan')) -> Raster: ...

def fill_missing_data(self, dem: Raster, filter_size: int = 11, weight: float = 2.0, exclude_edge_nodata: bool = False) -> Raster: ...

def fill_pits(self, dem: Raster) -> Raster: ...

# Requires WbW-Pro license
def filter_lidar(self, statement: str, input_lidar: Optional[Lidar]) -> Optional[Lidar]: ...

# Requires WbW-Pro license
def filter_lidar_by_percentile(self, input_lidar: Optional[Lidar],  percentile: float = 0.0, block_size: float = 1.0) -> Optional[Lidar]: ...

# Requires WbW-Pro license
def filter_lidar_by_reference_surface(self, input_lidar: Lidar, ref_surface: Raster, query: str = "within", threshold: float = 0.0, classify: bool = False, true_class_value: int = 2, false_class_value: int = 1, preserve_classes: bool = False) -> Lidar: ...

def filter_lidar_classes(self, input: Lidar, exclusion_classes: List[int]) -> Lidar: ...

def filter_lidar_noise(self, input: Lidar) -> Lidar: ...

def filter_lidar_scan_angles(self, in_lidar: Lidar, threshold: int) -> Lidar: ...

def filter_raster_features_by_area(self, input: Raster, threshold: int, zero_background: bool = False) -> Raster: ...

def find_flightline_edge_points(self, in_lidar: Lidar) -> Lidar: ...

def find_lowest_or_highest_points(self, raster: Raster, output_type: str = "lowest") -> Vector: ...

def find_main_stem(self, d8_pointer: Raster, streams_raster: Raster, esri_pointer: bool = False, zero_background: bool = False) -> Raster: ...

def find_noflow_cells(self, dem: Raster) -> Raster: ...

def find_parallel_flow(self, d8_pntr: Raster, streams: Raster) -> Raster: ...

def find_patch_edge_cells(self, raster: Raster) -> Raster: ...

def find_ridges(self, dem: Raster, line_thin: bool = True) -> Raster: ...

# Requires WbW-Pro license
def fix_dangling_arcs(self, input: Vector, snap_dist: float) -> Vector: ...

def flatten_lakes(self, dem: Raster, lakes: Vector) -> Raster: ...

def flightline_overlap(self, input_lidar: Lidar, resolution: float = 1.0) -> Raster: ...

def flip_image(self, raster: Raster, direction: str = "vertical") -> Raster: ...

def flood_order(self, dem: Raster) -> Raster: ...

def flow_accum_full_workflow(self, dem: Raster, out_type: str = "SCA", log_transform: bool = False, clip: bool = False, esri_pntr: bool = False) -> Tuple[Raster, Raster, Raster]: ...

def flow_length_diff(self, d8_pointer: Raster, esri_pointer: bool = False, log_transform: bool = False) -> Raster: ...

def gamma_correction(self, raster: Raster, gamma_value: float = 0.5) -> Raster: ...

def gaussian_contrast_stretch(self, raster: Raster, num_tones: int = 256) -> Raster: ...

def gaussian_curvature(self, dem: Raster, log_transform: bool = False, z_factor: float = 1.0) -> Raster: ...

def gaussian_filter(self, raster: Raster, sigma: float = 0.75) -> Raster: ...

def geomorphons(self, dem: Raster, search_distance: int = 50, flatness_threshold: float = 0.0, flatness_distance: int = 0, skip_distance: int = 0, output_forms: bool = True, analyze_residuals: bool = False) -> Raster: ...

# Requires WbW-Pro license
def generalize_classified_raster(self, raster: Raster, area_threshold: int = 5, method: str = "longest") -> Raster: ...

# Requires WbW-Pro license
def generalize_with_similarity(self, raster: Raster, similarity_rasters: List[Raster], area_threshold: int = 5) -> Raster: ...

# Requires WbW-Pro license
def generating_function(self, dem: Raster, log_transform: bool = False, z_factor: float = 1.0) -> Raster: ...

def hack_stream_order(self, d8_pntr: Raster, streams_raster: Raster, esri_pntr: bool = False, zero_background: bool = False) -> Raster: ...

def heat_map(self, points: Vector, field_name: Optional[str] = None, bandwidth: float = 0.0, cell_size: float = 0.0, base_raster: Optional[Raster] = None, kernel_function: str = "quartic") -> Raster: ...

def height_above_ground(self, input: Lidar) -> Lidar: ...

def hexagonal_grid_from_raster_base(self, base: Raster, width: float, orientation: str = "h") -> Vector: ...

def hexagonal_grid_from_vector_base(self, base: Vector, width: float, orientation: str = "h") -> Vector: ...

def high_pass_filter(self, raster: Raster, filter_size_x: int = 11, filter_size_y: int = 11) -> Raster: ...

def high_pass_median_filter(self, raster: Raster, filter_size_x: int = 11, filter_size_y: int = 11, sig_digits: int = 2) -> Raster: ...

def highest_position(self, input_rasters: List[Raster]) -> Raster: ...

def hillshade(self, dem: Raster, azimuth: float = 315.0, altitude: float = 30.0, z_factor: float = 1.0) -> Raster: ...

def hillslopes(self, d8_pntr: Raster, streams: Raster, esri_pntr: bool = False) -> Raster: ...

def histogram_equalization(self, raster: Raster, num_tones: int = 256) -> Raster: ...

def histogram_matching(self, image: Raster, histogram: List[List[float]], histo_is_cumulative: bool = False) -> Raster: ...

def histogram_matching_two_images(self, image1: Raster, image2: Raster) -> Raster: ...

def hole_proportion(self, input: Vector) -> Vector: ...

def horizon_angle(self, dem: Raster, azimuth: float = 0.0, max_dist: float = float('inf')) -> Raster: ...

# Requires WbW-Pro license
def horizon_area(self, dem: Raster, az_fraction: float = 5.0, max_dist: float = float('inf'), observer_hgt_offset: float = 0.05) -> Raster: ...

# Requires WbW-Pro license
def horizontal_excess_curvature(self, dem: Raster, log_transform: bool = False, z_factor: float = 1.0) -> Raster: ...

def horton_ratios(self, dem: Raster, streams_raster: Raster) -> Tuple[float, float, float, float]: ...

def horton_stream_order(self, d8_pntr: Raster, streams_raster: Raster, esri_pntr: bool = False, zero_background: bool = False) -> Raster: ...

# Requires WbW-Pro license
def hydrologic_connectivity(self, dem: Raster, exponent: float = 1.1, convergence_threshold: float = 0.0, z_factor: float = 1.0 ) -> Tuple[Raster, Raster]: ...

def hypsometric_analysis(self, dem_rasters: List[Raster], output_html_file: str, watershed_rasters: Optional[List[Raster]] = None) -> None: ...

def hypsometrically_tinted_hillshade(self, dem: Raster, solar_altitude: float = 45.0, hillshade_weight: float = 0.5, brightness: float = 0.5, atmospheric_effects: float = 0.0, palette: WbPalette = WbPalette.Atlas, reverse_palette: bool = False, full_360_mode: bool = False, z_factor: float = 1.0) -> Raster: ...

def idw_interpolation(self, points: Vector, field_name: str = "FID", use_z: bool = False, weight: float = 2.0, radius: float = 0.0, min_points: int = 0, cell_size: float = 0.0, base_raster: Optional[Raster] = None) -> Raster: ...

def ihs_to_rgb(self, intensity: Raster, hue: Raster, saturation: Raster) -> Tuple[Raster, Raster, Raster]: ...

def image_autocorrelation(self, rasters: List[Raster], output_html_file: str, contiguity_type: str = "bishop") -> None: ...

def image_correlation(self, rasters: List[Raster], output_html_file: str) -> None: ...

def image_correlation_neighbourhood_analysis(self, raster1: Raster, raster2: Raster, filter_size: int = 11, correlation_stat: str = "pearson") -> Tuple[Raster, Raster]: ...

def image_regression(self, independent_variable: Raster, dependent_variable: Raster, output_html_file: str, standardize_residuals: bool = False, output_scattergram: bool = False, num_samples: int = 1000) -> Raster: ...

# Requires WbW-Pro license
def image_segmentation(self, input_rasters: List[Raster], dist_threshold: float = 0.5, num_steps: int = 10, area_threshold: int = 4) -> Raster: ...

# Requires WbW-Pro license
def image_slider(self, left_raster: Raster, right_raster: Raster, output_html_file: str, left_palette: WbPalette = WbPalette.Grey, left_reverse_palette: bool = False, left_label: str = "",  right_palette: WbPalette = WbPalette.Grey, right_reverse_palette: bool = False, right_label: str = "", image_height: int = 600) -> None: ...

def image_stack_profile(self, images: List[Raster], points: Vector, output_html_file: str) -> None: ...

def impoundment_size_index(self, dem: Raster, max_dam_length: float, output_mean: bool = False, output_max: bool = False, output_volume: bool = False, output_area: bool = False, output_height: bool = False) -> Tuple[Optional[Raster], Optional[Raster], Optional[Raster], Optional[Raster], Optional[Raster]]: ...

# Requires WbW-Pro license
def improved_ground_point_filter(self, input: Lidar, block_size: float = 1.0, max_building_size: float = 150.0, slope_threshold: float = 15.0, elev_threshold: float = 0.15, classify: bool = False, preserve_classes: bool = False) -> Lidar: ...

def individual_tree_detection(self, input_lidar: Optional[Lidar],  min_search_radius: float = 1.0, min_height: float = 0.0, max_search_radius: Optional[float] = None, max_height: Optional[float] = None, only_use_veg: bool = False) -> Optional[Vector]: ...

def insert_dams(self, dem: Raster, dam_points: Vector, dam_length: float) -> Raster: ...

def isobasins(self, dem: Raster, target_size: float, connections: bool = False, csv_file: str = "" ) -> Raster: ...

def integral_image_transform(self, raster: Raster) -> Raster: ...

def intersect(self, input: Vector, overlay: Vector, snap_tolerance: float = 2.220446049250313e-16) -> Vector: ...

# Requires WbW-Pro license
def inverse_pca(self, rasters: List[Raster], pca_report_file: str) -> List[Raster]: ...

def jenson_snap_pour_points(self, pour_pts: Vector, streams: Raster, snap_dist: float = 0.0) -> Vector: ...

def join_tables(self, primary_vector: Vector, primary_key_field: str, foreign_vector: Vector, foreign_key_field: str, import_field: str = "") -> None: ...

def k_means_clustering(self, input_rasters: List[Raster], output_html_file: str = "", num_clusters: int = 5, max_iterations: int = 10, percent_changed_threshold: float = 2.0, initialization_mode: str = "diagonal", min_class_size: int = 10) -> Raster: ...

def k_nearest_mean_filter(self, raster: Raster, filter_size_x: int = 3, filter_size_y: int = 3, k: int = 5) -> Raster: ...

def kappa_index(self, class_raster: Raster, reference_raster: Raster, output_html_file: str = "") -> None: ...

# Requires WbW-Pro license
def knn_classification(self, input_rasters: List[Raster], training_data: Vector, class_field_name: str, scaling_method: str = "none", k: int = 5, test_proportion: float = 0.2, use_clipping: bool = False, create_output: bool = False) -> Optional[Raster]: ...

# Requires WbW-Pro license
def knn_regression(self, input_rasters: List[Raster], training_data: Vector, field_name: str, scaling_method: str = "none", k: int = 5, distance_weighting: bool = False, test_proportion: float = 0.2, create_output: bool = False) -> Optional[Raster]: ...

def ks_normality_test(self, raster: Raster, output_html_file: str, num_samples: int) -> None: ...

def laplacian_filter(self, raster: Raster, variant: str = "3x3(1)", clip_amount: float = 0.0) -> Raster: ...

def laplacian_of_gaussians_filter(self, raster: Raster, sigma: float = 0.75) -> Raster: ...

def las_to_ascii(self, input_lidar: Optional[Lidar]) -> None: ...

def las_to_shapefile(self, input_lidar: Optional[Lidar], output_multipoint: bool = False) -> Vector: ...

def layer_footprint_raster(self, input: Raster) -> Vector: ...

def layer_footprint_vector(self, input: Vector) -> Vector: ...

def lee_filter(self, raster: Raster, filter_size_x: int = 11, filter_size_y: int = 11, sigma: float = 10.0, m_value: float = 5.0) -> Raster: ...

def length_of_upstream_channels(self, d8_pointer: Raster, streams_raster: Raster, esri_pointer: bool = False, zero_background: bool = False) -> Raster: ...

def license_type(self) -> LicenseType: ...

def lidar_block_maximum(self, input_lidar: Optional[Lidar], cell_size: float = 1.0) -> Raster: ...

def lidar_block_minimum(self, input_lidar: Optional[Lidar], cell_size: float = 1.0) -> Raster: ...

def lidar_classify_subset(self, base_lidar: Lidar, subset_lidar: Lidar, subset_class_value: int, nonsubset_class_value: int) -> Lidar: ...

def lidar_colourize(self, in_lidar: Lidar, in_image: Raster) -> Lidar: ...

def lidar_construct_vector_tin(self, input_lidar: Optional[Lidar], returns_included: str = "all", excluded_classes: Optional[List[int]] = None, min_elev: float = float('-inf'), max_elev: float = float('inf'), max_triangle_edge_length: float = float('inf')) -> Vector: ...

# Requires WbW-Pro license
def lidar_contour(self, input_lidar: Optional[Lidar], contour_interval: float = 10.0, base_contour: float = 0.0, smooth: int = 5, interpolation_parameter: str = "elevation", returns_included: str = "all",  excluded_classes: Optional[List[int]] = None, min_elev: float = float('-inf'), max_elev: float = float('inf'), tile_overlap: float = 0.0, max_triangle_edge_length: float = float('inf')) -> Optional[Vector]: ...

def lidar_digital_surface_model(self, input_lidar: Optional[Lidar], cell_size: float = 1.0, search_radius: float = 0.5, min_elev: float = float('-inf'), max_elev: float = float('inf'), max_triangle_edge_length: float = float('inf')) -> Raster: ...

# Requires WbW-Pro license
def lidar_eigenvalue_features(self, input_lidar: Optional[Lidar], num_neighbours: Optional[int], search_radius: Optional[float]) -> None: ...

def lidar_elevation_slice(self, input: Lidar, minz: float = float('-inf'), maxz: float = float('inf'), classify: bool = False, in_class_value: int = 2, out_class_value: int = 1) -> Lidar: ...

def lidar_ground_point_filter(self, input_lidar: Optional[Lidar], search_radius: float = 2.0, min_neighbours: int = 0, slope_threshold: float = 45.0, height_threshold: float = 1.0, classify: bool = False, slope_norm: bool = True, height_above_ground: bool = False) -> Lidar: ...

def lidar_hex_bin(self, input_lidar: Lidar, width: float, orientation: str = "h") -> Vector: ...

def lidar_hillshade(self, input: Lidar, search_radius: float = -1.0, azimuth: float = 315.0, altitude: float = 30.0) -> Lidar: ...

def lidar_histogram(self, input_lidar: Lidar, output_html_file: str, parameter: str = "elevation", clip_percent: float = 1.0) -> None: ...

def lidar_idw_interpolation(self, input_lidar: Optional[Lidar], interpolation_parameter: str = "elevation",  returns_included: str = "all", cell_size: float = 1.0,  idw_weight: float = 1.0, search_radius: float = 2.5, excluded_classes: Optional[List[int]] = None, min_elev: float = float('-inf'), max_elev: float = float('inf'), buffer_size: float = 2.0) -> Raster: ...

def lidar_info(self, input_lidar: Lidar, output_html_file: Optional[str], show_point_density: bool = True, show_vlrs: bool = True, show_geokeys: bool = True) -> str: ...

def lidar_join(self, inputs: List[Lidar]) -> Lidar: ...

def lidar_kappa(self, input_lidar1: Lidar, input_lidar2: Lidar, output_html_file: str, cell_size: float = 1.0, output_class_accuracy: bool = False) -> Raster: ...

def lidar_nearest_neighbour_gridding(self, input_lidar: Optional[Lidar], interpolation_parameter: str = "elevation", returns_included: str = "all", cell_size: float = 1.0, search_radius: float = 2.5, excluded_classes: Optional[List[int]] = None, min_elev: float = float('-inf'), max_elev: float = float('inf')) -> Raster: ...

def lidar_point_density(self, input_lidar: Optional[Lidar], returns_included: str = "all", cell_size: float = 1.0, search_radius: float = 2.5, excluded_classes: Optional[List[int]] = None, min_elev: float = float('-inf'), max_elev: float = float('inf')) -> Raster: ...

# Requires WbW-Pro license
def lidar_point_return_analysis(self, input: Lidar, create_output: bool = False) -> Optional[Lidar]: ...

def lidar_point_stats(self, input_lidar: Optional[Lidar], cell_size: float = 1.0, num_points: bool = False, num_pulses: bool = False, avg_points_per_pulse: bool = False, z_range: bool = False, intensity_range: bool = False, predominant_class: bool = False) : (Optional[Raster], Optional[Raster], Optional[Raster], Optional[Raster], Optional[Raster], Optional[Raster])
def lidar_radial_basis_function_interpolation(self, input_lidar: Optional[Lidar], interpolation_parameter: str = "elevation", returns_included: str = "all", cell_size: float = 1.0, num_points: int = 15, excluded_classes: Optional[List[int]] = None, min_elev: float = float('-inf'), max_elev: float = float('inf'), func_type: str = "ThinPlateSpline", poly_order: str = "none", weight: float = 0.1) -> Raster: ...

def lidar_ransac_planes(self, in_lidar: Lidar, search_radius: float = 2.0, num_iterations: int = 50, num_samples: int = 10, inlier_threshold: float = 0.15, acceptable_model_size: int = 30, max_planar_slope: float = 75.0, classify: bool = False, only_last_returns: bool = False) -> Lidar: ...

def lidar_remove_outliers(self, input: Lidar, search_radius: float = 2.0, elev_diff: float = 50.0, use_median: bool = False, classify: bool = False) -> Lidar: ...

def lidar_rooftop_analysis(self, lidar_inputs: List[Lidar], building_footprints: Vector, search_radius: float = 2.0, num_iterations: int = 50, num_samples: int = 10, inlier_threshold: float = 0.15, acceptable_model_size: int = 30, max_planar_slope: float = 75.0, norm_diff_threshold: float = 2.0, azimuth: float = 180.0, altitude: float = 30.0) -> Vector: ...

def lidar_segmentation(self, in_lidar: Lidar, search_radius: float = 2.0, num_iterations: int = 50, num_samples: int = 10, inlier_threshold: float = 0.15, acceptable_model_size: int = 30, max_planar_slope: float = 75.0, norm_diff_threshold: float = 2.0, max_z_diff: float = 1.0, classes: bool = False, ground: bool = False) -> Lidar: ...

def lidar_segmentation_based_filter(self, in_lidar: Lidar, search_radius: float = 5.0, norm_diff_threshold: float = 2.0, max_z_diff: float = 1.0, classify_points: bool = False) -> Lidar: ...

def lidar_shift(self, input: Lidar, x_shift: float = 0.0, y_shift: float = 0.0, z_shift: float = 0.0) -> Lidar: ...

# Requires WbW-Pro license
def lidar_sibson_interpolation(self, input_lidar: Optional[Lidar], interpolation_parameter: str = "elevation", resolution: float = 1.0, returns_included: str = "all", excluded_classes: Optional[List[int]] = None, min_elev: float = float('-inf'), max_elev: float = float('inf')) -> Optional[Raster]: ...

def lidar_thin(self, input: Lidar, resolution: float = 1.0, selection_method: str = "first", save_filtered: bool = False) -> Tuple[Lidar, Optional[Lidar]]: ...

def lidar_thin_high_density(self, input: Lidar, density: float, resolution: float = 1.0, save_filtered: bool = False) -> Tuple[Lidar, Optional[Lidar]]: ...

def lidar_tile(self, input_lidar: Lidar, tile_width: float = 1000.0, tile_height: float = 1000.0, origin_x: float = 0.0, origin_y: float = 0.0, min_points_in_tile: int = 2, output_laz_format: bool = True) -> None: ...

def lidar_tile_footprint(self, input_lidar: Optional[Lidar], output_hulls: bool = False) -> Vector: ...

def lidar_tin_gridding(self, input_lidar: Optional[Lidar], interpolation_parameter: str = "elevation", returns_included: str = "all", cell_size: float = 1.0, excluded_classes: Optional[List[int]] = None, min_elev: float = float('-inf'), max_elev: float = float('inf'), max_triangle_edge_length: float = float('inf'), buffer_size: float = 2.0) -> Raster: ...

def lidar_tophat_transform(self, input: Lidar, search_radius: float) -> Lidar: ...

def line_detection_filter(self, raster: Raster, variant: str = "vertical", abs_values: bool = False, clip_tails: float = 0.0) -> Raster: ...

def line_intersections(self, input1: Vector, input2: Vector) -> Vector: ...

def line_thinning(self, raster: Raster) -> Raster: ...

def linearity_index(self, input: Vector) -> Vector: ...

def lines_to_polygons(self, input: Vector) -> Vector: ...

def list_unique_values(self, input: Vector, field_name: str) -> List[Tuple[str, int]]: ...

def list_unique_values_raster(self, raster: Raster) -> str: ...

# Requires WbW-Pro license
def local_hypsometric_analysis(self, dem: Raster, min_scale: int = 4, step_size: int = 1,  num_steps: int = 10, step_nonlinearity: float = 1.0) -> Tuple[Raster, Raster]: ...

# Requires WbW-Pro license
def logistic_regression(self, input_rasters: List[Raster], training_data: Vector, class_field_name: str, scaling_method: str = "none", test_proportion: float = 0.2, create_output: bool = False) -> Optional[Raster]: ...

def long_profile(self, d8_pointer: Raster, streams_raster: Raster, dem: Raster, output_html_file: str, esri_pointer: bool = False) -> None: ...

def long_profile_from_points(self, d8_pointer: Raster, points: Vector, dem: Raster, output_html_file: str, esri_pointer: bool = False) -> None: ...

def longest_flowpath(self, dem: Raster, basins: Raster) -> Vector: ...

def lowest_position(self, input_rasters: List[Raster]) -> Raster: ...

# Requires WbW-Pro license
def low_points_on_headwater_divides(self, dem: Raster, streams: Raster) -> Vector: ...

def majority_filter(self, raster: Raster, filter_size_x: int = 11, filter_size_y: int = 11) -> Raster: ...

def map_off_terrain_objects(self, dem: Raster, max_slope: float = float('inf'), min_feature_size: int = 0) -> Raster: ...

def max_absolute_overlay(self, input_rasters: List[Raster]) -> Raster: ...

def max_anisotropy_dev(self, dem: Raster, min_scale: int = 1, max_scale: int = 100, step_size: int = 1) -> Tuple[Raster, Raster]: ...

def max_anisotropy_dev_signature(self, dem: Raster, points: Vector, output_html_file: str, min_scale: int = 1, max_scale: int = 100, step_size: int = 1) -> None: ...

def max_branch_length(self, dem: Raster, log_transform: bool = False) -> Raster: ...

def max_difference_from_mean(self, dem: Raster, min_scale: int = 1, max_scale: int = 100, step_size: int = 1) -> Tuple[Raster, Raster]: ...

def max_downslope_elev_change(self, raster: Raster) -> Raster: ...

def max_elevation_dev_signature(self, dem: Raster, points: Vector, output_html_file: str, min_scale: int = 1, max_scale: int = 100, step_size: int = 1) -> None: ...

def max_elevation_deviation(self, dem: Raster, min_scale: int = 1, max_scale: int = 100, step_size: int = 1) -> Tuple[Raster, Raster]: ...

def max_overlay(self, input_rasters: List[Raster]) -> Raster: ...

def max_upslope_elev_change(self, raster: Raster) -> Raster: ...

def max_upslope_flowpath_length(self, dem: Raster) -> Raster: ...

def max_upslope_value(self, dem: Raster, values_raster: Raster) -> Raster: ...

def maximal_curvature(self, dem: Raster, log_transform: bool = False, z_factor: float = 1.0) -> Raster: ...

def maximum_filter(self, raster: Raster, filter_size_x: int = 11, filter_size_y: int = 11) -> Raster: ...

def mdinf_flow_accum(self, dem: Raster, out_type: str = "SCA", exponent: float = 1.1, convergence_threshold: float = float('inf'), log_transform: bool = False, clip: bool = False) -> Raster: ...

def mean_curvature(self, dem: Raster, log_transform: bool = False, z_factor: float = 1.0) -> Raster: ...

def mean_filter(self, raster: Raster, filter_size_x: int = 11, filter_size_y: int = 11) -> Raster: ...

def median_filter(self, raster: Raster, filter_size_x: int = 11, filter_size_y: int = 11, sig_digits: int = 2) -> Raster: ...

def medoid(self, input: Vector) -> Vector: ...

def merge_line_segments(self, input: Vector, snap_tolerance: float = 2.220446049250313e-16) -> Vector: ...

def merge_table_with_csv(self, primary_vector: Vector, primary_key_field: str, foreign_csv_filename: str, foreign_key_field: str, import_field: str = "") -> None: ...

def merge_vectors(self, input_vectors: List[Vector]) -> Vector: ...

def min_absolute_overlay(self, input_rasters: List[Raster]) -> Raster: ...

# Requires WbW-Pro license
def min_dist_classification(self, input_rasters: List[Raster], training_data: Vector, class_field_name: str, dist_threshold: float = float('inf')) -> Raster: ...

def min_downslope_elev_change(self, raster: Raster) -> Raster: ...

def min_max_contrast_stretch(self, raster: Raster, min_val: float, max_val: float, num_tones: int = 256) -> Raster: ...

def min_overlay(self, input_rasters: List[Raster]) -> Raster: ...

def minimal_curvature(self, dem: Raster, log_transform: bool = False, z_factor: float = 1.0) -> Raster: ...

def minimum_bounding_box(self, input: Vector, min_criteria: str = "area", individual_feature_hulls: bool = True) -> Vector: ...

def minimum_bounding_circle(self, input: Vector, individual_feature_hulls: bool = True) -> Vector: ...

def minimum_bounding_envelope(self, input: Vector, individual_feature_hulls: bool = True) -> Vector: ...

def minimum_convex_hull(self, input: Vector, individual_feature_hulls: bool = True) -> Vector: ...

def minimum_filter(self, raster: Raster, filter_size_x: int = 11, filter_size_y: int = 11) -> Raster: ...

def modified_k_means_clustering(self, input_rasters: List[Raster], output_html_file: str = "", num_start_clusters: int = 1000, merge_distance: float = 1.0, max_iterations: int = 10, percent_changed_threshold: float = 2.0) -> Raster: ...

# Requires WbW-Pro license
def modify_lidar(self, statement: str, input_lidar: Optional[Lidar]) -> Optional[Lidar]: ...

def modify_nodata_value(self, input: Raster, new_value: float = -32768.0) : ...

def mosaic(self, images: List[Raster], resampling_method: str = "cc") -> Raster: ...

def mosaic_with_feathering(self, image1: Raster, image2: Raster, resampling_method: str = "cc", distance_weight: float = 4.0) -> Raster: ...

def multidirectional_hillshade(self, dem: Raster, altitude: float = 30.0, z_factor: float = 1.0, full_360_mode: bool = False) -> Raster: ...

def multipart_to_singlepart(self, input: Vector, exclude_holes: bool = False) -> Vector: ...

def multiply_overlay(self, input_rasters: List[Raster]) -> Raster: ...

# Requires WbW-Pro license
def multiscale_curvatures(self, dem: Raster, curv_type: str = 'profile', min_scale: int = 4, step_size: int = 1, num_steps: int = 10, step_nonlinearity: float = 1.0, log_transform: bool = True, standardize: bool = False) -> Tuple[Raster, Raster]: ...

def multiscale_elevation_percentile(self, dem: Raster, num_significant_digits: int = 3, min_scale: int = 4, step_size: int = 1, num_steps: int = 10, step_nonlinearity: float = 1.0) -> Tuple[Raster, Raster]: ...

def multiscale_roughness(self, dem: Raster, min_scale: int = 1, max_scale: int = 100, step_size: int = 1) -> Tuple[Raster, Raster]: ...

def multiscale_roughness_signature(self, dem: Raster, points: Vector, output_html_file: str, min_scale: int = 1, max_scale: int = 100, step_size: int = 1) -> None: ...

def multiscale_std_dev_normals(self, dem: Raster, min_scale: int = 4, step_size: int = 1, num_steps: int = 10, step_nonlinearity: float = 1.0, html_signature_file: str = "") -> Tuple[Raster, Raster]: ...

def multiscale_std_dev_normals_signature(self, dem: Raster, points: Vector, output_html_file: str, min_scale: int = 4, step_size: int = 1, num_steps: int = 10, step_nonlinearity: float = 1.0) -> None: ...

def multiscale_topographic_position_image(self, local: Raster, meso: Raster, broad: Raster, hillshade: Optional[Raster] = None, lightness: float = 1.2) -> Raster: ...

def narrowness_index(self, raster: Raster) -> Raster: ...

def natural_neighbour_interpolation(self, points: Vector, field_name: str = "FID", use_z: bool = False, cell_size: float = 0.0, base_raster: Optional[Raster] = None, clip_to_hull: bool = True) -> Raster: ...

def nearest_neighbour_interpolation(self, points: Vector, field_name: str = "FID", use_z: bool = False, cell_size: float = 0.0, base_raster: Optional[Raster] = None, max_dist: float = float('inf')) -> Raster: ...

def new_raster_from_base_raster(self, base: Raster, out_val: float = float('nan'), data_type: str = "float") -> Raster: ...

def new_raster_from_base_vector(self, base: Vector, cell_size: float, out_val: float = float('nan'), data_type: str = "float") -> Raster: ...

# Requires WbW-Pro license
def nibble(self, input_raster: Raster, mask: Raster, use_nodata: bool = False, nibble_nodata: bool = True) -> Raster: ...

def normal_vectors(self, input: Lidar, search_radius: float = -1.0) -> Lidar: ...

def normalized_difference_index(self, nir_image: Raster, red_image: Raster, clip_percent: float = 0.0, correction_value: float = 0.0) -> Raster: ...

def normalize_lidar(self, input_lidar: Lidar, dtm: Raster) -> Lidar: ...

def num_downslope_neighbours(self, dem: Raster) -> Raster: ...

def num_inflowing_neighbours(self, dem: Raster) -> Raster: ...

def olympic_filter(self, raster: Raster, filter_size_x: int = 11, filter_size_y: int = 11) -> Raster: ...

def opening(self, raster: Raster, filter_size_x: int = 11, filter_size_y: int = 11) -> Raster: ...

# Requires WbW-Pro license
def openness(self, dem: Raster, dist: int = 20) -> Tuple[Raster, Raster]: ...

def otsu_thresholding(self, raster: Raster) -> Raster: ...

def paired_sample_t_test(self, raster1: Raster, raster2: Raster, output_html_file: str, num_samples: int) -> None: ...

def panchromatic_sharpening(self, pan: Raster, colour_composite: Raster, red: Raster, green: Raster, blue: Raster, fusion_method: str = "brovey") -> Raster: ...

# Requires WbW-Pro license
def parallelepiped_classification(self, input_rasters: List[Raster], training_data: Vector, class_field_name: str) -> Raster: ...

def patch_orientation(self, input: Vector) -> Vector: ...

def pennock_landform_classification(self, dem: Raster, slope_threshold: float = 3.0, prof_curv_threshold: float = 0.1, plan_curv_threshold: float = 0.0, z_factor: float = 1.0) -> Tuple[Raster, str]: ...

def percent_elev_range(self, dem: Raster, filter_size_x: int = 11, filter_size_y: int = 11) -> Raster: ...

def percent_equal_to(self, input_rasters: List[Raster], comparison: Raster) -> Raster: ...

def percent_greater_than(self, input_rasters: List[Raster], comparison: Raster) -> Raster: ...

def percent_less_than(self, input_rasters: List[Raster], comparison: Raster) -> Raster: ...

def percentage_contrast_stretch(self, raster: Raster, clip: float = 1.0, tail: str = "both", num_tones: int = 256) -> Raster: ...

def percentile_filter(self, raster: Raster, filter_size_x: int = 11, filter_size_y: int = 11, sig_digits: int = 2) -> Raster: ...

def perimeter_area_ratio(self, input: Vector) -> Vector: ...

# Requires WbW-Pro license
def phi_coefficient(self, raster1: Raster, raster2: Raster, output_html_file: str) -> None: ...

def pick_from_list(self, input_rasters: List[Raster], pos_input: Raster) -> Raster: ...

# Requires WbW-Pro license
def piecewise_contrast_stretch(self, raster: Raster, transformation_statement: str, num_greytones: float = 1024.0) -> Raster: ...

def plan_curvature(self, dem: Raster, log_transform: bool = False, z_factor: float = 1.0) -> Raster: ...

def polygon_area(self, input: Vector) -> Vector: ...

def polygon_long_axis(self, input: Vector) -> Vector: ...

def polygon_perimeter(self, input: Vector) -> Vector: ...

def polygon_short_axis(self, input: Vector) -> Vector: ...

def polygonize(self, input_layers: List[Vector]) -> Vector: ...

def polygons_to_lines(self, input: Vector) -> Vector: ...

def prewitt_filter(self, raster: Raster, clip_tails: float = 0.0) -> Raster: ...

def principal_component_analysis(self, rasters: List[Raster], output_html_file: str, num_components: int = 2, standardized: bool = False) -> List[Raster]: ...

def print_geotiff_tags(self, file_name: str) : ...

def profile(self, lines_vector: Vector, surface: Raster, output_html_file: str) -> None: ...

def profile_curvature(self, dem: Raster, log_transform: bool = False, z_factor: float = 1.0) -> Raster: ...

# Requires WbW-Pro license
def prune_vector_streams(self, streams: Vector, dem: Raster, threshold: float, snap_distance: float = 0.001) -> Vector: ...

def qin_flow_accumulation(self, dem: Raster, out_type: str = "SCA", exponent: float = 10.0, max_slope: float = 45.0, convergence_threshold: float = float('inf'), log_transform: bool = False, clip: bool = False) -> Raster: ...

def quantiles(self, raster: Raster, num_quantiles: int = 5) -> Raster: ...

def quinn_flow_accumulation(self, dem: Raster, out_type: str = "SCA", exponent: float = 1.1, convergence_threshold: float = float('inf'), log_transform: bool = False, clip: bool = False) -> Raster: ...

def radial_basis_function_interpolation(self, points: Vector, field_name: str = "FID", use_z: bool = False, radius: float = 0.0, min_points: int = 0, cell_size: float = 0.0, base_raster: Optional[Raster] = None, func_type: str = "ThinPlateSpline", poly_order: str = "none", weight: float = 0.1) -> Raster: ...

def radius_of_gyration(self, raster: Raster) -> Tuple[Raster, str]: ...

def raise_walls(self, dem: Raster, walls: Vector, breach_lines: Vector, wall_height: float = 100.0) -> Raster: ...

def random_field(self, base_raster: Optional[Raster] = None) -> Raster: ...

# Requires WbW-Pro license
def random_forest_classification_fit(self, input_rasters: List[Raster], training_data: Vector, class_field_name: str, split_criterion: str = "Gini", n_trees: int = 200,  min_samples_leaf: int = 1, min_samples_split: int = 2, test_proportion: float = 0.2) -> List[int]: ...

# Requires WbW-Pro license
def random_forest_classification_predict(self, input_rasters: List[Raster], model_bytes: List[int]) -> Raster: ...

# Requires WbW-Pro license
def random_forest_regression_fit(self, input_rasters: List[Raster], training_data: Vector, field_name: str, n_trees: int = 200,  min_samples_leaf: int = 1, min_samples_split: int = 2, test_proportion: float = 0.2) -> List[int]: ...

# Requires WbW-Pro license
def random_forest_regression_predict(self, input_rasters: List[Raster], model_bytes: List[int]) -> Raster: ...

def random_sample(self, base_raster: Optional[Raster] = None, num_samples: int = 1000) -> Raster: ...

def range_filter(self, raster: Raster, filter_size_x: int = 11, filter_size_y: int = 11) -> Raster: ...

def raster_area(self, raster: Raster, units: str = "map units", zero_background: bool = False) -> Tuple[Raster, str]: ...

def raster_calculator(self, expression: str, input_rasters: List[Raster]) -> Raster: ...

def raster_cell_assignment(self, raster: Raster, what_to_assign: str = "column") -> Raster: ...

def raster_histogram(self, raster: Raster, output_html_file: str, num_bins: Optional[int] = None) -> None: ...

def raster_perimeter(self, raster: Raster, units: str = "map units", zero_background: bool = False) -> Tuple[Raster, str]: ...

def raster_streams_to_vector(self, streams: Raster, d8_pointer: Raster, esri_pointer: bool = False, all_vertices: bool = False) -> Vector: ...

def raster_summary_stats(self, input: Raster) -> str: ...

def raster_to_vector_lines(self, raster: Raster) -> Vector: ...

def raster_to_vector_points(self, raster: Raster) -> Vector: ...

def raster_to_vector_polygons(self, raster: Raster) -> Vector: ...

def rasterize_streams(self, streams: Vector, base_raster: Optional[Raster] = None, zero_background: bool = False, use_feature_id: bool = False) -> Raster: ...

def reciprocal(self, raster: Raster) -> Raster: ...

def reclass(self, raster: Raster, reclass_values: List[List[float]], assign_mode: bool = False) -> Raster: ...

def reclass_equal_interval(self, raster: Raster, interval_size: float, start_value: float = float('-inf'), end_value: float = float('inf')) -> Raster: ...

# Requires WbW-Pro license
def reconcile_multiple_headers(self, input: Vector, region_field_name: str, yield_field_name: str, radius: float, min_yield: float = float('-inf'),  max_yield: float = float('inf'), mean_tonnage: float = float('-inf')) -> Vector: ...

# Requires WbW-Pro license
def recover_flightline_info(self, input: Lidar, max_time_diff: float = 5.0, pt_src_id: bool = False, user_data: bool = False, rgb: bool = False) -> Lidar: ...

# Requires WbW-Pro license
def recreate_pass_lines(self, input: Vector, yield_field_name: str, max_change_in_heading: float = 25.0, ignore_zeros: bool = False) -> Tuple[Vector, Vector]: ...

def rectangular_grid_from_raster_base(self, base: Raster, width: float, height: float, x_origin: float = 0.0, y_origin: float = 0.0) -> Vector: ...

def rectangular_grid_from_vector_base(self, base: Vector, width: float, height: float, x_origin: float = 0.0, y_origin: float = 0.0) -> Vector: ...

def reinitialize_attribute_table(self, input: Vector) -> None: ...

def related_circumscribing_circle(self, input: Vector) -> Vector: ...

def relative_aspect(self, dem: Raster, azimuth: float = 0.0, z_factor: float = 1.0) -> Raster: ...

def relative_stream_power_index(self, specific_catchment_area: Raster, slope: Raster, exponent: float = 1.0) -> Raster: ...

def relative_topographic_position(self, dem: Raster, filter_size_x: int = 11, filter_size_y: int = 11) -> Raster: ...

def remove_duplicates(self, input: Lidar, include_z: bool = False) -> Lidar: ...

# Requires WbW-Pro license
def remove_field_edge_points(self, input: Vector, radius: float,  max_change_in_heading: float = 25.0, flag_edges: bool = False) -> Vector: ...

def remove_off_terrain_objects(self, dem: Raster, filter_size: int = 11, slope_threshold: float = 15.0) -> Raster: ...

def remove_polygon_holes(self, input: Vector) -> Vector: ...

# Requires WbW-Pro license
def remove_raster_polygon_holes(self, input: Raster, threshold_size: int = sys.maxsize, use_diagonals: bool = False) -> Raster: ...

def remove_short_streams(self, d8_pntr: Raster, streams_raster: Raster, min_length: float = 0.0, esri_pntr: bool = False) -> Raster: ...

def remove_spurs(self, raster: Raster, max_iterations: int = 10) -> Raster: ...

def repair_stream_vector_topology(self, input: Vector, snap_dist: float) -> Vector: ...

def resample(self, input_rasters: List[Raster], cell_size: float = 0.0, base_raster: Optional[Raster] = None, method: str = "cc") -> Raster: ...

def rescale_value_range(self, raster: Raster, out_min_val: float, out_max_val: float, clip_min: float = float('inf'), clip_max: float = float('-inf')) -> Raster: ...

def rgb_to_ihs(self, red: Optional[Raster] = None, green: Optional[Raster] = None, blue: Optional[Raster] = None, composite: Optional[Raster] = None) -> Tuple[Raster, Raster, Raster]: ...

def rho8_flow_accum(self, raster: Raster, out_type: str = "SCA", log_transform: bool = False, clip: bool = False, input_is_pointer: bool = False, esri_pntr: bool = False) -> Raster: ...

def rho8_pointer(self, dem: Raster, esri_pntr: bool = False) -> Raster: ...

# Requires WbW-Pro license
def ridge_and_valley_vectors(self, dem: Raster, filter_size: int = 11, ep_threshold: float = 30.0, slope_threshold: float = 0.0, min_length: int = 20) -> Tuple[Vector, Vector]: ...

# Requires WbW-Pro license
def ring_curvature(self, dem: Raster, log_transform: bool = False, z_factor: float = 1.0) -> Raster: ...

# Requires WbW-Pro license
def river_centerlines(self, raster: Raster, min_length: int = 3, search_radius: int = 9) -> Vector: ...

def roberts_cross_filter(self, raster: Raster, clip_amount: float = 0.0) -> Raster: ...

def root_mean_square_error(self, input: Raster, reference: Raster) -> str: ...

# Requires WbW-Pro license
def rotor(self, dem: Raster, log_transform: bool = False, z_factor: float = 1.0) -> Raster: ...

def ruggedness_index(self, input: Raster) -> Raster: ...

def scharr_filter(self, raster: Raster, clip_tails: float = 0.0) -> Raster: ...

def sediment_transport_index(self, specific_catchment_area: Raster, slope: Raster, sca_exponent: float = 0.4, slope_exponent: float = 1.3) -> Raster: ...

def select_tiles_by_polygon(self, input_directory: str, output_directory: str, polygons: Vector) -> None: ...

def set_nodata_value(self, raster: Raster, back_value: float = 0.0) -> Raster: ...

# Requires WbW-Pro license
def shadow_animation(self, dem: Raster, output_html_file: str,  palette: WbPalette = WbPalette.Soft, max_dist: float = float('inf'), date: str = "21/06/2021", time_interval: int = 30, location: str = "43.5448/-80.2482/-4", image_height: int = 600, delay: int = 250, label: str = "") -> None: ...

# Requires WbW-Pro license
def shadow_image(self, dem: Raster, palette: WbPalette = WbPalette.Soft, max_dist: float = float('inf'), date: str = "21/06/2021", time: str = "13:00", location: str = "43.5448/-80.2482/-4") -> Raster: ...

def shape_complexity_index_raster(self, raster: Raster) -> Raster: ...

def shape_complexity_index_vector(self, input: Vector) -> Vector: ...

# Requires WbW-Pro license
def shape_index(self, dem: Raster, z_factor: float = 1.0) -> Raster: ...

def shreve_stream_magnitude(self, d8_pntr: Raster, streams_raster: Raster, esri_pntr: bool = False, zero_background: bool = False) -> Raster: ...

# Requires WbW-Pro license
def sieve(self, input_raster: Raster, threshold: int = 1, zero_background: bool = False) -> Raster: ...

def sigmoidal_contrast_stretch(self, raster: Raster, cutoff: float = 0.0, gain: float = 1.0, num_tones: int = 256) -> Raster: ...

def singlepart_to_multipart(self, input: Vector, field_name: str) -> Vector: ...

def sink(self, dem: Raster, zero_background: bool = False) -> Raster: ...

# Requires WbW-Pro license
def skyline_analysis(self, dem: Raster, points: Vector, output_html_file: str, max_dist: float = float('inf'), observer_hgt_offset: float = 0.0, output_as_polygons: bool = True, az_fraction: float = 1.0) -> Vector: ...

# Requires WbW-Pro license
def sky_view_factor(self, dem: Raster, az_fraction: float = 5.0, max_dist: float = float('inf'), observer_hgt_offset: float = 0.05) -> Raster: ...

def slope(self, dem: Raster, units: str = "degrees", z_factor: float = 1.0) -> Raster: ...

# Requires WbW-Pro license
def slope_vs_aspect_plot(self, dem: Raster, output_html_file: str, aspect_bin_size: float = 2.0, min_slope: float = 0.1, z_factor: float = 1.0) -> None: ...

def slope_vs_elev_plot(self, dem_rasters: List[Raster], output_html_file: str, watershed_rasters: List[Raster]) -> None: ...

def smooth_vectors(self, input: Vector, filter_size: int = 3) -> Vector: ...

# Requires WbW-Pro license
def smooth_vegetation_residual(self, dem: Raster, max_scale: int = 1, dev_threshold: float = 1.0, scale_threshold: int = 5) -> Raster: ...

def snap_pour_points(self, pour_pts: Vector, flow_accum: Raster, snap_dist: float = 0.0) -> Vector: ...

def sobel_filter(self, raster: Raster, variant: str = "3x3", clip_tails: float = 0.0) -> Raster: ...

# Requires WbW-Pro license
def sort_lidar(self, sort_criteria: str, input_lidar: Optional[Lidar]) -> Optional[Lidar]: ...

def spherical_std_dev_of_normals(self, dem: Raster, filter_size: int = 11) -> Raster: ...

def split_colour_composite(self, composite_image: Raster) -> Tuple[Raster, Raster, Raster]: ...

# Requires WbW-Pro license
def split_lidar(self, split_criterion: str, input_lidar: Optional[Lidar], interval: float = 5.0, min_pts: int = 5) -> None: ...

def split_vector_lines(self, input: Vector, segment_length: float) -> Vector: ...

def split_with_lines(self, input: Vector, split_vector: Vector) -> Vector: ...

def standard_deviation_contrast_stretch(self, raster: Raster, clip: float = 2.0, num_tones: int = 256) -> Raster: ...

def standard_deviation_filter(self, raster: Raster, filter_size_x: int = 11, filter_size_y: int = 11) -> Raster: ...

def standard_deviation_of_slope(self, dem: Raster, filter_size: int = 11, z_factor: float = 1.0) -> Raster: ...

def standard_deviation_overlay(self, input_rasters: List[Raster]) -> Raster: ...

def stochastic_depression_analysis(self, dem: Raster, rmse: float, range: float, iterations: int = 100) -> Raster: ...

def strahler_order_basins(self, d8_pointer: Raster, streams: Raster, esri_pntr: bool = False) -> Raster: ...

def strahler_stream_order(self, d8_pntr: Raster, streams_raster: Raster, esri_pntr: bool = False, zero_background: bool = False) -> Raster: ...

def stream_link_class(self, d8_pntr: Raster, streams_raster: Raster, esri_pntr: bool = False, zero_background: bool = False) -> Raster: ...

def stream_link_identifier(self, d8_pntr: Raster, streams_raster: Raster, esri_pntr: bool = False, zero_background: bool = False) -> Raster: ...

def stream_link_length(self, d8_pointer: Raster, streams_id_raster: Raster, esri_pointer: bool = False, zero_background: bool = False) -> Raster: ...

def stream_link_slope(self, d8_pointer: Raster, streams_id_raster: Raster, dem: Raster, esri_pointer: bool = False, zero_background: bool = False) -> Raster: ...

def stream_slope_continuous(self, d8_pointer: Raster, streams_raster: Raster, dem: Raster, esri_pointer: bool = False, zero_background: bool = False) -> Raster: ...

def subbasins(self, d8_pntr: Raster, streams: Raster, esri_pntr: bool = False) -> Raster: ...

def sum_overlay(self, input_rasters: List[Raster]) -> Raster: ...

def surface_area_ratio(self, dem: Raster) -> Raster: ...

# Requires WbW-Pro license
def svm_classification(self, input_rasters: List[Raster], training_data: Vector, class_field_name: str, scaling_method: str = "none", c_value: float = 50.0, kernel_gamma: float = 0.5, tolerance: float = 0.1, test_proportion: float = 0.2, create_output: bool = False) -> Optional[Raster]: ...

# Requires WbW-Pro license
def svm_regression(self, input_rasters: List[Raster], training_data: Vector, class_field_name: str, scaling_method: str = "none", c_value: float = 50.0, epsilon_value: float = 10.0, kernel_gamma: float = 0.5, test_proportion: float = 0.2, create_output: bool = False) -> Optional[Raster]: ...

def symmetrical_difference(self, input: Vector, overlay: Vector, snap_tolerance: float = 2.220446049250313e-16) -> Vector: ...

def tangential_curvature(self, dem: Raster, log_transform: bool = False, z_factor: float = 1.0) -> Raster: ...

def thicken_raster_line(self, raster: Raster) -> Raster: ...

def time_in_daylight(self, dem: Raster, az_fraction: float = 5.0, max_dist: float = float('inf'), latitude: float = 0.0, longitude: float = 0.0, utc_offset_str: str = "UTC+00:00", start_day: int = 1, end_day: int = 365, start_time: str = "sunrise", end_time: str = "sunset") -> Raster: ...

def tin_interpolation(self, points: Vector, field_name: str = "FID", use_z: bool = False, cell_size: float = 0.0, base_raster: Optional[Raster] = None, max_triangle_edge_length: float = float('inf')) -> Raster: ...

def tophat_transform(self, raster: Raster, filter_size_x: int = 11, filter_size_y: int = 11, variant: str = "white") -> Raster: ...

# Requires WbW-Pro license
def topological_breach_burn(self, streams: Vector, dem: Raster, snap_distance: float = 0.001) -> Tuple[Raster, Raster, Raster, Raster]: ...

def topological_stream_order(self, d8_pntr: Raster, streams_raster: Raster, esri_pntr: bool = False, zero_background: bool = False) -> Raster: ...

def topographic_hachures(self, dem: Raster, contour_interval: float = 10.0, base_contour: float = 0.0, deflection_tolerance: float = 10.0, filter_size: int = 9, separation: float = 2.0, distmin: float = 0.5, distmax: float = 2.0, discretization: float = 0.5, turnmax: float = 45.0, slopemin: float = 0.5, depth: int = 16) -> Vector: ...

# Requires WbW-Pro license
def topo_render(self, dem: Raster, palette: WbPalette = WbPalette.Soft, reverse_palette: bool = False,  azimuth: float = 315.0, altitude: float = 30.0, clipping_polygon: Optional[Vector] = None, background_hgt_offset: float = 10.0, background_clr: Tuple[int, int, int, int] = (255, 255, 255, 255), attenuation_parameter: float = 0.3,  ambient_light: float = 0.2, z_factor: float = 1.0) -> Raster: ...

# Requires WbW-Pro license
def topographic_position_animation(self, dem: Raster, output_html_file: str = "topo_pos.html", palette: WbPalette = WbPalette.Soft,  min_scale: int = 1, num_steps: int = 1, step_nonlinearity: float = 1.0, image_height: int = 600, delay: int = 250, label: str = "", use_dev_max: bool = False) -> None: ...

def total_curvature(self, dem: Raster, log_transform: bool = False, z_factor: float = 1.0) -> Raster: ...

def total_filter(self, raster: Raster, filter_size_x: int = 11, filter_size_y: int = 11) -> Raster: ...

def trace_downslope_flowpaths(self, seed_points: Vector, d8_pointer: Raster, esri_pntr: bool = False, zero_background: bool = False) -> Raster: ...

def travelling_salesman_problem(self, input: Vector, duration: int = 60) -> Vector: ...

def trend_surface(self, raster: Raster, output_html_file: str, polynomial_order: int = 1) -> Raster: ...

def trend_surface_vector_points(self, input: Vector, cell_size: float, output_html_file: str, field_name: str = "FID", polynomial_order: int = 1) -> Raster: ...

def tributary_identifier(self, d8_pntr: Raster, streams_raster: Raster, esri_pntr: bool = False, zero_background: bool = False) -> Raster: ...

def turning_bands_simulation(self, base_raster: Optional[Raster] = None, range: float = 1.0, iterations: int = 1000) -> Raster: ...

def two_sample_ks_test(self, raster1: Raster, raster2: Raster, output_html_file: str, num_samples: int) -> None: ...

def union(self, input: Vector, overlay: Vector, snap_tolerance: float = 2.220446049250313e-16) -> Vector: ...

def unnest_basins(self, d8_pointer: Raster, pour_points: Vector, esri_pntr: bool = False) -> List[Raster]: ...

def unsharp_masking(self, raster: Raster, sigma: float = 0.75, amount: float = 100.0, threshold: float = 0.0) -> Raster: ...

# Requires WbW-Pro license
def unsphericity(self, dem: Raster, log_transform: bool = False, z_factor: float = 1.0) -> Raster: ...

def update_nodata_cells(self, input1: Raster, input2: Raster) -> Raster: ...

def upslope_depression_storage(self, dem: Raster) -> Raster: ...

def user_defined_weights_filter(self, raster: Raster, weights: List[List[float]], kernel_center: str = "center", normalize_weights: bool = False) -> Raster: ...

def vector_hex_binning(self, vector_points: Vector, width: float, orientation: str = "horizontal") -> Vector: ...

def vector_lines_to_raster(self, input: Vector, field_name: str = "FID", zero_background: bool = False, cell_size: float = 0.0, base_raster: Optional[Raster] = None) -> Raster: ...

def vector_points_to_raster(self, input: Vector, field_name: str = "FID", assign_op: str = "last", zero_background: bool = False, cell_size: float = 0.0, base_raster: Optional[Raster] = None) -> Raster: ...

def vector_polygons_to_raster(self, input: Vector, field_name: str = "FID", zero_background: bool = False, cell_size: float = 0.0, base_raster: Optional[Raster] = None) -> Raster: ...

# Requires WbW-Pro license
def vertical_excess_curvature(self, dem: Raster, log_transform: bool = False, z_factor: float = 1.0) -> Raster: ...

def vector_stream_network_analysis(self, streams: Vector, dem: Raster, max_ridge_cutting_height: float = 10.0, snap_distance: float = 0.001) -> Tuple[Vector, Vector, Vector, Vector]: ...

def viewshed(self, dem: Raster, station_points: Vector, station_height: float = 2.0) -> Raster: ...

def visibility_index(self, dem: Raster, station_height: float = 2.0, resolution_factor: int = 8) -> Raster: ...

def voronoi_diagram(self, input_points: Vector) -> Vector: ...

def watershed(self, d8_pointer: Raster, pour_points: Vector, esri_pntr: bool = False) -> Raster: ...

def watershed_from_raster_pour_points(self, d8_pointer: Raster, pour_points: Raster, esri_pntr: bool = False) -> Raster: ...

def weighted_overlay(self, factors: List[Raster], weights: List[float], cost: Optional[List[Raster]] = None, constraints: Optional[List[Raster]] = None, scale_max: float = 1.0) -> Raster: ...

def weighted_sum(self, input_rasters: List[Raster], weights: List[float]) -> Raster: ...

def wetness_index(self, specific_catchment_area: Raster, slope: Raster) -> Raster: ...

def wilcoxon_signed_rank_test(self, raster1: Raster, raster2: Raster, output_html_file: str, num_samples: int) -> None: ...

def write_function_memory_insertion(self, image1: Raster, image2: Raster, image3: Raster) -> Raster: ...

# Requires WbW-Pro license
def yield_filter(self, input: Vector, yield_field_name: str, pass_field_name: str,  swath_width: float = 6.096, z_score_threshold: float = 2.5, min_yield: float = 0.0, max_yield: float = float('inf')) -> Vector: ...

# Requires WbW-Pro license
def yield_map(self, input: Vector, pass_field_name: str, swath_width: float = 6.096, max_change_in_heading: float = 25.0) -> Vector: ...

# Requires WbW-Pro license
def yield_normalization(self, input: Vector, yield_field_name: str,  radius: float, standardize: bool = False, min_yield: float = 0.0, max_yield: float = float('inf')) -> Vector: ...

def z_scores(self, raster: Raster) -> Raster: ...

def zonal_statistics(self, data_raster: Raster, feature_definitions_raster: Raster, stat_type: str = "mean", zero_is_background: bool = False) -> Tuple[Raster, str]: ...

class WbPalette

Atlas: int
HighRelief: int
Arid: int
Earthtones: int
Soft: int
Muted: int
LightQuant: int
Turbo: int
Purple: int
Viridis: int
GreenYellow: int
PinkYellowGreen: int
BlueYellowRed: int
Deep: int
Imhof: int
White: int
Grey: int
def get_palette(self) -> List[Tuple[float]]: ...

def get_normalized_palette(self) -> List[Tuple[float]]: ...

def reverse(sel) -> List[Tuple[float]]: ...