terrainseg.utils.lsps

Classes

gaussPyramids	Base class for all neural network modules.
lspCalc	Base class for all neural network modules.
lspModule	Base class for all neural network modules.

Module Contents

class terrainseg.utils.lsps.gaussPyramids(inChn: int, spatDims: int, device=None, dtype=torch.float32)

Bases: torch.nn.Module

Base class for all neural network modules.

Your models should also subclass this class.

Modules can also contain other Modules, allowing them to be nested in a tree structure. You can assign the submodules as regular attributes:

import torch.nn as nn
import torch.nn.functional as F


class Model(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.conv2 = nn.Conv2d(20, 20, 5)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        return F.relu(self.conv2(x))

Submodules assigned in this way will be registered, and will also have their parameters converted when you call to(), etc.

Note

As per the example above, an __init__() call to the parent class must be made before assignment on the child.

Variables:

training (bool) – Boolean represents whether this module is in training or evaluation mode.

inChn

spatDims

forward(x: torch.Tensor) → torch.Tensor

x: [N, C, H, W] (H=W should match spatDims for the mask as written) returns: [N, 5*C, H, W] (concatenation of 5 pyramid levels along channel dim)

class terrainseg.utils.lsps.lspCalc(cellSize: float = 1.0, innerRadius: int = 2, outerRadius: int = 5, hsRadius: int = 50, smoothRadius: int = 11, doTPIHS: bool = True, device=None, dtype=torch.float32)

Bases: torch.nn.Module

Base class for all neural network modules.

Your models should also subclass this class.

Modules can also contain other Modules, allowing them to be nested in a tree structure. You can assign the submodules as regular attributes:

import torch.nn as nn
import torch.nn.functional as F


class Model(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.conv2 = nn.Conv2d(20, 20, 5)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        return F.relu(self.conv2(x))

Submodules assigned in this way will be registered, and will also have their parameters converted when you call to(), etc.

Note

As per the example above, an __init__() call to the parent class must be made before assignment on the child.

Variables:

training (bool) – Boolean represents whether this module is in training or evaluation mode.

cellSize

innerRadius = 2

outerRadius = 5

hsRadius = 50

smoothRadius = 11

doTPIHS = True

forward(inDTM: torch.Tensor) → torch.Tensor

inDTM: [N, 1, H, W] :returns: [N, 6, H, W] (tpiHS, slp, tpiL, hillshade, crvPro, crvPln)

else: [N, 5, H, W] (slp, tpiL, hillshade, crvPro, crvPln)

Return type:

if doTPIHS

class terrainseg.utils.lsps.lspModule(cell_size: float = 1.0, spat_dim: int = 640, do_gp: bool = False, inner_radius: float = 2.0, outer_radius: float = 10.0, hs_radius: float = 50.0, smooth_radius: float = 11.0)

Bases: torch.nn.Module

Base class for all neural network modules.

Your models should also subclass this class.

Modules can also contain other Modules, allowing them to be nested in a tree structure. You can assign the submodules as regular attributes:

import torch.nn as nn
import torch.nn.functional as F


class Model(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.conv2 = nn.Conv2d(20, 20, 5)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        return F.relu(self.conv2(x))

Submodules assigned in this way will be registered, and will also have their parameters converted when you call to(), etc.

Note

As per the example above, an __init__() call to the parent class must be made before assignment on the child.

Variables:

training (bool) – Boolean represents whether this module is in training or evaluation mode.

cell_size = 1.0

spat_dim = 640

do_gp = False

inner_radius = 2.0

outer_radius = 10.0

hs_radius = 50.0

smooth_radius = 11.0

in_channels = 6

gaussPyramid

lspOrig

lspGP

forward(x: torch.Tensor) → torch.Tensor

x: torch.Tensor [B, 1, H, W] (typical) or whatever lspOrig expects.