ocnn 2.2.6__tar.gz → 2.2.8__tar.gz

{ocnn-2.2.6/ocnn.egg-info → ocnn-2.2.8}/PKG-INFO

@@ -1,13 +1,12 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: ocnn
-Version: 2.2.6
+Version: 2.2.8
 Summary: Octree-based Sparse Convolutional Neural Networks
 Home-page: https://github.com/octree-nn/ocnn-pytorch
 Author: Peng-Shuai Wang
 Author-email: wangps@hotmail.com
 License: MIT
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
@@ -16,6 +15,17 @@ Requires-Dist: torch
 Requires-Dist: torchvision
 Requires-Dist: numpy
 Requires-Dist: packaging
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # O-CNN
 
@@ -63,6 +73,16 @@ We just did not post our paper on Arxiv during the review process of SIGGRAPH.
 Therefore, **the idea of constraining CNN computation into sparse non-emtpry
 voxels, i.e. Sparse Convolution,  is first proposed by our O-CNN**.
 
+<!--
+Developed in collaboration with authors from [PointCNN](https://arxiv.org/abs/1801.07791),
+[Dr. Yangyan Li](https://yangyan.li/) and [Prof. Baoquan Chen](https://baoquanchen.info/),
+-->
+This library supports point cloud processing from the ground up.
+The library provides essential components for converting raw point clouds into
+octrees to perform convolution operations. Of course, it also supports other 3D
+data formats, such as meshes and volumetric grids, which can be converted into
+octrees to leverage the library's capabilities.
+
 
 ## Key benefits of ocnn-pytorch
 

{ocnn-2.2.6 → ocnn-2.2.8}/README.md

@@ -44,6 +44,16 @@ We just did not post our paper on Arxiv during the review process of SIGGRAPH.
 Therefore, **the idea of constraining CNN computation into sparse non-emtpry
 voxels, i.e. Sparse Convolution,  is first proposed by our O-CNN**.
 
+<!--
+Developed in collaboration with authors from [PointCNN](https://arxiv.org/abs/1801.07791),
+[Dr. Yangyan Li](https://yangyan.li/) and [Prof. Baoquan Chen](https://baoquanchen.info/),
+-->
+This library supports point cloud processing from the ground up.
+The library provides essential components for converting raw point clouds into
+octrees to perform convolution operations. Of course, it also supports other 3D
+data formats, such as meshes and volumetric grids, which can be converted into
+octrees to leverage the library's capabilities.
+
 
 ## Key benefits of ocnn-pytorch
 

{ocnn-2.2.6 → ocnn-2.2.8}/ocnn/__init__.py

@@ -12,7 +12,7 @@ from . import models
 from . import dataset
 from . import utils
 
-__version__ = '2.2.6'
+__version__ = '2.2.8'
 
 __all__ = [
     'octree',

{ocnn-2.2.6 → ocnn-2.2.8}/ocnn/nn/octree_pad.py

@@ -22,10 +22,10 @@ def octree_pad(data: torch.Tensor, octree: Octree, depth: int, val: float = 0.0)
     val (float): The padding value. (Default: :obj:`0.0`)
   '''
 
-  mask = octree.nempty_mask(depth)
+  idx = octree.nempty_index(depth)
   size = (octree.nnum[depth], data.shape[1])  # (N, C)
   out = torch.full(size, val, dtype=data.dtype, device=data.device)
-  out[mask] = data
+  out[idx] = data
   return out
 
 
@@ -35,5 +35,5 @@ def octree_depad(data: torch.Tensor, octree: Octree, depth: int):
   Please refer to :func:`octree_depad` for the meaning of the arguments.
   '''
 
-  mask = octree.nempty_mask(depth)
-  return data[mask]
+  idx = octree.nempty_index(depth)
+  return data[idx]

{ocnn-2.2.6 → ocnn-2.2.8}/ocnn/octree/octree.py

@@ -43,11 +43,13 @@ class Octree:
   def __init__(self, depth: int, full_depth: int = 2, batch_size: int = 1,
                device: Union[torch.device, str] = 'cpu', **kwargs):
     super().__init__()
+    # configurations for initialization
     self.depth = depth
     self.full_depth = full_depth
     self.batch_size = batch_size
     self.device = device
 
+    # properties after building the octree
     self.reset()
 
   def reset(self):
@@ -63,12 +65,18 @@ class Octree:
     self.normals = [None] * num
     self.points = [None] * num
 
+    # self.nempty_masks, self.nempty_indices and self.nempty_neighs are
+    # for handling of non-empty nodes and are constructed on demand
+    self.nempty_masks = [None] * num
+    self.nempty_indices = [None] * num
+    self.nempty_neighs = [None] * num
+
     # octree node numbers in each octree layers.
-    # TODO: decide whether to settle them to 'gpu' or not?
+    # These are small 1-D tensors; just keep them on CPUs
     self.nnum = torch.zeros(num, dtype=torch.long)
     self.nnum_nempty = torch.zeros(num, dtype=torch.long)
 
-    # the following properties are valid after `merge_octrees`.
+    # the following properties are only valid after `merge_octrees`.
     # TODO: make them valid after `octree_grow`, `octree_split` and `build_octree`
     batch_size = self.batch_size
     self.batch_nnum = torch.zeros(num, batch_size, dtype=torch.long)
@@ -107,8 +115,8 @@ class Octree:
 
     key = self.keys[depth]
     if nempty:
-      mask = self.nempty_mask(depth)
-      key = key[mask]
+      idx = self.nempty_index(depth)
+      key = key[idx]
     return key
 
   def xyzb(self, depth: int, nempty: bool = False):
@@ -132,19 +140,63 @@ class Octree:
 
     batch_id = self.keys[depth] >> 48
     if nempty:
-      mask = self.nempty_mask(depth)
-      batch_id = batch_id[mask]
+      idx = self.nempty_index(depth)
+      batch_id = batch_id[idx]
     return batch_id
 
-  def nempty_mask(self, depth: int):
+  def nempty_mask(self, depth: int, reset: bool = False):
     r''' Returns a binary mask which indicates whether the cooreponding octree
     node is empty or not.
 
     Args:
       depth (int): The depth of the octree.
+      reset (bool): If True, recomputes the mask.
     '''
 
-    return self.children[depth] >= 0
+    if self.nempty_masks[depth] is None or reset:
+      self.nempty_masks[depth] = self.children[depth] >= 0
+    return self.nempty_masks[depth]
+
+  def nempty_index(self, depth: int, reset: bool = False):
+    r''' Returns the indices of non-empty octree nodes.
+
+    Args:
+      depth (int): The depth of the octree.
+      reset (bool): If True, recomputes the indices.
+    '''
+
+    if self.nempty_indices[depth] is None or reset:
+      mask = self.nempty_mask(depth)
+      rng = torch.arange(mask.shape[0], device=mask.device, dtype=torch.long)
+      self.nempty_indices[depth] = rng[mask]
+    return self.nempty_indices[depth]
+
+  def nempty_neigh(self, depth: int, reset: bool = False):
+    r''' Returns the neighborhoods of non-empty octree nodes.
+    Args:
+
+      depth (int): The depth of the octree.
+      reset (bool): If True, recomputes the neighborhoods.
+    '''
+    if self.nempty_neighs[depth] is None or reset:
+      neigh = self.neighs[depth]
+      idx = self.nempty_index(depth)
+      neigh = self.remap_nempty_neigh(neigh[idx], depth)
+      self.nempty_neighs[depth] = neigh
+    return self.nempty_neighs[depth]
+
+  def remap_nempty_neigh(self, neigh: torch.Tensor, depth: int):
+    r''' Remaps the neighborhood indices to the non-empty octree nodes.
+
+    Args:
+      neigh (torch.Tensor): The input neighborhoods with shape :obj:`(N, 27)`.
+      depth (int): The depth of the octree.
+    '''
+
+    valid = neigh >= 0
+    child = self.children[depth]
+    neigh[valid] = child[neigh[valid]].long()  # remap the index
+    return neigh
 
   def build_octree(self, point_cloud: Points):
     r''' Builds an octree from a point cloud.
@@ -225,6 +277,10 @@ class Octree:
       features = scatter_add(point_cloud.features, idx, dim=0)
       self.features[d] = features / counts.unsqueeze(1)
 
+    # reset nempty_masks and nempty_indices, which will be updated on demand
+    self.nempty_masks = [None] * (self.depth + 1)
+    self.nempty_indices = [None] * (self.depth + 1)
+    self.nempty_neighs = [None] * (self.depth + 1)
     return idx
 
   def octree_grow_full(self, depth: int, update_neigh: bool = True):
@@ -240,18 +296,22 @@ class Octree:
 
     # node number
     num = 1 << (3 * depth)
-    self.nnum[depth] = num * self.batch_size
-    self.nnum_nempty[depth] = num * self.batch_size
+    batch_size = self.batch_size
+    self.nnum[depth] = num * batch_size
+    self.nnum_nempty[depth] = num * batch_size
 
     # update key
     key = torch.arange(num, dtype=torch.long, device=self.device)
-    bs = torch.arange(self.batch_size, dtype=torch.long, device=self.device)
+    bs = torch.arange(batch_size, dtype=torch.long, device=self.device)
     key = key.unsqueeze(0) | (bs.unsqueeze(1) << 48)
     self.keys[depth] = key.view(-1)
 
     # update children
     self.children[depth] = torch.arange(
-        num * self.batch_size, dtype=torch.int32, device=self.device)
+        num * batch_size, dtype=torch.int32, device=self.device)
+
+    # nempty_masks, nempty_indices, and nempty_neighs
+    # need not be reset for full octrees
 
     # update neigh if needed
     if update_neigh:
@@ -281,6 +341,12 @@ class Octree:
     self.children[depth] = children.int()
     self.nnum_nempty[depth] = nnum_nempty
 
+    # reset nempty_masks, nempty_indices, and nempty_neighs as they depend on
+    # children[depth] and are invalid now
+    self.nempty_masks[depth] = None
+    self.nempty_indices[depth] = None
+    self.nempty_neighs[depth] = None
+
   def octree_grow(self, depth: int, update_neigh: bool = True):
     r''' Grows the octree and updates the relevant properties. And in most
     cases, call :func:`Octree.octree_split` to update the splitting status of
@@ -301,6 +367,9 @@ class Octree:
       self.features.append(None)
       self.normals.append(None)
       self.points.append(None)
+      self.nempty_masks.append(None)
+      self.nempty_indices.append(None)
+      self.nempty_neighs.append(None)
       zero = torch.zeros(1, dtype=torch.long)
       self.nnum = torch.cat([self.nnum, zero])
       self.nnum_nempty = torch.cat([self.nnum_nempty, zero])
@@ -342,7 +411,7 @@ class Octree:
       key = torch.arange(nnum, dtype=torch.long, device=device)
       x, y, z, _ = key2xyz(key, depth)
       xyz = torch.stack([x, y, z], dim=-1)  # (N,  3)
-      grid = range_grid(-1, 1, device)   # (27, 3)
+      grid = range_grid(-1, 1, device)      # (27, 3)
       xyz = xyz.unsqueeze(1) + grid         # (N, 27, 3)
       xyz = xyz.view(-1, 3)                 # (N*27, 3)
       neigh = xyz2key(xyz[:, 0], xyz[:, 1], xyz[:, 2], depth=depth)
@@ -400,16 +469,18 @@ class Octree:
     '''
 
     key = self.key(depth, nempty)
-    # `torch.bucketize` is similar to `torch.searchsorted`.
-    # I choose `torch.bucketize` here because it has fewer dimension checks,
-    # resulting in slightly better performance according to the docs of
-    # pytorch-1.9.1, since `key` is always 1-D sorted sequence.
+    idx = torch.searchsorted(key, query)
+
+    # `torch.bucketize` can also be used here; it is similar to
+    # `torch.searchsorted`, and it has fewer dimension checks, resulting in
+    # slightly better performance for 1D sorted sequences according to the docs
+    # of pytorch-1.9.1. `key` is always a 1D sorted sequence.
     # https://pytorch.org/docs/1.9.1/generated/torch.searchsorted.html
-    idx = torch.bucketize(query, key)
+    # idx = torch.bucketize(query, key)
 
     valid = idx < key.shape[0]      # valid if in-bound
-    found = key[idx[valid]] == query[valid]
-    valid[valid.clone()] = found    # valid if found
+    vi = torch.arange(query.shape[0], device=query.device)[valid]
+    valid[vi] = key[idx[vi]] == query[vi]  # valid if found
     idx[valid.logical_not()] = -1   # set to -1 if invalid
     return idx
 
@@ -428,22 +499,18 @@ class Octree:
           octree nodes.
     '''
 
-    if stride == 1:
+    if stride == 1 and not nempty:
       neigh = self.neighs[depth]
-    elif stride == 2:
-      # clone neigh to avoid self.neigh[depth] being modified
+    elif stride == 2 and not nempty:
       neigh = self.neighs[depth][::8].clone()
+    elif stride == 1 and nempty:
+      neigh = self.nempty_neigh(depth)
+    elif stride == 2 and nempty:
+      neigh = self.neighs[depth][::8].clone()
+      neigh = self.remap_nempty_neigh(neigh, depth)
     else:
       raise ValueError('Unsupported stride {}'.format(stride))
 
-    if nempty:
-      child = self.children[depth]
-      if stride == 1:
-        nempty_node = child >= 0
-        neigh = neigh[nempty_node]
-      valid = neigh >= 0
-      neigh[valid] = child[neigh[valid]].long()  # remap the index
-
     if kernel == '333':
       return neigh
     elif kernel in self.lut_kernel:
@@ -548,15 +615,23 @@ class Octree:
       return [p.to(device, non_blocking=non_blocking)
               if isinstance(p, torch.Tensor) else None for p in prop]
 
-    # Construct a new Octree on the specified device
-    octree = Octree(self.depth, self.full_depth, self.batch_size, device)
+    # Construct a new Octree on the specified device.
+    # During the initialization, self.device is used to set up the new Octree;
+    # the look-up tables (including self.lut_kernel, self.lut_parent, and
+    # self.lut_child), will be already created on the correct device.
+    octree = Octree.init_like(self, device)
+
+    # Move all the other properties to the specified device
     octree.keys = list_to_device(self.keys)
     octree.children = list_to_device(self.children)
     octree.neighs = list_to_device(self.neighs)
     octree.features = list_to_device(self.features)
     octree.normals = list_to_device(self.normals)
     octree.points = list_to_device(self.points)
-    octree.nnum = self.nnum.clone()  # TODO: whether to move nnum to the self.device?
+
+    # The following are small tensors, keep them on CPU to avoid frequent device
+    # switching, so just clone them.
+    octree.nnum = self.nnum.clone()
     octree.nnum_nempty = self.nnum_nempty.clone()
     octree.batch_nnum = self.batch_nnum.clone()
     octree.batch_nnum_nempty = self.batch_nnum_nempty.clone()
@@ -572,90 +647,124 @@ class Octree:
 
     return self.to('cpu')
 
+  def merge_octrees(self, octrees: List['Octree']):
+    r''' Merges a list of octrees into one batch.
 
-def merge_octrees(octrees: List['Octree']):
-  r''' Merges a list of octrees into one batch.
+    Args:
+      octrees (List[Octree]): A list of octrees to merge.
 
-  Args:
-    octrees (List[Octree]): A list of octrees to merge.
+    Returns:
+      Octree: The merged octree.
+    '''
+
+    # init and check
+    batch_size = len(octrees)
+    self.batch_size = batch_size
+    for i in range(1, batch_size):
+      condition = (octrees[i].depth == self.depth and
+                   octrees[i].full_depth == self.full_depth and
+                   octrees[i].device == self.device)
+      assert condition, 'The check of merge_octrees failed'
+
+    # node num
+    batch_nnum = torch.stack(
+        [octrees[i].nnum for i in range(batch_size)], dim=1)
+    batch_nnum_nempty = torch.stack(
+        [octrees[i].nnum_nempty for i in range(batch_size)], dim=1)
+    self.nnum = torch.sum(batch_nnum, dim=1)
+    self.nnum_nempty = torch.sum(batch_nnum_nempty, dim=1)
+    self.batch_nnum = batch_nnum
+    self.batch_nnum_nempty = batch_nnum_nempty
+    nnum_cum = cumsum(batch_nnum_nempty, dim=1, exclusive=True)
+
+    # merge octre properties
+    for d in range(self.depth + 1):
+      # key
+      keys = [None] * batch_size
+      for i in range(batch_size):
+        key = octrees[i].keys[d] & ((1 << 48) - 1)  # clear the highest bits
+        keys[i] = key | (i << 48)
+      self.keys[d] = torch.cat(keys, dim=0)
+
+      # children
+      children = [None] * batch_size
+      for i in range(batch_size):
+        # !! `clone` is used here to avoid modifying the original octrees
+        child = octrees[i].children[d].clone()
+        mask = child >= 0
+        child[mask] = child[mask] + nnum_cum[d, i]
+        children[i] = child
+      self.children[d] = torch.cat(children, dim=0)
+
+      # features
+      if octrees[0].features[d] is not None and d == self.depth:
+        features = [octrees[i].features[d] for i in range(batch_size)]
+        self.features[d] = torch.cat(features, dim=0)
+
+      # normals
+      if octrees[0].normals[d] is not None and d == self.depth:
+        normals = [octrees[i].normals[d] for i in range(batch_size)]
+        self.normals[d] = torch.cat(normals, dim=0)
+
+      # points
+      if octrees[0].points[d] is not None and d == self.depth:
+        points = [octrees[i].points[d] for i in range(batch_size)]
+        self.points[d] = torch.cat(points, dim=0)
+
+    return self
+
+  @classmethod
+  def init_like(cls, octree: 'Octree', device: Union[torch.device, str, None] = None):
+    r''' Initializes the octree like another octree.
+
+    Args:
+      octree (Octree): The reference octree.
+      device (torch.device or str): The device to use for computation.
+    '''
+
+    device = device if device is not None else octree.device
+    return cls(depth=octree.depth, full_depth=octree.full_depth,
+               batch_size=octree.batch_size, device=device)
+
+  @classmethod
+  def init_octree(cls, depth: int, full_depth: int = 2, batch_size: int = 1,
+                  device: Union[torch.device, str] = 'cpu'):
+    r'''
+    Initializes an octree to :attr:`full_depth`.
 
-  Returns:
-    Octree: The merged octree.
+    Args:
+      depth (int): The depth of the octree.
+      full_depth (int): The octree layers with a depth small than
+          :attr:`full_depth` are forced to be full.
+      batch_size (int, optional): The batch size.
+      device (torch.device or str): The device to use for computation.
+
+    Returns:
+      Octree: The initialized Octree object.
+    '''
+
+    octree = cls(depth, full_depth, batch_size, device)
+    for d in range(full_depth + 1):
+      octree.octree_grow_full(depth=d)
+    return octree
+
+
+def merge_octrees(octrees: List['Octree']):
+  r''' A wrapper of :meth:`Octree.merge_octrees`.
+
+  .. deprecated::
+    Use :meth:`Octree.merge_octrees` instead.
   '''
 
-  # init and check
-  octree = Octree(depth=octrees[0].depth, full_depth=octrees[0].full_depth,
-                  batch_size=len(octrees), device=octrees[0].device)
-  for i in range(1, octree.batch_size):
-    condition = (octrees[i].depth == octree.depth and
-                 octrees[i].full_depth == octree.full_depth and
-                 octrees[i].device == octree.device)
-    assert condition, 'The check of merge_octrees failed'
-
-  # node num
-  batch_nnum = torch.stack(
-      [octrees[i].nnum for i in range(octree.batch_size)], dim=1)
-  batch_nnum_nempty = torch.stack(
-      [octrees[i].nnum_nempty for i in range(octree.batch_size)], dim=1)
-  octree.nnum = torch.sum(batch_nnum, dim=1)
-  octree.nnum_nempty = torch.sum(batch_nnum_nempty, dim=1)
-  octree.batch_nnum = batch_nnum
-  octree.batch_nnum_nempty = batch_nnum_nempty
-  nnum_cum = cumsum(batch_nnum_nempty, dim=1, exclusive=True)
-
-  # merge octre properties
-  for d in range(octree.depth+1):
-    # key
-    keys = [None] * octree.batch_size
-    for i in range(octree.batch_size):
-      key = octrees[i].keys[d] & ((1 << 48) - 1)  # clear the highest bits
-      keys[i] = key | (i << 48)
-    octree.keys[d] = torch.cat(keys, dim=0)
-
-    # children
-    children = [None] * octree.batch_size
-    for i in range(octree.batch_size):
-      child = octrees[i].children[d].clone()  # !! `clone` is used here to avoid
-      mask = child >= 0                       # !! modifying the original octrees
-      child[mask] = child[mask] + nnum_cum[d, i]
-      children[i] = child
-    octree.children[d] = torch.cat(children, dim=0)
-
-    # features
-    if octrees[0].features[d] is not None and d == octree.depth:
-      features = [octrees[i].features[d] for i in range(octree.batch_size)]
-      octree.features[d] = torch.cat(features, dim=0)
-
-    # normals
-    if octrees[0].normals[d] is not None and d == octree.depth:
-      normals = [octrees[i].normals[d] for i in range(octree.batch_size)]
-      octree.normals[d] = torch.cat(normals, dim=0)
-
-    # points
-    if octrees[0].points[d] is not None and d == octree.depth:
-      points = [octrees[i].points[d] for i in range(octree.batch_size)]
-      octree.points[d] = torch.cat(points, dim=0)
-
-  return octree
+  return Octree.init_like(octrees[0]).merge_octrees(octrees)
 
 
 def init_octree(depth: int, full_depth: int = 2, batch_size: int = 1,
                 device: Union[torch.device, str] = 'cpu'):
-  r'''
-  Initializes an octree to :attr:`full_depth`.
-
-  Args:
-    depth (int): The depth of the octree.
-    full_depth (int): The octree layers with a depth small than
-        :attr:`full_depth` are forced to be full.
-    batch_size (int, optional): The batch size.
-    device (torch.device or str): The device to use for computation.
+  r''' A wrapper of :meth:`Octree.init_octree`.
 
-  Returns:
-    Octree: The initialized Octree object.
+  .. deprecated::
+    Use :meth:`Octree.init_octree` instead.
   '''
 
-  octree = Octree(depth, full_depth, batch_size, device)
-  for d in range(full_depth+1):
-    octree.octree_grow_full(depth=d)
-  return octree
+  return Octree.init_octree(depth, full_depth, batch_size, device)

{ocnn-2.2.6 → ocnn-2.2.8}/ocnn/octree/points.py

@@ -240,6 +240,7 @@ class Points:
 
     # Construct a new Points on the specified device
     points = Points(torch.zeros(1, 3, device=device))
+    points.batch_size = self.batch_size
     points.batch_npt = self.batch_npt
     points.points = self.points.to(device, non_blocking=non_blocking)
     if self.normals is not None:

{ocnn-2.2.6 → ocnn-2.2.8/ocnn.egg-info}/PKG-INFO

@@ -1,13 +1,12 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: ocnn
-Version: 2.2.6
+Version: 2.2.8
 Summary: Octree-based Sparse Convolutional Neural Networks
 Home-page: https://github.com/octree-nn/ocnn-pytorch
 Author: Peng-Shuai Wang
 Author-email: wangps@hotmail.com
 License: MIT
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
@@ -16,6 +15,17 @@ Requires-Dist: torch
 Requires-Dist: torchvision
 Requires-Dist: numpy
 Requires-Dist: packaging
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # O-CNN
 
@@ -63,6 +73,16 @@ We just did not post our paper on Arxiv during the review process of SIGGRAPH.
 Therefore, **the idea of constraining CNN computation into sparse non-emtpry
 voxels, i.e. Sparse Convolution,  is first proposed by our O-CNN**.
 
+<!--
+Developed in collaboration with authors from [PointCNN](https://arxiv.org/abs/1801.07791),
+[Dr. Yangyan Li](https://yangyan.li/) and [Prof. Baoquan Chen](https://baoquanchen.info/),
+-->
+This library supports point cloud processing from the ground up.
+The library provides essential components for converting raw point clouds into
+octrees to perform convolution operations. Of course, it also supports other 3D
+data formats, such as meshes and volumetric grids, which can be converted into
+octrees to leverage the library's capabilities.
+
 
 ## Key benefits of ocnn-pytorch
 

{ocnn-2.2.6 → ocnn-2.2.8}/setup.py

@@ -7,7 +7,7 @@
 
 from setuptools import setup, find_packages
 
-__version__ = '2.2.6'
+__version__ = '2.2.8'
 
 with open("README.md", "r", encoding="utf-8") as fid:
   long_description = fid.read()
@@ -29,7 +29,7 @@ setup(
     license='MIT',
     classifiers=[
         'Programming Language :: Python :: 3',
-        'License :: OSI Approved :: MIT License',
+        # 'License :: OSI Approved :: MIT License',
         'Operating System :: OS Independent',
     ],
 )