learning3d 0.0.1__py3-none-any.whl

learning3d/utils/transformer.py

@@ -0,0 +1,243 @@
+import os
+import sys
+import glob
+import h5py
+import copy
+import math
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+# Part of the code is referred from: http://nlp.seas.harvard.edu/2018/04/03/attention.html#positional-encoding
+
+def clones(module, N):
+    return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])
+
+def attention(query, key, value, mask=None, dropout=None):
+    d_k = query.size(-1)
+    scores = torch.matmul(query, key.transpose(-2, -1).contiguous()) / math.sqrt(d_k)
+    if mask is not None:
+        scores = scores.masked_fill(mask == 0, -1e9)
+    p_attn = F.softmax(scores, dim=-1)
+    return torch.matmul(p_attn, value), p_attn
+
+def nearest_neighbor(src, dst):
+    inner = -2 * torch.matmul(src.transpose(1, 0).contiguous(), dst)  # src, dst (num_dims, num_points)
+    distances = -torch.sum(src ** 2, dim=0, keepdim=True).transpose(1, 0).contiguous() - inner - torch.sum(dst ** 2,
+                                                                                                           dim=0,
+                                                                                                           keepdim=True)
+    distances, indices = distances.topk(k=1, dim=-1)
+    return distances, indices
+
+
+class EncoderDecoder(nn.Module):
+    """
+    A standard Encoder-Decoder architecture. Base for this and many
+    other models.
+    """
+
+    def __init__(self, encoder, decoder, src_embed, tgt_embed, generator):
+        super(EncoderDecoder, self).__init__()
+        self.encoder = encoder
+        self.decoder = decoder
+        self.src_embed = src_embed
+        self.tgt_embed = tgt_embed
+        self.generator = generator
+
+    def forward(self, src, tgt, src_mask, tgt_mask):
+        "Take in and process masked src and target sequences."
+        return self.decode(self.encode(src, src_mask), src_mask,
+                           tgt, tgt_mask)
+
+    def encode(self, src, src_mask):
+        return self.encoder(self.src_embed(src), src_mask)
+
+    def decode(self, memory, src_mask, tgt, tgt_mask):
+        return self.generator(self.decoder(self.tgt_embed(tgt), memory, src_mask, tgt_mask))
+
+
+class Generator(nn.Module):
+    def __init__(self, emb_dims):
+        super(Generator, self).__init__()
+        self.nn = nn.Sequential(nn.Linear(emb_dims, emb_dims // 2),
+                                nn.BatchNorm1d(emb_dims // 2),
+                                nn.ReLU(),
+                                nn.Linear(emb_dims // 2, emb_dims // 4),
+                                nn.BatchNorm1d(emb_dims // 4),
+                                nn.ReLU(),
+                                nn.Linear(emb_dims // 4, emb_dims // 8),
+                                nn.BatchNorm1d(emb_dims // 8),
+                                nn.ReLU())
+        self.proj_rot = nn.Linear(emb_dims // 8, 4)
+        self.proj_trans = nn.Linear(emb_dims // 8, 3)
+
+    def forward(self, x):
+        x = self.nn(x.max(dim=1)[0])
+        rotation = self.proj_rot(x)
+        translation = self.proj_trans(x)
+        rotation = rotation / torch.norm(rotation, p=2, dim=1, keepdim=True)
+        return rotation, translation
+
+
+class Encoder(nn.Module):
+    def __init__(self, layer, N):
+        super(Encoder, self).__init__()
+        self.layers = clones(layer, N)
+        self.norm = LayerNorm(layer.size)
+
+    def forward(self, x, mask):
+        for layer in self.layers:
+            x = layer(x, mask)
+        return self.norm(x)
+
+
+class Decoder(nn.Module):
+    "Generic N layer decoder with masking."
+
+    def __init__(self, layer, N):
+        super(Decoder, self).__init__()
+        self.layers = clones(layer, N)
+        self.norm = LayerNorm(layer.size)
+
+    def forward(self, x, memory, src_mask, tgt_mask):
+        for layer in self.layers:
+            x = layer(x, memory, src_mask, tgt_mask)
+        return self.norm(x)
+
+
+class LayerNorm(nn.Module):
+    def __init__(self, features, eps=1e-6):
+        super(LayerNorm, self).__init__()
+        self.a_2 = nn.Parameter(torch.ones(features))
+        self.b_2 = nn.Parameter(torch.zeros(features))
+        self.eps = eps
+
+    def forward(self, x):
+        mean = x.mean(-1, keepdim=True)
+        std = x.std(-1, keepdim=True)
+        return self.a_2 * (x - mean) / (std + self.eps) + self.b_2
+
+
+class SublayerConnection(nn.Module):
+    def __init__(self, size, dropout=None):
+        super(SublayerConnection, self).__init__()
+        self.norm = LayerNorm(size)
+
+    def forward(self, x, sublayer):
+        return x + sublayer(self.norm(x))
+
+
+class EncoderLayer(nn.Module):
+    def __init__(self, size, self_attn, feed_forward, dropout):
+        super(EncoderLayer, self).__init__()
+        self.self_attn = self_attn
+        self.feed_forward = feed_forward
+        self.sublayer = clones(SublayerConnection(size, dropout), 2)
+        self.size = size
+
+    def forward(self, x, mask):
+        x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, mask))
+        return self.sublayer[1](x, self.feed_forward)
+
+
+class DecoderLayer(nn.Module):
+    "Decoder is made of self-attn, src-attn, and feed forward (defined below)"
+
+    def __init__(self, size, self_attn, src_attn, feed_forward, dropout):
+        super(DecoderLayer, self).__init__()
+        self.size = size
+        self.self_attn = self_attn
+        self.src_attn = src_attn
+        self.feed_forward = feed_forward
+        self.sublayer = clones(SublayerConnection(size, dropout), 3)
+
+    def forward(self, x, memory, src_mask, tgt_mask):
+        "Follow Figure 1 (right) for connections."
+        m = memory
+        x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, tgt_mask))
+        x = self.sublayer[1](x, lambda x: self.src_attn(x, m, m, src_mask))
+        return self.sublayer[2](x, self.feed_forward)
+
+
+class MultiHeadedAttention(nn.Module):
+    def __init__(self, h, d_model, dropout=0.1):
+        "Take in model size and number of heads."
+        super(MultiHeadedAttention, self).__init__()
+        assert d_model % h == 0
+        # We assume d_v always equals d_k
+        self.d_k = d_model // h
+        self.h = h
+        self.linears = clones(nn.Linear(d_model, d_model), 4)
+        self.attn = None
+        self.dropout = None
+
+    def forward(self, query, key, value, mask=None):
+        "Implements Figure 2"
+        if mask is not None:
+            # Same mask applied to all h heads.
+            mask = mask.unsqueeze(1)
+        nbatches = query.size(0)
+
+        # 1) Do all the linear projections in batch from d_model => h x d_k
+        query, key, value = \
+            [l(x).view(nbatches, -1, self.h, self.d_k).transpose(1, 2).contiguous()
+             for l, x in zip(self.linears, (query, key, value))]
+
+        # 2) Apply attention on all the projected vectors in batch.
+        x, self.attn = attention(query, key, value, mask=mask,
+                                 dropout=self.dropout)
+
+        # 3) "Concat" using a view and apply a final linear.
+        x = x.transpose(1, 2).contiguous() \
+            .view(nbatches, -1, self.h * self.d_k)
+        return self.linears[-1](x)
+
+
+class PositionwiseFeedForward(nn.Module):
+    "Implements FFN equation."
+
+    def __init__(self, d_model, d_ff, dropout=0.1):
+        super(PositionwiseFeedForward, self).__init__()
+        self.w_1 = nn.Linear(d_model, d_ff)
+        self.norm = nn.Sequential()  # nn.BatchNorm1d(d_ff)
+        self.w_2 = nn.Linear(d_ff, d_model)
+        self.dropout = None
+
+    def forward(self, x):
+        return self.w_2(self.norm(F.relu(self.w_1(x)).transpose(2, 1).contiguous()).transpose(2, 1).contiguous())
+
+
+class Identity(nn.Module):
+    def __init__(self):
+        super(Identity, self).__init__()
+
+    def forward(self, *input):
+        return input
+
+
+class Transformer(nn.Module):
+    def __init__(self, emb_dims, n_blocks, dropout, ff_dims, n_heads):
+        super(Transformer, self).__init__()
+        self.emb_dims = emb_dims
+        self.N = n_blocks
+        self.dropout = dropout
+        self.ff_dims = ff_dims
+        self.n_heads = n_heads
+        c = copy.deepcopy
+        attn = MultiHeadedAttention(self.n_heads, self.emb_dims)
+        ff = PositionwiseFeedForward(self.emb_dims, self.ff_dims, self.dropout)
+        self.model = EncoderDecoder(Encoder(EncoderLayer(self.emb_dims, c(attn), c(ff), self.dropout), self.N),
+                                    Decoder(DecoderLayer(self.emb_dims, c(attn), c(attn), c(ff), self.dropout), self.N),
+                                    nn.Sequential(),
+                                    nn.Sequential(),
+                                    nn.Sequential())
+
+    def forward(self, *input):
+        src = input[0]
+        tgt = input[1]
+        src = src.transpose(2, 1).contiguous()
+        tgt = tgt.transpose(2, 1).contiguous()
+        tgt_embedding = self.model(src, tgt, None, None).transpose(2, 1).contiguous()
+        src_embedding = self.model(tgt, src, None, None).transpose(2, 1).contiguous()
+        return src_embedding, tgt_embedding

learning3d-0.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2010-2019 Google, Inc. http://angularjs.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

learning3d-0.0.1.dist-info/METADATA

@@ -0,0 +1,271 @@
+Metadata-Version: 2.1
+Name: learning3d
+Version: 0.0.1
+Summary: Learning3D: A Modern Library for Deep Learning on 3D Point Clouds Data
+Author-email: Vinit Sarode <vinitsarode5@gmail.com>
+Project-URL: Homepage, https://github.com/vinits5/learning3d
+Project-URL: Issues, https://github.com/vinits5/learning3d/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch ==2.0.1
+Requires-Dist: torchvision ==0.15.2
+Requires-Dist: h5py ==3.8.0
+Requires-Dist: ninja ==1.11.1
+Requires-Dist: open3d ==0.17.0
+Requires-Dist: tensorboardX ==2.6
+Requires-Dist: tqdm ==4.65.0
+Requires-Dist: scikit-learn ==1.2.2
+Requires-Dist: scipy ==1.10.1
+Requires-Dist: numpy ==1.24.3
+Requires-Dist: transforms3d ==0.4.1
+Requires-Dist: pycuda
+
+<p align="center">
+	<img src="https://github.com/vinits5/learning3d/blob/master/images/logo.png" height="170">
+</p>
+
+# Learning3D: A Modern Library for Deep Learning on 3D Point Clouds Data.
+
+**[Documentation](https://github.com/vinits5/learning3d#documentation) | [Blog](https://medium.com/@vinitsarode5/learning3d-a-modern-library-for-deep-learning-on-3d-point-clouds-data-48adc1fd3e0?sk=0beb59651e5ce980243bcdfbf0859b7a) | [Demo](https://github.com/vinits5/learning3d/blob/master/examples/test_pointnet.py)**
+
+Learning3D is an open-source library that supports the development of deep learning algorithms that deal with 3D data. The Learning3D exposes a set of state of art deep neural networks in python. A modular code has been provided for further development. We welcome contributions from the open-source community.
+
+## Latest News:
+1. \[24 Oct, 2023\]: [MaskNet++](https://github.com/zhouruqin/MaskNet2) is now a part of learning3d library.
+2. \[12 May, 2022\]: [ChamferDistance](https://github.com/fwilliams/fml) loss function is incorporated in learning3d. This is a purely pytorch based loss function.
+3. \[24 Dec. 2020\]: [MaskNet](https://arxiv.org/pdf/2010.09185.pdf) is now ready to enhance the performance of registration algorithms in learning3d for occluded point clouds.
+4. \[24 Dec. 2020\]: Loss based on the predicted and ground truth correspondences is added in learning3d after consideration of [Correspondence Matrices are Underrated](https://arxiv.org/pdf/2010.16085.pdf) paper.
+5. \[24 Dec. 2020\]: [PointConv](https://arxiv.org/abs/1811.07246), latent feature estimation using convolutions on point clouds is now available in learning3d.
+6. \[16 Oct. 2020\]: [DeepGMR](https://wentaoyuan.github.io/deepgmr/), registration using gaussian mixture models is now available in learning3d
+7. \[14 Oct. 2020\]: Now, use your own data in learning3d. (Check out [UserData](https://github.com/vinits5/learning3d#use-your-own-data) functionality!)
+
+## Available Computer Vision Algorithms in Learning3D
+
+| Sr. No.       | Tasks         | Algorithms  |
+|:-------------:|:----------:|:-----|
+| 1 | [Classification](https://github.com/vinits5/learning3d#use-of-classification--segmentation-network) | PointNet, DGCNN, PPFNet, [PointConv](https://github.com/vinits5/learning3d#use-of-pointconv) |
+| 2 | [Segmentation](https://github.com/vinits5/learning3d#use-of-classification--segmentation-network) | PointNet, DGCNN |
+| 3 | [Reconstruction](https://github.com/vinits5/learning3d#use-of-point-completion-network) | Point Completion Network (PCN) |
+| 4 | [Registration](https://github.com/vinits5/learning3d#use-of-registration-networks) | PointNetLK, PCRNet, DCP, PRNet, RPM-Net, DeepGMR |
+| 5 | [Flow Estimation](https://github.com/vinits5/learning3d#use-of-flow-estimation-network) | FlowNet3D |
+| 6 | [Inlier Estimation](https://github.com/vinits5/learning3d#use-of-inlier-estimation-network-masknet) | MaskNet, MaskNet++ | 
+
+## Available Pretrained Models
+1. PointNet
+2. PCN
+3. PointNetLK
+4. PCRNet
+5. DCP
+6. PRNet
+7. FlowNet3D
+8. RPM-Net (clean-trained.pth, noisy-trained.pth, partial-pretrained.pth)
+9. DeepGMR
+10. PointConv (Download from this [link](https://github.com/DylanWusee/pointconv_pytorch/blob/master/checkpoints/checkpoint.pth))
+11. MaskNet
+12. MaskNet++ / MaskNet2
+
+## Available Datasets
+1. ModelNet40
+
+## Available Loss Functions
+1. Classification Loss (Cross Entropy)
+2. Registration Losses (FrobeniusNormLoss, RMSEFeaturesLoss)
+3. Distance Losses (Chamfer Distance, Earth Mover's Distance)
+4. Correspondence Loss (based on this [paper](https://arxiv.org/pdf/2010.16085.pdf))
+
+## Technical Details
+### Supported OS
+1. Ubuntu 16.04
+2. Ubuntu 18.04
+3. Ubuntu 20.04.6
+3. Linux Mint
+
+### Requirements
+1. CUDA 10.0 or higher
+2. Pytorch 1.3 or higher
+3. Python 3.8
+
+## How to use this library?
+**Important Note: Clone this repository in your project. Please don't add your codes in "learning3d" folder.**
+
+1. All networks are defined in the module "models".
+2. All loss functions are defined in the module "losses".
+3. Data loaders are pre-defined in data_utils/dataloaders.py file.
+4. All pretrained models are provided in learning3d/pretrained folder.
+
+## Documentation
+B: Batch Size, N: No. of points and C: Channels.
+####  Use of Point Embedding Networks:
+> from learning3d.models import PointNet, DGCNN, PPFNet\
+> pn = PointNet(emb_dims=1024, input_shape='bnc', use_bn=False)\
+> dgcnn = DGCNN(emb_dims=1024, input_shape='bnc')\
+> ppf = PPFNet(features=['ppf', 'dxyz', 'xyz'], emb_dims=96, radius='0.3', num_neighbours=64)
+
+| Sr. No. | Variable | Data type | Shape | Choices | Use |
+|:---:|:---:|:---:|:---:|:---:|:---:|
+| 1. | emb_dims | Integer | Scalar | 1024, 512 | Size of feature vector for the each point|
+| 2. | input_shape | String | - | 'bnc', 'bcn' | Shape of input point cloud|
+| 3. | output | tensor | BxCxN | - | High dimensional embeddings for each point|
+| 4. | features | List of Strings | - | ['ppf', 'dxyz', 'xyz'] | Use of various features |
+| 5. | radius | Float | Scalar | 0.3 | Radius of cluster for computing local features |
+| 6. | num_neighbours | Integer | Scalar | 64 | Maximum number of points to consider per cluster |
+
+#### Use of Classification / Segmentation Network:
+> from learning3d.models import Classifier, PointNet, Segmentation\
+> classifier = Classifier(feature_model=PointNet(), num_classes=40)\
+> seg = Segmentation(feature_model=PointNet(), num_classes=40)
+
+| Sr. No. | Variable | Data type | Shape | Choices | Use |
+|:---:|:---:|:---:|:---:|:---:|:---:|
+| 1. | feature_model | Object | - | PointNet / DGCNN | Point cloud embedding network |
+| 2. | num_classes | Integer | Scalar | 10, 40 | Number of object categories to be classified |
+| 3. | output | tensor | Classification: Bx40, Segmentation: BxNx40 | 10, 40 | Probabilities of each category or each point |
+
+#### Use of Registration Networks:
+> from learning3d.models import PointNet, PointNetLK, DCP, iPCRNet, PRNet, PPFNet, RPMNet\
+> pnlk = PointNetLK(feature_model=PointNet(), delta=1e-02, xtol=1e-07, p0_zero_mean=True, p1_zero_mean=True, pooling='max')\
+> dcp = DCP(feature_model=PointNet(), pointer_='transformer', head='svd')\
+> pcrnet = iPCRNet(feature_moodel=PointNet(), pooling='max')\
+> rpmnet = RPMNet(feature_model=PPFNet())\
+> deepgmr = DeepGMR(use_rri=True, feature_model=PointNet(), nearest_neighbors=20)
+
+| Sr. No. | Variable | Data type | Choices | Use | Algorithm |
+|:---:|:---:|:---:|:---:|:---:|:---:|
+| 1. | feature_model | Object | PointNet / DGCNN | Point cloud embedding network | PointNetLK | 
+| 2. | delta | Float | Scalar | Parameter to calculate approximate jacobian | PointNetLK |
+| 3. | xtol | Float | Scalar | Check tolerance to stop iterations | PointNetLK |
+| 4. | p0_zero_mean | Boolean | True/False | Subtract mean from template point cloud |  PointNetLK |
+| 5. | p1_zero_mean | Boolean | True/False | Subtract mean from source point cloud | PointNetLK |
+| 6. | pooling | String | 'max' / 'avg' | Type of pooling used to get global feature vectror | PointNetLK |
+| 7. | pointer_ | String | 'transformer' / 'identity' | Choice for Transformer/Attention network | DCP |
+| 8. | head | String | 'svd' / 'mlp' | Choice of module to estimate registration params | DCP |
+| 9. | use_rri | Boolean | True/False | Use nearest neighbors to estimate point cloud features. | DeepGMR |
+| 10. | nearest_neighbores | Integer | 20/any integer | Give number of nearest neighbors used to estimate features | DeepGMR |
+
+#### Use of Inlier Estimation Network (MaskNet):
+> from learning3d.models import MaskNet, PointNet, MaskNet2\
+> masknet = MaskNet(feature_model=PointNet(), is_training=True)
+> masknet2 = MaskNet2(feature_model=PointNet(), is_training=True)
+
+| Sr. No. | Variable | Data type | Choices | Use |
+|:---:|:---:|:---:|:---:|:---:|
+| 1. | feature_model | Object | PointNet / DGCNN | Point cloud embedding network |
+| 2. | is_training | Boolean | True / False | Specify if the network will undergo training or testing |
+
+#### Use of Point Completion Network:
+> from learning3d.models import PCN\
+> pcn = PCN(emb_dims=1024, input_shape='bnc', num_coarse=1024, grid_size=4, detailed_output=True)
+
+| Sr. No. | Variable | Data type | Choices | Use |
+|:---:|:---:|:---:|:---:|:---:|
+| 1. | emb_dims | Integer | 1024, 512 | Size of feature vector for each point | 
+| 2. | input_shape | String | 'bnc' / 'bcn' | Shape of input point cloud |
+| 3. | num_coarse | Integer | 1024 | Shape of output point cloud |
+| 4. | grid_size | Integer | 4, 8, 16 | Size of grid used to produce detailed output | 
+| 5. | detailed_output | Boolean | True / False | Choice for additional module to create detailed output point cloud|
+
+#### Use of PointConv:
+Use the following to create pretrained model provided by authors.
+> from learning3d.models import create_pointconv\
+> PointConv = create_pointconv(classifier=True, pretrained='path of checkpoint')\
+> ptconv = PointConv(emb_dims=1024, input_shape='bnc', input_channel_dim=6, classifier=True)
+
+**OR**\
+Use the following to create your own PointConv model.
+
+> PointConv = create_pointconv(classifier=False, pretrained=None)\
+> ptconv = PointConv(emb_dims=1024, input_shape='bnc', input_channel_dim=3, classifier=True)
+
+PointConv variable is a class. Users can use it to create a sub-class to override *create_classifier* and *create_structure* methods in order to change PointConv's network architecture.
+
+| Sr. No. | Variable | Data type | Choices | Use |
+|:---:|:---:|:---:|:---:|:---:|
+| 1. | emb_dims | Integer | 1024, 512 | Size of feature vector for each point | 
+| 2. | input_shape | String | 'bnc' / 'bcn' | Shape of input point cloud |
+| 3. | input_channel_dim | Integer | 3/6 | Define if point cloud contains only xyz co-ordinates or normals and colors as well |
+| 4. | classifier | Boolean | True / False | Choose if you want to use a classifier with PointConv |
+| 5. | pretrained | Boolean | String | Give path of the pretrained classifier model (only use it for weights given by authors) |
+
+#### Use of Flow Estimation Network:
+> from learning3d.models import FlowNet3D\
+> flownet = FlowNet3D()
+
+#### Use of Data Loaders:
+> from learning3d.data_utils import ModelNet40Data, ClassificationData, RegistrationData, FlowData\
+> modelnet40 = ModelNet40Data(train=True, num_points=1024, download=True)\
+> classification_data = ClassificationData(data_class=ModelNet40Data())\
+> registration_data = RegistrationData(algorithm='PointNetLK', data_class=ModelNet40Data(), partial_source=False, partial_template=False, noise=False)\
+> flow_data = FlowData()
+
+| Sr. No. | Variable | Data type | Choices | Use |
+|:---:|:---:|:---:|:---:|:---:|
+| 1. | train | Boolean | True / False | Split data as train/test set |
+| 2. | num_points | Integer | 1024 | Number of points in each point cloud |
+| 3. | download | Boolean | True / False | If data not available then download it |
+| 4. | data_class | Object | - | Specify which dataset to use |
+| 5. | algorithm | String | 'PointNetLK', 'PCRNet', 'DCP', 'iPCRNet' | Algorithm used for registration |
+| 6. | partial_source | Boolean | True / False | Create partial source point cloud |
+| 7. | partial_template | Boolean | True / False | Create partial template point cloud |
+| 8. | noise | Boolean | True / False | Add noise in source point cloud |
+
+#### Use Your Own Data:
+> from learning3d.data_utils import UserData\
+> dataset = UserData(application, data_dict)
+
+|Sr. No. | Application | Required Key | Respective Value |
+|:---:|:---:|:---:|:---:|
+| 1. | 'classification' | 'pcs' | Point Clouds (BxNx3) |
+|    |                  | 'labels' | Ground Truth Class Labels (BxN) |
+| 2. | 'registration' | 'template' | Template Point Clouds (BxNx3) |
+|    |                | 'source' | Source Point Clouds (BxNx3) |
+|    |                | 'transformation' | Ground Truth Transformation (Bx4x4)|
+| 3. | 'flow_estimation' | 'frame1' | Point Clouds (BxNx3) |
+|    |                   | 'frame2' | Point Clouds (BxNx3) |
+|    |                   | 'flow' | Ground Truth Flow Vector (BxNx3)|
+
+#### Use of Loss Functions:
+> from learning3d.losses import RMSEFeaturesLoss, FrobeniusNormLoss, ClassificationLoss, EMDLoss, ChamferDistanceLoss, CorrespondenceLoss\
+> rmse = RMSEFeaturesLoss()\
+> fn_loss = FrobeniusNormLoss()\
+> classification_loss = ClassificationLoss()\
+> emd = EMDLoss()\
+> cd = ChamferDistanceLoss()\
+> corr = CorrespondenceLoss()
+
+| Sr. No. | Loss Type | Use |
+|:---:|:---:|:---:|
+| 1. | RMSEFeaturesLoss | Used to find root mean square value between two global feature vectors of point clouds |
+| 2. | FrobeniusNormLoss | Used to find frobenius norm between two transfromation matrices |
+| 3. | ClassificationLoss | Used to calculate cross-entropy loss | 
+| 4. | EMDLoss | Earth Mover's distance between two given point clouds |
+| 5. | ChamferDistanceLoss | Chamfer's distance between two given point clouds |
+| 6. | CorrespondenceLoss | Computes cross entropy loss using the predicted correspondence and ground truth correspondence for each source point |
+
+### To run codes from examples:
+1. Copy the file from "examples" folder outside of the directory "learning3d"
+2. Now, run the file. (ex. python test_pointnet.py)
+- Your Directory/Location
+	- learning3d
+	- test_pointnet.py
+
+### References:
+1. [PointNet:](https://arxiv.org/abs/1612.00593) Deep Learning on Point Sets for 3D Classification and Segmentation
+2. [Dynamic Graph CNN](https://arxiv.org/abs/1801.07829) for Learning on Point Clouds
+3. [PPFNet:](https://arxiv.org/pdf/1802.02669.pdf) Global Context Aware Local Features for Robust 3D Point Matching
+4. [PointConv:](https://arxiv.org/abs/1811.07246) Deep Convolutional Networks on 3D Point Clouds
+5. [PointNetLK:](https://arxiv.org/abs/1903.05711) Robust & Efficient Point Cloud Registration using PointNet
+6. [PCRNet:](https://arxiv.org/abs/1908.07906) Point Cloud Registration Network using PointNet Encoding
+7. [Deep Closest Point:](https://arxiv.org/abs/1905.03304) Learning Representations for Point Cloud Registration
+8. [PRNet:](https://arxiv.org/abs/1910.12240) Self-Supervised Learning for Partial-to-Partial Registration
+9. [FlowNet3D:](https://arxiv.org/abs/1806.01411) Learning Scene Flow in 3D Point Clouds
+10. [PCN:](https://arxiv.org/pdf/1808.00671.pdf) Point Completion Network
+11. [RPM-Net:](https://arxiv.org/pdf/2003.13479.pdf) Robust Point Matching using Learned Features
+12. [3D ShapeNets:](https://people.csail.mit.edu/khosla/papers/cvpr2015_wu.pdf) A Deep Representation for Volumetric Shapes
+13. [DeepGMR:](https://arxiv.org/abs/2008.09088) Learning Latent Gaussian Mixture Models for Registration
+14. [CMU:](https://arxiv.org/pdf/2010.16085.pdf) Correspondence Matrices are Underrated
+15. [MaskNet:](https://arxiv.org/pdf/2010.09185.pdf) A Fully-Convolutional Network to Estimate Inlier Points
+16. [MaskNet++:](https://www.sciencedirect.com/science/article/abs/pii/S0097849322000085) Inlier/outlier identification for two point clouds

learning3d-0.0.1.dist-info/RECORD

@@ -0,0 +1,115 @@
+learning3d/__init__.py,sha256=WsLbk69HZ7OXJwTpNFcEphgtNp4sqEVGbZ1HGeNdYZ0,189
+learning3d/data_utils/__init__.py,sha256=iYAVh0FThnVlG42QIgmDYrC3NGVYuzKX8s1oRqAI1YU,261
+learning3d/data_utils/dataloaders.py,sha256=kb0wsLlMN7sB-CS_4BGSprSaZBwkUNYxS5iwUdD6JJM,14871
+learning3d/data_utils/user_data.py,sha256=ADDGeCUCr6TcXhcxvAFncIeLO71xoRHYi4H418ktvQs,4828
+learning3d/examples/test_dcp.py,sha256=o1hgl22b2xhqqYe4_k7NlNo3-rIMmSzzssCI74DCfoE,5606
+learning3d/examples/test_deepgmr.py,sha256=pb-gRE6YLLaPFmiBXQjaE-B-J314QY4RkNwLHx65bcU,5597
+learning3d/examples/test_flownet.py,sha256=52i9UOnSpCxZXrCgYJ-HNxsxRXqr_K4PydYMF90Lxv8,4603
+learning3d/examples/test_masknet.py,sha256=dkqUui9sv2SzHtvtzUzL_PxJxMcBMqCSDPAYg0BWAVU,6405
+learning3d/examples/test_masknet2.py,sha256=3_XWBQOwQjK3BCQ__BmPhCvYI_0hZMK3X4C-P2Krw6w,6859
+learning3d/examples/test_pcn.py,sha256=4eaosjJVqiFxlqnaUWu-O2Jawt4uU16UJEzitIjP2us,4342
+learning3d/examples/test_pcrnet.py,sha256=_x9l55sMBACXUfQHLaH7GJMfz6PWdYWSxjrRxVoY-As,4366
+learning3d/examples/test_pnlk.py,sha256=9u7B--PuCpl6TAmObmIKfDvYW6bMj3Jcc3_djTDO-D4,4456
+learning3d/examples/test_pointconv.py,sha256=NUcLjkkNJsGZYaUZHug6QGybm8NshZfg2tc8rfksNU8,4673
+learning3d/examples/test_pointnet.py,sha256=VKfB5DE8fh2G1iIoY02GvjSgWUJk2jQBmmJs3HC5rVU,4324
+learning3d/examples/test_prnet.py,sha256=ls1wWul26UHhquXt-PEn4O2-vCzCdxJ-aNIZDnHfvgg,4901
+learning3d/examples/test_rpmnet.py,sha256=oy-z7I26IQxr4TD_p0qCRnOn6H8VbQFyiWO83ZSFcDk,4476
+learning3d/examples/train_PointNetLK.py,sha256=0GgT2NYKNZl8o02rvW-nYBO_1tlfDNuakuAXtm1V16c,8773
+learning3d/examples/train_dcp.py,sha256=SQVrwnZqGmFCZv_X2tzMysBmv-HI9sllZMWw5zsW3NM,9511
+learning3d/examples/train_deepgmr.py,sha256=vxdkgfQZPtwuYryR0chegTiLuXOQag8r_ccGJ6qtw7o,9397
+learning3d/examples/train_flownet.py,sha256=V3uG7EaqsQO0BtmAFFN_aHb5bsyYoLv3JKb1_XhYKNw,10369
+learning3d/examples/train_masknet.py,sha256=XzgWsmVAm5Lk21mH9qhvNN0um4pI1fYVfsBAV4deSOM,8889
+learning3d/examples/train_pcn.py,sha256=X7MSYVXwgIMExplua1M9pG20eNhZ_0p83yTADSYrAlA,7542
+learning3d/examples/train_pcrnet.py,sha256=KQ8MiDUiR46qS9t7tc5POJ3NjMyZFBEPOVQY-7Vszpk,8198
+learning3d/examples/train_pointconv.py,sha256=noGT2yGWHAuecObz1X9cEiWl0xjh7NhmRneP88jR8uI,8939
+learning3d/examples/train_pointnet.py,sha256=SXheDRP_GHZQQw4BEYS7bfL481D8GcbTekON-GVwOsk,8840
+learning3d/examples/train_prnet.py,sha256=2zvd-3cYzZP8L92XJmFL5rTzxpApUhetiEc4u4V0X5g,8373
+learning3d/examples/train_rpmnet.py,sha256=PEdFgPXyeME0axvLEd--VbpbqWV6P5i6NnjQnJ_X3Oo,8530
+learning3d/losses/__init__.py,sha256=zjjZeA_NvAhZlxiYBbtgjEsvMyLFhFWXlZioitrlGWw,425
+learning3d/losses/chamfer_distance.py,sha256=UTZ6x5cGwL3L5hJZOWoC35gTzcKh1S0yCg8vGuGXU1w,2121
+learning3d/losses/classification.py,sha256=QgDHC5VgSga6BiuD4Ee70t6vvchlE97BY0KExevhdgk,374
+learning3d/losses/correspondence_loss.py,sha256=Tcq2o5eLY7j50pibAuH0vBcUTjwZ-wHNzGZD4H6mAe0,583
+learning3d/losses/emd.py,sha256=DqP77dN6lPkpGGgBz10oO6YNYxt889weYbVYj6bZFUM,389
+learning3d/losses/frobenius_norm.py,sha256=IuKr0DT9aPBlc5fjIy6lJ082yOh9F8xiNoXF6FvWZtY,682
+learning3d/losses/rmse_features.py,sha256=_KMqIWqH9-lH2P6YSeGfSOIbP7plUAwWWBh2Cu7cpXA,453
+learning3d/losses/cuda/chamfer_distance/__init__.py,sha256=5nz6Ui4PVKru4HLGovFue3M-eumQlovMYP6Qfk3O6SE,46
+learning3d/losses/cuda/chamfer_distance/chamfer_distance.cpp,sha256=rcknAz6oYPhlTVjGnAga2c4bMz2rz_UU9ch7zrcmWoc,6260
+learning3d/losses/cuda/chamfer_distance/chamfer_distance.cu,sha256=7-UQ8QVcSQ1tbN7xwDNQQfpbG-S5b7KuSv0nCBYlhI8,5070
+learning3d/losses/cuda/chamfer_distance/chamfer_distance.py,sha256=vzF4GdkgdD5Rr3F6pk1u1kF1LpiFKpLTZcd-H1IVu3s,1926
+learning3d/losses/cuda/emd_torch/setup.py,sha256=AUvCT6EI2fOcCbyzrGscvCKu5gLhjofmZ-PfNBY2dNw,574
+learning3d/losses/cuda/emd_torch/pkg/emd_loss_layer.py,sha256=FMfOoT8VF05Ns6_BaF6tquT5B9T7man0WtKJ9lPRfk8,1116
+learning3d/losses/cuda/emd_torch/pkg/include/cuda_helper.h,sha256=8uVFZEr7YWVMPqHqfu_5lLUHCDjgwE0bJc-MUhmbLRk,469
+learning3d/losses/cuda/emd_torch/pkg/include/emd.h,sha256=5TF1_V_OFywM8ftegQGw0YpdgPAzg6UolJ4OOFG5rVM,1215
+learning3d/losses/cuda/emd_torch/pkg/include/cuda/emd.cuh,sha256=XliqHIePtL73Kdh0eDlRLalNmP3KqzwAEcgWysAOnNs,9826
+learning3d/losses/cuda/emd_torch/pkg/layer/__init__.py,sha256=aDpfP0iZyg3Uu-ppa33u2imCsmlvKSf5S8QhLnGfwyI,35
+learning3d/losses/cuda/emd_torch/pkg/layer/emd_loss_layer.py,sha256=yCEEfafLZ1Ia_BCrE7mcnDRDaaEj6je3Rj8cnQ_Zrts,1019
+learning3d/losses/cuda/emd_torch/pkg/src/emd.cpp,sha256=lQ4q2XO5K2CldYmnRJnGhKTR9hVRFTwO305bHT3Cauo,17
+learning3d/losses/cuda/emd_torch/pkg/src/cuda/emd.cu,sha256=DJXALRWyiVDzaKWsD2tQnEXrIT9GpIldkvIJ9fZMGbI,1462
+learning3d/models/__init__.py,sha256=r5upYkq5M4pu7rxuFxFI5AshVGQI-gMMsQRm_iF3TuE,642
+learning3d/models/classifier.py,sha256=_LUNXbLrpKNXmCkO2R1mz64dbwfrze7f_4SYT1Z6SYo,1205
+learning3d/models/dcp.py,sha256=LZFgtk9f9f9s3QvX65nFXGgC33yGIZuy4XjviwH8OGE,3377
+learning3d/models/deepgmr.py,sha256=vIxOQrZjvOCHLElJCjZ8EcZ-vm0-v71IKsPGuSF-elE,5298
+learning3d/models/dgcnn.py,sha256=Bt-dP2NwpOy4AcWrspXfVV1EKL-ZQElYUp2uaWNvE_Q,3057
+learning3d/models/flownet3d.py,sha256=2cPqzwXyw5uBNWIpHLTwRf0exSHYcW2Lyd94wOHgXZ0,17667
+learning3d/models/masknet.py,sha256=ElMF3b-JgYmgwSEf1taGQvhA7Xy7_MiHEofzc03VCd8,2705
+learning3d/models/masknet2.py,sha256=6lgukurfzUOY-6xdCpMljOYFtvADLSczAXJzRC3Jkh4,9063
+learning3d/models/pcn.py,sha256=FvpjLR6t3kFQ1I4Fhpbsaj_P8Ml6S912x36JAZ1dUKs,5346
+learning3d/models/pcrnet.py,sha256=6C6iM3XkDNdgihtPIdy09RgFD2KKDCnDzLvFfp6X-Tg,2755
+learning3d/models/pointconv.py,sha256=lJ3_3uslE29lO3roZiE5vxr5971AWV5ExeVTzbEl858,5151
+learning3d/models/pointnet.py,sha256=qgSWLJ4N5Y7ObAwKiJH29Pcl67jm3sfqbXqi3tQbUQg,3238
+learning3d/models/pointnetlk.py,sha256=Zl66LjDX1vLdZRgCdY2oQJnpWpqPEx6BH8GbcVCsw68,5805
+learning3d/models/pooling.py,sha256=vOzJMambeG7kf1pnox5p5FE2CVH2iMDGU_DgWRw15WQ,412
+learning3d/models/ppfnet.py,sha256=aBzWvtNHFo-eu1kWoZmPI9xJOFHyxYHjdapb6cN2Aso,2894
+learning3d/models/prnet.py,sha256=KSTTMEUgEvE2PX59Mqas48LQUYyh8O6PwOHvP8zEYHU,18499
+learning3d/models/rpmnet.py,sha256=eMVqJ6BalY96TSB8VFXjCJIA15J0XAB3BEpMB-6CMdM,11517
+learning3d/models/segmentation.py,sha256=CjlINj5M0Y6C-CejrieIu9ZkuwEoCFNjq_hr5SX9umU,1166
+learning3d/ops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+learning3d/ops/data_utils.py,sha256=qW8FOQWgcHjuuiSaAayJ3nKJnDW_GDv3ujE-uFvWsPE,1764
+learning3d/ops/invmat.py,sha256=m1Mm2mQNn4KgQv54w-ek0xLkZuKnfDlF2ooylXeXvAw,4154
+learning3d/ops/quaternion.py,sha256=D00IL6VHitYy4CINFAilD0t0kyBjc_JHfKuMrJGJ1Cw,6793
+learning3d/ops/se3.py,sha256=x6oLbQzLOXiM0xDJsVUCUE1liZ_TaJzkkHQvIyjqCqI,3957
+learning3d/ops/sinc.py,sha256=A_Ffu07RXGx3daZn4zOGdnW10_l06cmhFdAiU4NKhcw,5228
+learning3d/ops/so3.py,sha256=b0tX5nHyF2Qtp8V0ejGKaPaHJQ_G38ifQ7gSJzRU1ts,5166
+learning3d/ops/transform_functions.py,sha256=hvNjZO-uJodsGYtQwtAtDxtQ6uBpA7Lv9t-_yAg6wxo,12806
+learning3d/utils/__init__.py,sha256=iuYyToRcZ9YZMNn-ngJMjzU8p4FkaO2m8YyXSE14hN4,442
+learning3d/utils/pointconv_util.py,sha256=kJxGztai7X15YsGuorMOc50SPtj_k1yfkP4XCTzIWdM,14331
+learning3d/utils/ppfnet_util.py,sha256=HEoxkgUBlawKZLWspfQm3caWUyAMIrW-ECtStNYbe2Y,7989
+learning3d/utils/svd.py,sha256=yCYQt2SKqeIzCBnBEr_8xFR79m4fIoNVFnp77epn1dM,1936
+learning3d/utils/transformer.py,sha256=UDgJvnh7ekWyijaAn-a3ckeFeMxlK_chXzWlhAGDiPM,8974
+learning3d/utils/lib/pointnet2_modules.py,sha256=Tqiz32BT-fc2gHmv87xbbNUctE2mEpYpnJ3jfVmqw0w,6339
+learning3d/utils/lib/pointnet2_utils.py,sha256=TQOVhi22raBffgtKWsVf-reoEqPkN-zvv6GOh2TqHxY,10637
+learning3d/utils/lib/pytorch_utils.py,sha256=-kJfrswEu0gnnrYM1yIrj6HFW2YVyK2P9To4EyYAqNw,6173
+learning3d/utils/lib/setup.py,sha256=AF3MiatsAYYEIl26Vt5JlsmZEI19lV86k6b4fw1uxgU,679
+learning3d/utils/lib/build/lib.linux-x86_64-3.5/pointnet2_cuda.cpython-35m-x86_64-linux-gnu.so,sha256=HjZKllvXRMLn1ONxFPA-RF2athcY06clU-D91CLS4Dw,7222568
+learning3d/utils/lib/build/temp.linux-x86_64-3.5/src/ball_query.o,sha256=_jT_UVj61Yi2eDgpn1gn595TTqbQ8hAERAazE9kcuwA,2730016
+learning3d/utils/lib/build/temp.linux-x86_64-3.5/src/ball_query_gpu.o,sha256=GFosEyxTG6gPBUZJ7niNojLxJvt12v2cnO0lqtnO3mI,13912
+learning3d/utils/lib/build/temp.linux-x86_64-3.5/src/group_points.o,sha256=kNMDj14OwT70OtmCf63mdtnf58tXpnKXe95DOHu63Ow,2490896
+learning3d/utils/lib/build/temp.linux-x86_64-3.5/src/group_points_gpu.o,sha256=CCX8QD24Kp4hJqUFG34e88Co5poWc6XvkARQYpBgs88,17048
+learning3d/utils/lib/build/temp.linux-x86_64-3.5/src/interpolate.o,sha256=xyOxGf0zrgX8k6Muvn4WgGuZWk0N1-E7r4Fnjpao-sg,2503232
+learning3d/utils/lib/build/temp.linux-x86_64-3.5/src/interpolate_gpu.o,sha256=4kAHyU-Ho3_Sr77NWJINzVndHu8PdirIUqm0tQ7yVY4,32712
+learning3d/utils/lib/build/temp.linux-x86_64-3.5/src/pointnet2_api.o,sha256=L8v-YcL3J53kKxFw50frNlsKl1n4HowU5krlscSZ-5E,7242784
+learning3d/utils/lib/build/temp.linux-x86_64-3.5/src/sampling.o,sha256=lOw0IlJMXjCbTw9LONz7_TEzjWl484WFzilyzW742Io,2495440
+learning3d/utils/lib/build/temp.linux-x86_64-3.5/src/sampling_gpu.o,sha256=ULYz2ppU_n0KU8ka0Q4FE9wdPUuZDYcmvxRWN8UgUnU,95544
+learning3d/utils/lib/dist/pointnet2-0.0.0-py3.5-linux-x86_64.egg,sha256=zwF5_pf6Id5lVow5MGkdug_upjMpbEwW7hUTIHEub0I,2241340
+learning3d/utils/lib/pointnet2.egg-info/SOURCES.txt,sha256=XtaY4SQXYOT8Hhdjw4iworVxoDjoWdmdBe5fpkwK_-c,328
+learning3d/utils/lib/pointnet2.egg-info/dependency_links.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+learning3d/utils/lib/pointnet2.egg-info/top_level.txt,sha256=XVeKz4zj8Ixbw0jjiXuOqdON71dDXExnItEZVUaOdVE,15
+learning3d/utils/lib/src/ball_query.cpp,sha256=Ysx8OAn4G-dSrlPgbZS2WCDfxcV54HQTZu5FbL2QlKs,933
+learning3d/utils/lib/src/ball_query_gpu.cu,sha256=vj-Y6gUh2oVLLYTuz8JE8tcHxGrJBTC4pTRsNcWNa1o,2050
+learning3d/utils/lib/src/ball_query_gpu.h,sha256=47MXh8U46wcpvQ7wcC05QyAsE1N3GB-TExsT0hoApxE,476
+learning3d/utils/lib/src/cuda_utils.h,sha256=es4AGc6gYXileyddOxCGsmzV0Mg9ZG6LiucMUw6ee8o,353
+learning3d/utils/lib/src/group_points.cpp,sha256=koGBIklYmbwHDpCrHPURJl_f1AtsqpNB2DbgRRb4zuc,1171
+learning3d/utils/lib/src/group_points_gpu.cu,sha256=OIa_C0egafVIvJTcfu7UUI-E4ylxktcSG-fUjJQbNow,3307
+learning3d/utils/lib/src/group_points_gpu.h,sha256=lNX0VSo6xFCfWQh-ZPUIBobu2kfmFz8PF8l2zZe1NyQ,836
+learning3d/utils/lib/src/interpolate.cpp,sha256=VKMC4dveIgdfTiqpjrhe5CMqW097Hgmza5PkZVKVUfc,2521
+learning3d/utils/lib/src/interpolate_gpu.cu,sha256=yOHn2D5MFonqrfLD7K7-DFozXqSDqdetdaFHJzsPMKs,7470
+learning3d/utils/lib/src/interpolate_gpu.h,sha256=SbxS1oY6Qrp3f-r_kDtjq5_EzRpdIZpJIGVfmhhmnsI,1477
+learning3d/utils/lib/src/pointnet2_api.cpp,sha256=LRvlZoDLpaZHg2Tvb2ad5j8qVNCZ7TX9XEsNfdlSpT8,1213
+learning3d/utils/lib/src/sampling.cpp,sha256=kH75rE1jxri4v8wIksKAjaUbJlXB3FLEXYQTmb0kmII,1549
+learning3d/utils/lib/src/sampling_gpu.cu,sha256=V9dTFaYksQ-jNnoUvQgRNuFW9MmaBdZpbmXQbnvShJc,7934
+learning3d/utils/lib/src/sampling_gpu.h,sha256=STr6hTB9A8D0skTTR6TiU79j1eSc-FRqik_j0PPWDmM,1045
+learning3d-0.0.1.dist-info/LICENSE,sha256=3qY3_NeQIvalbLlsHFtOfuUKjs_U2k6u7rf6YVx6ac0,1098
+learning3d-0.0.1.dist-info/METADATA,sha256=S7VpnwJuti1vz84GQLua3OME7NEVDczBTWrAQwXStEg,15835
+learning3d-0.0.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+learning3d-0.0.1.dist-info/top_level.txt,sha256=nTmYW8NhbNV1_15DGNpl_OvvSFtQP98sy3qrrHr0eLo,11
+learning3d-0.0.1.dist-info/RECORD,,

learning3d-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+