def __init__(self,
                 ratio=None,
                 radius=None,
                 down_conv_nn=None,
                 kp_points=16,
                 nb_feature=0,
                 *args,
                 **kwargs):
        super(KPConv, self).__init__(FPSSampler(ratio),
                                     RadiusNeighbourFinder(radius), *args,
                                     **kwargs)

        self.ratio = ratio
        self.radius = radius

        in_features, out_features = down_conv_nn

        # KPCONV arguments
        self.in_features = in_features
        self.out_features = out_features
        self.kp_points = kp_points

        self._conv = PointKernel(self.kp_points,
                                 self.in_features,
                                 self.out_features,
                                 radius=self.radius)
    def __init__(self,
                 ratio=None,
                 radius=None,
                 down_conv_nn=None,
                 kp_points=16,
                 nb_feature=0,
                 *args,
                 **kwargs):
        super(ResidualBKPConv, self).__init__(FPSSampler(ratio),
                                              RadiusNeighbourFinder(radius),
                                              *args, **kwargs)

        self.ratio = ratio
        self.radius = radius
        self.max_num_neighbors = kwargs.get("max_num_neighbors", 64)

        in_features, out_features = down_conv_nn

        # KPCONV arguments
        self.in_features = in_features
        self.out_features = out_features
        self.kp_points = kp_points

        self.pre_mlp = nn.Linear(self.in_features, self.in_features // 2)
        self._conv = PointKernel(
            self.kp_points,
            self.in_features // 2,
            self.in_features // 2,
            radius=self.radius,
        )
        self.post_mlp = nn.Linear(self.in_features // 2, out_features)

        self.shortcut_mlp = nn.Linear(self.in_features, self.out_features)
Example #3
0
    def __init__(
        self,
        inN=None,
        outN=None,
        K=None,
        D=None,
        C1=None,
        C2=None,
        hidden_channel=None,
        *args,
        **kwargs,
    ):
        super(PointCNNConvDown, self).__init__(FPSSampler(outN / inN),
                                               DilatedKNNNeighbourFinder(K, D))

        self._conv = XConv(C1, C2, 3, K, hidden_channels=hidden_channel)
    def __init__(self,
                 ratio=None,
                 radius=None,
                 down_conv_nn=None,
                 kp_points=16,
                 nb_feature=0,
                 is_strided=True,
                 kp_extent=1,
                 density_parameter=1,
                 *args,
                 **kwargs):
        super(BaseKPConvPartialDense, self).__init__(
            FPSSampler(ratio),
            RadiusNeighbourFinder(radius,
                                  max_num_neighbors=kwargs.get(
                                      "max_num_neighbors", 64),
                                  conv_type=self.CONV_TYPE), *args, **kwargs)

        self.ratio = ratio
        self.radius = radius
        self.is_strided = is_strided

        if len(down_conv_nn) == 2:
            in_features, out_features = down_conv_nn
            intermediate_features = None

        elif len(down_conv_nn) == 3:
            in_features, intermediate_features, out_features = down_conv_nn

        else:
            raise NotImplementedError

        # KPCONV arguments
        self.in_features = in_features
        self.out_features = out_features
        self.intermediate_features = intermediate_features
        self.kp_points = kp_points

        # Dataset ~ Model parameters
        self.kp_extent = kp_extent
        self.density_parameter = density_parameter

        # PARAMTERS IMPORTANT FOR SHADOWING
        self.shadow_features_fill = 0.0
        self.shadow_points_fill_ = float(10e6)
Example #5
0
    def __init__(self,
                 ratio=None,
                 radius=None,
                 radius_num_point=None,
                 down_conv_nn=None,
                 nb_feature=None,
                 *args,
                 **kwargs):
        super(SAModule, self).__init__(
            FPSSampler(ratio=ratio),
            MultiscaleRadiusNeighbourFinder(
                radius, max_num_neighbors=radius_num_point), *args, **kwargs)

        local_nn = MLP(down_conv_nn) if down_conv_nn is not None else None

        self._conv = PointConv(local_nn=local_nn, global_nn=None)
        self._radius = radius
        self._ratio = ratio
        self._num_points = radius_num_point