Original: Dimensionless instance segmentation by learning graph representations of point clouds
Revised: D IMENSIONLESS INSTANCE SEGMENTATION BY LEARNING GRAPH REPRESENTATIONS OF POINT CLOUDS

Original: Anonymous authors Paper under double-blind review
Revised: Anonymous authors Paper under double-blind review

Original: Abstract
Revised: A BSTRACT

Original: Point clouds are an increasingly common spatial data modality, being produced by sensors used in robotics and self-driving cars, and as natural intermediate representations of objects in microscopy and other bioimaging domains (e.g., cell locations over time, or filaments, membranes, or organelle boundaries in cryo-electron micrographs or tomograms).
Revised: Point clouds are an increasingly common spatial data modality, being produced by sensors used in robotics and self-driving cars, and as natural intermediate representations of objects in microscopy and other bioimaging domains (e.g., cell locations over time, or filaments, membranes, or organelle boundaries in cryo-electron micrographs or tomograms).

Original: However, semantic and instance segmentation of this data remains challenging due to the complex nature of objects in point clouds.
Revised: However, semantic and instance segmentation of this data remains challenging due to the complex nature of objects in point clouds.

Original: Especially in bioimaging domains where objects are often large and can be intersecting or overlapping.
Revised: Especially in bioimaging domains where objects are often large and can be intersecting or overlapping.

Original: Furthermore, methods for operating on point clouds should not be sensitive to the specific orientation or translation of the point cloud, which is often arbitrary.
Revised: Furthermore, methods for operating on point clouds should not be sensitive to the specific orientation or translation of the point cloud, which is often arbitrary.

Original: Here, we frame the point cloud instance segmentation problem as a graph learning problem in which we seek to learn a function that accepts the point cloud as  input and outputs a probability distribution over neighbor graphs in which connected components of the graph correspond to individual object instances.
Revised: Here, we frame the point cloud instance segmentation problem as a graph learning problem in which we seek to learn a function that accepts the point cloud as an input and outputs a probability distribution over neighbor graphs in which connected components of the graph correspond to individual object instances.

Original: We introduce the Dimensionless Instance Segmentation Transformer (DIST), a deep neural network for spatially invariant instance segmentation of point clouds to solve this point cloud-to-graph problem.
Revised: We introduce the Dimensionless Instance Segmentation Transformer (DIST), a deep neural network for spatially invariant instance segmentation of point clouds to solve this point cloud-to-graph problem.

Original: DIST uses an SO(n) invariant transformer layer architecture to operate on point clouds of arbitrary dimension and outputs, for each pair of points, the probability that an edge exists between them in the instance graph.
Revised: DIST uses an SO(n) invariant transformer layer architecture to operate on point clouds of arbitrary dimension and outputs, for each pair of points, the probability that an edge exists between them in the instance graph.

Original: We then decode the most likely set of instances using a graph cut.
Revised: We then decode the most likely set of instances using a graph cut.

Original: We demonstrate the power of DIST for the segmentation of biomolecules in cryo-electron micrographs and tomograms, far surpassing existing methods for membrane and filament segmentation in empirical evaluation.
Revised: We demonstrate the power of DIST for the segmentation of biomolecules in cryo-electron micrographs and tomograms, far surpassing existing methods for membrane and filament segmentation in empirical evaluation.

Original: DIST also applies to scene and object understanding, performing competitively on the ScanNetV2 3D instance segmentation challenge.
Revised: DIST also applies to scene and object understanding, performing competitively on the ScanNetV 3D instance segmentation challenge.

Original: We anticipate that DIST will underpin a new generation of methods for point cloud segmentation in bioimaging and that our general model and approach will provide useful insights for point cloud segmentation methods in other domains.
Revised: We anticipate that DIST will underpin a new generation of methods for point cloud segmentation in bioimaging and that our general model and approach will provide useful insights for point cloud segmentation methods in other domains.

Original:  Introduction
Revised:  I NTRODUCTION

Original: Point clouds are a common way to represent objects or scenes in a computer, and are widely used in computer vision, augmented and virtual reality, and imaging.
Revised: Point clouds are a common way to represent objects or scenes in a computer, and are widely used in computer vision, augmented and virtual reality, and imaging.

Original: Point clouds of scenes are often subsequently processed to semantically classifythe points - semantic segmentationor to segment individual objects and instances - instance segmentation ( Figure 1 ).
Revised: Point clouds of locations are often subsequently processed to semantically classify points - semantic segmentation - or to segment individual objects and instances - instance segmentation ( Figure 1 ).

Original: Unlike 2D or 3D images, point clouds are disordered, unstructured, and may have noisy point locations, making it difficult to design algorithms or machine learning models to process them.
Revised: Unlike 2D or 3D images, point clouds are disordered, unstructured, and may have noisy point locations, making it difficult to design algorithms or machine learning models to process them.

Original: Deep learning methods for processing point clouds have become of increasing interest with the increase in point cloud data  being generated by sensors in robotics and as a representation of objects in physics engines, natural images, and bioimaging.
Revised: Deep learning methods for processing point clouds have become of increasing interest as more and more point cloud data are being generated by sensors in robotics and as a representation of objects in physics engines, natural images, and bioimaging.

Original: Many recent methods have been developed to segment point clouds using deep learning (Lai et al.
Revised: Many recent methods have been developed to segment point clouds using deep learning (Lai et al., 2022;

Original: ; Qi et al. Wang (2020); Zanjani et al. (2021); Guo et al.
Revised: Qi et al., 2017; Wang, 2020; Zanjani et al., 2021;

Original: (2020); Hong and Pavlic (2021); Pan et al.
Revised: Guo et al., 2020; Hong and Pavlic, 2021;

Original: ; Yuan (2021)), which address the instance, scene, or part segmentation problems using various architectures or training schemes.
Revised: Pan et al., 2018; Yuan, 2021), which address the instance, scene, or part segmentation problems using various architectures or training schemes.

Original: However, instance segmentation methods require prior information about the number ofinstances that are present  or assume some fixed number of instances.
Revised: However, instance segmentation methods require prior information about the number of present instances or assume some fixed number of instances.

Original: Furthermore, many methods convert point clouds into pixelor voxel-grids to process them with convolutional layers, or otherwise incorporate point coordinates directly into the network, causing their outputs not to be invariant to rotation and translation of the point cloud.
Revised: Furthermore, many methods convert point clouds into pixel- or voxel-grids to process them with convolutional layers, or otherwise incorporate point coordinates directly into the network, causing their outputs not to be invariant to rotation and translation of the point cloud.

Original: In cryo-electron microscopy, an increasingly common task is to segment individual filaments, membranes, organelles, or other biological structures in 2D micrographs or 3D tomograms.
Revised: In cryo-electron microscopy, an increasingly common task is to segment individual filaments, membranes, organelles, or other biological structures in 2D micrographs or 3D tomograms.

Original: These objects are often large and can intersect or overlap causing instance segmentation to be difficult even if a semantic segmentation mask is known.
Revised: These objects are often large and can intersect or overlap causing instance segmentation to be difficult even if a semantic segmentation mask is known.

Original: Experienced scientists or technicians often spend weeks to months painstakingly manually labeling these data sets for downstream analysis, limiting throughput.
Revised: Experienced scientists or technicians often spend weeks to months painstakingly manually labeling these datasets for downstream analysis, limiting throughput.

Original: Current state-of-the-art methods barely help.
Revised: Current state-of-the-art methods barely help.

Original: For filament instance segmentation, for example, these methods utilize algorithms custom-tailored to curve tracing (Chai et al. but have such high error rates that scientists still spend days manually correcting annotationerrors, if the algorithms work at all (Redemann et al. Stalling et al.
Revised: For filament instance segmentation, for example, these methods utilize algorithms custom-tailored to curve tracing (Chai et al., 2022) but have such high error rates that scientists still spend days manually correcting annotation if the algorithms work at all (Redemann et al., 2014; Stalling et al., 2005).

Original: Faster and more accurate instance segmentation methods are urgently needed to facilitate large-scale analysis of these data sets as imaging technology improves.
Revised: Faster and more accurate instance segmentation methods are urgently needed to facilitate large-scale analysis of these datasets as imaging technology improves.

Original: To address these problems, we propose the Dimensionless Instance Segmentation Transformer (DIST).
Revised: To address these problems, we propose the Dimensionless Instance Segmentation Transformer (DIST).

Original: DIST is able to perform SO(n) invariant instance segmentation of point clouds using only geometric features.
Revised: DIST is able to perform SO(n) invariant instance segmentation of point clouds using only geometric features.

Original: We accomplish this by framing instance segmentation as a graph prediction problem.
Revised: We accomplish this by framing instance segmentation as a graph prediction problem.

Original: Given a point cloud as input, DIST outputs a probability distribution over graphs parameterized by the probability, for each pair of points, that those points are neighbors in sub-graphs defining each instance.
Revised: Given a point cloud as input, DIST outputs a probability distribution over graphs parameterized by the probability, for each pair of points, that those points are neighbors in sub-graphs defining each instance.

Original: Instances, therefore, are defined by connected components of the full point cloud graph.
Revised: Instances, therefore, are defined by connected components of the full point cloud graph.

Original: With the output of DIST, we are able to find the most likely instance segmentation using a graph cut.
Revised: With the output of DIST, we are able to find the most likely instance segmentation using a graph cut.

Original: This allows us to perform instance segmentation on any number of underlying instances without any built in restrictions on the maximum number of instances.
Revised: This allows us to perform instance segmentation on any number of underlying instances without any built-in restrictions on the maximum number of instances.

Original: Furthermore, DIST is invariant to rotation and translations of the point cloud, because it operates on point-point pairwise representations initially defined by the distances between the points. 
Revised: Furthermore, DIST is invariant to rotation and translations of the point cloud, because it operates on point-point pairwise representations initially defined by the distances between the points. This also makes DIST dimensionless as the distance between points is invariant for a number of dimensions.

Original: The DIST layers updatethese edge representations using geometrically inspired operations, axial attention updates over the source and destination nodes and a triangular multiplicative update, inspired by (Jumper et al.
Revised: The DIST layers update edge representations using geometrically inspired operations, axial attention updates over the source and destination nodes, and a triangular multiplicative update, inspired by (Jumper et al., 2021).

Original: DIST can, optionally, accept additional, non-spatial, point featureswhich are incorporated via a traditional transformer layer where the attention updates include a bias term learned from the learned edge features.
Revised: DIST can, optionally, accept additional, non-spatial, point features incorporated via a traditional transformer layer where the attention updates include a bias term learned from the learned edge features.

Original: Empirically, we find that DIST performs incredibly well, improving the state of the art in membrane instance segmentation in 2D micrographs and microtubule (MT) segmentation in 3D tomograms by a large margin (from 0.539 mCov for Amira to 0.955 mCov with DIST).
Revised: Empirically, we find that DIST performs incredibly well, improving on current state-of-the-art solution for membrane instance segmentation in 2D micrographs and microtubule (MT) segmentation in 3D tomograms by a large margin (from 0.539 mCov for Amira to 0.955 mCov with DIST).

Original: DISTis also applicable to instance segmentation of other point clouds, outperforming other geometric methods for instance segmentation on ScanNetV2 (Dai et al.
Revised: DIST also applies to instance segmentation of other point clouds, outperforming other geometric methods for instance segmentation on ScanNetV2 (Dai et al., 2017) and showing competitive results for current state-of-the-art models.

Original: In this work, we make the following contributions
Revised: In this work, we make the following contributions:

Original: : • We frame instance segmentation as a graph learning problem, where we learn a function that maps point clouds to distributions over neighbor graphs in which instances are connected components.
Revised: • We frame instance segmentation as a graph learning problem, where we learn a function that maps point clouds to distributions over neighbor graphs in which instances are connected components.

Original: • We introduce the Dimensionless Instance Segmentation Transformer (DIST) to perform SO(n) invariant inference on the instance neighbor graph using the point cloud as input.
Revised: • We introduce the Dimensionless Instance Segmentation Transformer (DIST) to perform SO(n) invariant inference on the instance neighbor graph using the point cloud as input.

Original: • DIST can operate on point clouds with only geometric features and can, optionally, incorporate additional point features.
Revised: • DIST can operate on point clouds with only geometric features and can, optionally, incorporate additional point features.

Original: • DIST does not require prior knowledge about the number of instances in a point cloud and has no built in limitations on the number of instances that can be segmented simultaneously.
Revised: • DIST does not require prior knowledge about the number of instances in a point cloud and has no built-in limitations on the number of instances that can be segmented simultaneously.

Original: • Empirical results show that DIST dramatically outperforms previous methods for membrane and microtubule segmenation in cryo-electron microscopy data and that DIST outperforms other geometric methods for instance segmentation in natural 3D scene scans.
Revised: • Empirical results show that DIST dramatically outperforms previous methods for membrane and microtubule segmentation in cryo-electron microscopy data and that DIST outperforms other geometric methods for instance segmentation in natural 3D scene scans.

Original:  Related Work
Revised:  R ELATED W ORK

Original: Recently, interest in point cloud segmentation methods has increased significantly, partly enabled by benchmarks such as ScanNetV2 ( Appendix Table B )
Revised: Recently, interest in point cloud segmentation methods has increased significantly, partly enabled by benchmarks such as ScanNetV2 ( Appendix Table B )

Original: (Dai et al.
Revised: (Dai et al., 2017).

Original: Point cloud segmentation tasks are generally divided into semantic, part, and instance segmentation.
Revised: Point cloud segmentation tasks are generally divided into semantic, part, and instance segmentation.

Original: Deep learning methods for semantic and part segmentation, such as PointNet++ (Qi et al. and Point Cloud Transformer (Guo et al. (2020)), have achieved significant improvements.
Revised: Deep learning methods for semantic and part segmentation, such as PointNet++ (Qi et al., 2017) and Point Cloud Transformer (Guo et al., 2020) have achieved significant improvements.

Original: Instance segmentation methods have also improved, but these improvements have been slower due to the additional challenge inthe task formulation.
Revised: Instance segmentation methods have also improved, but these improvements have been slower due to the additional challenge in task formulation.

Original: Here, we concentrate on instance segmentation methods as that is the focus of this work.
Revised: Here, we concentrate on instance segmentation methods as that is the focus of this work.

Original: Instance segmentation methods can generally be divided into two groups: proposal-based and proposal-free.
Revised: Instance segmentation methods can generally be divided into two groups: proposal-based and proposal-free.

Original: Proposal-based methods convert instance segmentation into sub-tasks: 1) find bounding boxes of the objects, and 2) for each detected object, map  back to the input to find an instance segmentation.
Revised: Proposal-based methods convert instance segmentation into sub-tasks: 1) find bounding boxes of the objects, and 2) for each detected object, map it back to the input to find an instance segmentation.

Original: This requires multi-stage training and pruning incorrect object predictions.
Revised: This requires multi-stage training and pruning incorrect object predictions.

Original: Methods such as 3D-SIS (Hou et al. , LiDARSeg (Zhang et al. (2020)), and 3D-MPA (Engelmann et al. (2020)) use this approach.
Revised: Methods such as 3D-SIS (Hou et al., 2018), LiDARSeg (Zhang et al., 2020), and 3D-MPA (Engelmann et al., 2020) use this approach.

Original: Because these methods rely on an initial object detection pass with objects defined as bounding boxes, they are not appropriate for instance segmentation when objects cannot be discretely separated into bounding boxes or are otherwise poorly represented by regions.
Revised: Because these methods rely on an initial object detection pass with objects defined as bounding boxes, they are not appropriate for instance segmentation when objects cannot be discretely separated into bounding boxes or are otherwise poorly represented by regions.

Original: Proposal-free methods generally approach instance segmentation as a clustering step after semantic segmentation.
Revised: Proposal-free methods generally approach instance segmentation as a clustering step after semantic segmentation.

Original: PartNet
Revised: PartNet

Original: (Mo et al. and PointGroup (Jiang et al. (2020b)) achieve this with discriminative feature learning and point grouping.
Revised: (Mo et al., 2018) and PointGroup (Jiang et al., 2020b) achieve this with discriminative feature learning and point grouping.

Original: However, these methods often struggle to correctly distinguish instance boundaries.
Revised: However, these methods often struggle to correctly distinguish instance boundaries.

Original: A handful of graph-based methods have been considered for operating on point clouds.
Revised: A handful of graph-based methods have been considered for operating on point clouds.

Original: In these methods, point clouds are generally converted into a k-nearest neighbors graph before being processed with a graph convolutional neural network (GCNN; Guo et al.
Revised: In these methods, point clouds are generally converted into a k-nearest neighbors graph before being processed with a graph convolutional neural network (GCN; (Guo et al., 2021)).

Original: For example, Simonovsky and Komodakis (2017) use GCNNs for object classification from Sydney Urban Objects data set and chemical structures where each atoms were represented as nodes.
Revised: For example, (Simonovsky and Komodakis, 2017) use GCNs for object classification from Sydney Urban Objects dataset and chemical structures where each atom was represented as a node.

Original: This was extended by Pan et al. (2018) to do part and rotated 3D object classification on  PartNet data set using dynamic GCN.
Revised: This was extended by (Pan et al., 2018) to do part and rotated 3D object classification on the PartNet dataset using dynamic GCN.

Original: However, there are only two graph-based methods that have been proposed for instance segmentation, to our knowledge, OTOC (Liu et al. (2021)) and SegGroup (Tao et al. (2022)).
Revised: However, there are only two graph-based methods that have been proposed for instance segmentation, to our knowledge, OTOC (Liu et al., 2021) and SegGroup (Tao et al., 2022).

Original: These methods output node features which are used for instance segmentation similarly to proposal-free methods.
Revised: These methods output node features that are used for instance segmentation similar to proposal-free methods.

Original: In contrast, our method outputs a graph which defines instances directly.
Revised: In contrast, our method outputs a graph that defines instances directly.

Revised: It was achieved via a triangular multiplication layer (Jumper et al., 2021) that allowed DIST to learn a geometrical representation of instances.

Revised: Jumper et.

Revised: al., use triangular multiplication to update their pair representations, which correspond to each pair of columns in their multiple sequence alignment.

Revised: This was used to learn triangle inequality in their MSA representation.

Revised: In our study, we observed that this approach also allows for defining a distance-inspired update for our edge/pairwise point representations.

Original:  Furthermore, our method does not require semantic input features, unlike OTOC and SegGroup.
Revised: Jumper et. al., apply these updates sequentially to rows and columns whereas we apply them independently to each and then accumulate those updates. We also include row and column axial attention updates which improved our ability to resolve object instances that were close to each other. Furthermore, our method does not require semantic input features, unlike OTOC and SegGroup.

Original: DIST also outperforms OTOC and
Revised: DIST also outperforms OTOC and

Original: SegGroup by a considerable margin on the ScanNetV2 instance segmentation dataset.
Revised: SegGroup by a considerable margin on the ScanNetV2 instance segmentation dataset.

Original:  Method
Revised:  M ETHOD

Original: Instance segmentation with DIST is divided into three parts (Figure 2): 1) the raw point cloud is converted into a pairwise representation based on distances between the points, 2) the edge representations are fed through the DIST model to produce an output matrix containing the probability, for each pair of points, that there is an edge between them in the instance graph, and 3) the maximum likelihood graph defined by the edge probabilities is found using a graph cut algorithm.
Revised: Instance segmentation with DIST is divided into three parts ( Figure 2 ): 1) the raw point cloud is converted into a pairwise representation based on distances between the points, 2) the edge representations are fed through the DIST model to produce an output matrix containing the probability, for each pair of points, that there is an edge between them in the instance graph, and 3) the maximum likelihood graph defined by the edge probabilities is found using a graph cut algorithm.

Original: This final predicted graph defines thepredicted instance segmentation.
Revised: This finally predicted graph defines the instance segmentation.

Original: The DIST model is trained to predict the ground truth edges in labeled instance graphs using standard neural network training techniques, backpropagation and stochastic gradient descent.define
Revised: The DIST model is trained to predict the ground truth edges in labeled instance graphs using standard neural network training techniques, back-propagation and stochastic gradient descent.

Original: 3. Pairwise-feature input embedding
Revised: 3. P AIRWISE - FEATURE INPUT EMBEDDING

Original: The DIST model operates on pairwise features.
Revised: The DIST model operates on pairwise features.

Original: That is, for each pair of points in the point cloud, DIST learns a vector representation.
Revised: That is, for each pair of points in the point cloud, DIST learns a vector representation.

Original: We refer to these as pairwise embeddings or edge embeddings.
Revised: We refer to these as pairwise embeddings or edge embeddings.

Original: In order to ensure that our representations are invariant to the translation and rotation of the point cloud, we initialize the edge features using the corresponding  between each pair of nodes.
Revised: In order to ensure that our representations are invariant to the translation and rotation of the point cloud, we initialize the edge features using the corresponding distance between each pair of nodes.

Original: Because we think that nearby points are more important than distant points within the point cloud, we define these features using a scaled exponential of the negative squared distance.
Revised: Because we think that nearby points are more important than distant points within the point cloud, we define these features using a scaled exponential of the negative squared distance.

Original: More formally, given a point cloud represented as a set of points p i where i = 1, . . . , n , we initialize a graph G with a featureless node for each p i , and edges e i,j connecting all nodes, with weights e i,j = exp (  d 2 i,j s 2 ∗ 2 ) , where d i,j is the euclidean distance between p i and p j , and s is sigma denoted as fixed scaling factor for  normalized point cloud.
Revised: More formally, given a point cloud represented as a set of points p i where i = 1, ..., n , we initialize a graph G with a featureless node for each p i , and edges e i,j connecting all nodes, with weights e i,j = exp ( − d 2 i,j s 2 ∗ 2 ) , where d i,j is the euclidean distance between p i and p j , and s is sigma denoted as fixed scaling factor for the normalized point cloud.

Original: This weighting approach allows us to embed geometrical information about all points directly from the Euclidean distance.
Revised: This weighting approach allows us to embed geometrical information about all points directly from the Euclidean distance.

Original: These weights are then multiplied with a learned d − dimensional embedding vector to define the initial edge representations.
Revised: These weights are then multiplied with a learned d − dimensional embedding vector to define the initial edge representations.

Original: 3. Geometric Transformer Layer
Revised: 3. G EOMETRIC T RANSFORMER L AYER

Original: Starting from the initial edge representations, we apply several steps of axial multi-head attention (MHA) and triangular multiplicative updates (Appendix Figure C-B).
Revised: Starting from the initial edge representations, we apply several steps of axial multi-head attention (MHA) and triangular multiplicative updates ( Appendix Figure C-B ).

Original: Each overall step is referred to as a "DIST layer" (Appendix Figure C-C), and the edge update that occurs within each DIST layer (composed of simultaneous MHA and triangular multiplicative updates) is referred to as the "Edge update" module (Appendix Figure C-D).
Revised: Each overall step is referred to as a "DIST layer" ( Appendix Figure C-C ), and the edge update that occurs within each DIST layer (composed of simultaneous MHA and triangular multiplicative updates) is referred to as the "Edge update" module ( Appendix Figure C-D ).

Original: In the following description, we describe actions on rows/columns of the graph representation of G , which corresponds to the set of incoming or outgoing edges of G .
Revised: In the following description, we describe actions on rows/columns of the graph representation of G , which corresponds to the set of incoming or outgoing edges of G .

Original: MHA module was adapted from the original paper (Vaswani et al.
Revised: MHA module was adapted from the original paper (Vaswani et al., 2017).

Revised: MHA was chosen to increase stability and captures the relationships between node/edges with every node/edge in the point cloud.

Original: It performs axial attention updates over rows or columns of the graph.
Revised: It achieved it by performing axial attention updates over rows or columns of the graph.

Original: In axial updates, we switch between interpreting the rows or columns as the length axis of the tensor and apply typical multi-head attention.
Revised: In axial updates, we switch between interpreting the rows or columns as the long axis of the tensor and apply typical multi-head attention.

Original: This corresponds to attending over edges outgoing from a node (row attention) or incoming to a node (column attention).
Revised: This corresponds to attending over edges outgoing from a node (row attention) or incoming to a node (column attention).

Original: This is followed by a fully connected layer with residual connections from the row and column axial attention operations to generate the output edge features.
Revised: This is followed by a fully connected layer with residual connections from the row and column axial attention operations to generate the output edge features.

Original: Triangular multiplicative update was adapted from (Jumper et al.
Revised: Triangular multiplicative update was adapted from (Jumper et al., 2021), with a detailed design depicted in Appendix Figure C-E and pseudo-code shown in Appendix D . We chose to perform this operation to allow DIST to directly learn the relationship between each node. Triangular update in Jumper work was performed by a sequential operation over rows and columns, which was essential to learn MSA representation.

Original: (2021)), with a detailed design depicted in Figure C-E and pseudo-code shown in Appendix D. The triangular  update takes an input edge feature embedding and performs Einstein summation over row or column features, followed by a linear layer with gating to obtain an update for the edge feature embedding.
Revised: In our approach, we perform the triangular operations at the same time for rows and columns which allowed us to better learn of geometrical features of a point cloud. The triangular multiplicative update could achieve it by utilizing point distances encoding their geometrical features from which triangular update could learn instance representation. The triangular update achieves it by taking an input edge feature embedding and performing Einstein summation over row or column features, followed by a linear layer with gating to obtain an update for the edge feature embedding.

Original: At each DIST layer, the output from both the MHA and triangular multiplicative updates are added to the incoming edge features, and the resulting updated edge features are fed through an activation function before being used as the input to the next DIST layer.
Revised: At each DIST layer, the output from both the MHA and triangular multiplicative updates are added to the incoming edge features, and the resulting updated edge features are fed through an activation function before being used as the input to the next DIST layer.

Original: Finally, after the last DIST layer, the resulting edges in the graph are fed through a single linear layer to obtain a probability for that edge.
Revised: Finally, after the last DIST layer, the resulting edges in the graph are fed through a single linear layer to obtain a probability for that edge.

Original: 3. Graph Cut Instance Segmentation
Revised: 3. G RAPH C UT I NSTANCE S EGMENTATION

Original: The final DIST graph representation contains the predicted probability for each edge in the instance graph of the point cloud, which can be used to obtain an instance segmentation.
Revised: The final DIST graph representation contains the predicted probability for each edge in the instance graph of the point cloud, which can be used to obtain an instance segmentation.

Original: A simple segmentation can be achieved by thresholding the probabilities and examining the resulting graph.
Revised: A simple segmentation can be achieved by thresholding the probabilities and examining the resulting graph.

Original: With graph structure constraints.

Original: For some problems, we may have additional information about the graph structure.
Revised: For some problems, we may have additional information about the graph structure.

Original: For example, for filament and membrane segmentation, we know the graph is defined as a linear chain in which a node can have at most 2 neighbors.
Revised: For example, for filament and membrane segmentation, we know the graph is defined as a linear chain in which a node can have at most 2 neighbors.

Original: In this case, we adopt a greedy algorithm for graph inference (Appendix E).
Revised: In this case, we adopt a greedy algorithm for graph inference ( Appendix E ).

Original: First, we build a hash map for each node in the point cloud containing node ID P i , edge probability p i,j .
Revised: First, we build a hash map for each node in the point cloud containing node ID P i and edge probability p i,j .

Original: Next, for each new instance, we searched the hash map for the initial node.
Revised: Next, for each new instance, we searched the hash map for the initial node.

Original: This allows us in the final step to iteratively find up to two edges with the highest probability for all connected nodes.
Revised: This allows us in the final step to iteratively find up to two edges with the highest probability for all connected nodes.

Original: This process is continued until no new edges can be recognized for a given instance.
Revised: This process is continued until no new edges can be recognized for a given instance.

Original: We use this approach when segmenting membranes and microtubules which follow this chain structure.
Revised: We use this approach when segmenting membranes and microtubules which follow this chain structure.

Original: 3. Implementation Details 3.4. Model hyperparameters
Revised: 3. I MPLEMENTATION D ETAILS 3.4. M ODEL HYPERPARAMETERS

Original: In all experiments we use a DIST model with 6 layers, 8 attention heads, and a hidden dimension of 128.
Revised: In all experiments, we use a DIST model with 6 layers, 8 attention heads, and a hidden dimension of 128.

Original: We lightly tuned the value of sigma, finding that both biological datasets  a value of 2 and for ScanNetV2 a value of 0.05 gave the best results on the training set.
Revised: We lightly tuned the value of sigma, finding that both biological datasets had a value of 2, and for ScanNetV2 a value of 0.05 gave the best results on the training set.

Original: All DIST models were trained with binary cross entropy loss using the ADAM optimizer with learning rate 10 − 5 and no weight decay on a single NVIDIA A100 GPU.
Revised: All DIST models were trained with binary cross entropy loss using the ADAM optimizer with learning rate 10 − 5 and no weight decay on a single NVIDIA A100 GPU.

Original: DIST model training was stopped when the validation loss did not improve after 50  epochs.
Revised: DIST model training was stopped when the validation loss did not improve after 50 consecutive epochs.

Original: 3.4. Point Cloud Pre-Processing
Revised: 3.4. P OINT C LOUD P RE -P ROCESSING

Original: There are two major challenges in point cloud instance segmentation: 1) uneven point spacing within and between data sets, which makes learning  generalizable local features difficult, and 2) the size of the point cloud, which is often too large to process due to memory constraints, because the RAM usage of DIST scales cubicly (axial attention requires quadratic attention for each point) with the number of points, making large point clouds require far more RAM than is available on current GPUs.
Revised: There are two major challenges in point cloud instance segmentation: 1) uneven point spacing within and between datasets, which makes learning difficult to learn generalizable local features, and 2) the size of the point cloud, which is often too large to process due to memory constraints, because the RAM usage of DIST scales cubically (axial attention requires quadratic attention for each point) with the number of points, making large point clouds require far more RAM than is available on current GPUs.

Original: Point cloud re-scaling.
Revised: Point cloud re-scaling.

Original: We tackle the uneven sampling resolution problem by re-scaling the point cloud.
Revised: We tackle the uneven sampling resolution problem by re-scaling the point cloud.

Original: We scale the point clouds for biological data - where point clouds are derived from image data - by using the physical pixel size and normalizing the data such that distances between points are scaled in Angstroms.
Revised: We scale the point clouds for biological data - where point clouds are derived from image data - by using the physical pixel size and normalizing the data such that distances between points are scaled in Angstroms.

Original: In the case of ScanNetV2 data sets, no additional point cloud normalization was done.
Revised: In the case of ScanNetV2 datasets, no additional point cloud normalization was done.

Original: Cropping and stitching.
Revised: Cropping and stitching.

Original: Next, we tackle the memory cost of computing.
Revised: Next, we tackle the memory cost of computing.

Original: In the case of the DIST model, the size of the point cloud poses a challenge due to cubic complexity.
Revised: In the case of the DIST model, the size of the point cloud poses a challenge due to cubic complexity.

Original: This makes it impossible to process very large scenes due to GPU memory constraints.
Revised: This makes it impossible to process very large scenes due to GPU memory constraints.

Original: Although many methods for improving memory efficiency were demonstrated (Kyzirakos et al. Hui et al. ; Liu et al. , all of them achieve it at the cost of computation speed, down-sampling, or losing semantic or geometrical information.
Revised: Although many methods for improving memory efficiency were demonstrated (Kyzirakos et al., 2016; Hui et al., 2021; Liu et al., 2019), all of them achieve it at the cost of computation speed, down-sampling, or losing semantic or geometrical information.

Original: We define the instance segmentation problem as the segmentation of geometrically similar objects.
Revised: We define the instance segmentation problem as the segmentation of geometrically similar objects.

Original: Therefore, we expect most of the information to be present within local regions.
Revised: Therefore, we expect most of the information to be present within local regions.

Original: With this in mind, we reduced the size of the point clouds by cropping (Appendix Figure A).
Revised: With this in mind, we reduced the size of the point clouds by cropping ( Appendix Figure A ).

Original: During training, we select crops at random.
Revised: During training, we select crops at random.

Original: For inference, we split the point cloud into tiled regions and then use overlap between the regions to stitch the graph across region boundaries.
Revised: For inference, we split the point cloud into tiled regions and then use overlap between the regions to stitch the graph across region boundaries.

Original: For each dataset, we selected the maximum crop size that would fit into GPU RAM.
Revised: For each dataset, we selected the maximum crop size that would fit into GPU RAM.

Original:  Experiments
Revised:  E XPERIMENTS

Original: Datasets.
Revised: Datasets.

Original: Because our primary motivation is to perform instance segmentation on biological structures in electron microscopy (EM) data, we compare the performance of DIST to the current state-of-the-art algorithms for instance segmentation of filament-like structures on real-world EM data.
Revised: Because our primary motivation is to perform instance segmentation on biological structures in electron microscopy (EM) data, we compare the performance of DIST to the current state-of-the-art algorithms for instance segmentation of filament-like structures on real-world EM data.

Original: We evaluate DIST on a membrane segmentation task in 2D cryoEM micrographs and a microtubule segmenation task in 3D plastic section tomograms.
Revised: We evaluate DIST on a membrane segmentation task in 2D cryo-EM micrographs and a microtubule (MT) segmentation task in 3D plastic section tomograms.

Original: For both data sets, ground truth labels are derived from manual annotation by an experience microscopist.
Revised: For both datasets, ground truth labels are derived from manual annotation by an experienced microscopist.

Original: The datasets contain 76 micrographs of membranes (2D scenes; with 500-2’ points each) and 48 MT tomograms (3D scenes; with 10’000-50’000 points each).
Revised: The datasets contain 76 micrographs of membranes (2D scenes; with 500-2’500 points each) and 48 MT tomograms (3D scenes; with 10’000-50’000 points each).

Original: We split these into  train, validation, and test sets with an 80/10/10 split ratio.
Revised: We split these into a train, validation, and test sets with an 80/10/10 split ratio.

Original: We also evaluate DIST for instance segmentation of point clouds containing natural objects and benchmark it against other instance segmentation methods on the ScanNetV2 3D instance segmentation challenge (Dai et al.
Revised: We also evaluate DIST for instance segmentation of point clouds containing natural objects and benchmark it against other instance segmentation methods on the ScanNetV2 3D instance segmentation challenge (Dai et al., 2017).

Original: For ScanNet, we train on the standard training set and report results on the validation set.
Revised: For ScanNetV2, we train on the standard training set and report results on the validation set.

Original: Ground truth generation
Revised: Ground truth generation.

Original: In order to train and evaluate the DIST model we need to build an instance graph representation of the point cloud.
Revised: In order to train and evaluate the DIST model we need to build an instance graph representation of the point cloud.

Original: The graph representation is a 2D matrix with nodes ( P i , j ; matrix diagonal) representing each individual coordinate point, and the edge represent spatial connectivity between two nodes i and j , where i is the matrix row, and j is matrix column.
Revised: The graph representation is a 2D matrix with nodes ( P i , j ; matrix diagonal) representing each individual coordinate point, and the edge represent spatial connectivity between two nodes i and j , where i is the matrix row, and j is matrix column.

Original: The graph representation for filament-like structures (membranes and microtubules) is constructed from ground truth annotations in which each individual instance is an ordered list of nodes.
Revised: The graph representation for filament-like structures (membranes and microtubules) is constructed from ground truth annotations in which each individual instance is an ordered list of nodes.

Original: Knowing the order, the edge matrix is define as 1 for each P i,j if i is in the same instance as j and j is a neighbors of i in the ordered list.
Revised: Knowing the order, the edge matrix is defined as 1 for each P i,j if i is in the same instance as j and j is a neighbor of i in the ordered list.

Original: This approach imposes restrictions where each i can have only up to two edges.
Revised: This approach imposes restrictions where each i can have only up to two edges.

Original: In contrast, the ScanNetV2 dataset consist of semantically labeled point clouds obtained from LIDAR scanned scenes.
Revised: In contrast, the ScanNetV2 dataset consists of semantically labeled point clouds obtained from Lidar-scanned scenes.

Original: In this case, we construct the graph by labeling as 1 each P i,j , if i is in the same instance as j and if the distance from j to i is less than the average k NN distance between all points.
Revised: In this case, we construct the graph by labeling as 1 each P i,j , if i is in the same instance as j and if the distance from j to i is less than the average k NN distance between all points.

Original: In both cases, the instances are connected subgraphs of the full point cloud graph.
Revised: In both cases, the instances are connected sub-graphs of the full point cloud graph.

Original: Graph representation evaluation We performed experiments on 2D and 3D point clouds manually segmented by experienced users.
Revised: Graph representation evaluation. We performed experiments on 2D and 3D point clouds manually segmented by experienced users.

Original: The evaluation metric used for the graph prediction is intersection over union (mIoU) averaged over all cropped graphs.
Revised: The evaluation metric used for the graph prediction is intersection over union (mIoU) averaged over all cropped graphs.

Original: Due to the lack of  comparable real or synthetic benchmark data set to which we could compare our DIST graph prediction, we defined here our baseline independently.
Revised: Due to the lack of a comparable real or synthetic benchmark dataset to which we could compare our DIST graph prediction, we defined here our baseline independently.

Original: The baseline was defined as a point cloud graph representation generated from point distances.
Revised: The baseline was defined as a point cloud graph representation generated from point distances.

Original: This was achieved by computing the distance between each pair of nodes in a point cloud.
Revised: This was achieved by computing the distance between each pair of nodes in a point cloud.

Original: Instance segmentation evaluation To benchmark instance segmentation performance for membrane and microtubules data sets we measured mean class coverage (mCov; Jiang et al.
Revised: Instance segmentation evaluation. To benchmark instance segmentation performance for membrane and microtubules datasets we measured mean class coverage (mCov; (Jiang et al., 2020a)).

Original: (2020a)).This metric measures IoU between the ground truth label and its matching predictions.
Revised: This metric measures IoU between the ground truth label and its matching predictions.

Original: Additionally, for this data sets we also generate our baseline using state-of-the-art segmentation software ZiB Amira (Stalling et al. and multi-curve fitting (MCF; Chai et al.
Revised: Additionally, for this dataset, we also generate our baseline using state-of-the-art segmentation software ZiB Amira (Stalling et al., 2005) and multi-curve fitting (MCF; (Chai et al., 2022)).

Original: Both of these software are nowadays wildly used for MT segmentation tasks.
Revised: Both of this software are nowadays wildly used for MT segmentation tasks.

Original: For both of the methods, we used the ’standard’ setting.
Revised: For both of the methods, we used the ’standard’ setting.

Original: In the case of ZiB Amira, the setting was heavily tuned for the MT data set and is suggested to use by the authors.
Revised: In the case of ZiB Amira, the setting was heavily tuned for the MT dataset and is suggested to use by the authors.

Original: In the case of MCF, the author optimized the ’standard’ setting for filament-like structures.
Revised: In the case of MCF, the author optimized the ’standard’ setting for filament-like structures.

Original: MT and Mem data set are filament-like structure, and therefore using a setting tuned by the author and adjusting only the pixel size value in our opinion should yield the best results.
Revised: MT and Mem datasets are filament-like structures, and therefore using a setting tuned by the author and adjusting only the pixel size value in the author’s opinion should yield the best results.

Original: The ScanNetV2 data sets were evaluated using average precision (AP50) denotes the scores with an IoU threshold of 50% and were compared with  SegGroup and OTOC models.
Revised: Keeping the same with the ScanNetV2 datasets were evaluated using average precision (AP50) denotes the scores with an IoU threshold of 50% and were compared with InsConv, SegGroup and OTOC models.

Revised: The ScanNetV2 evaluation was then compared against the ScanNetV2 semantic instance segmentation benchmark.

Revised: The mAP50 score in this benchmark denotes an average AP50 of every predicted instance without taking into account semantic labels which DIST did not produce.

Original: These models were  selected since both of them perform graph representation prediction.
Revised: Our DIST model predicts only instances, not semantic labels. Class names were obtained post-instance prediction by comparing the GT with predicted instances. then the class name was selected for each instance based on the highest metric value and it was used to demonstrate the AP50 score per class.

Original: 4. Membrane and Microtubule Data Set
Revised: 4. M EMBRANE AND M ICROTUBULE D ATASETS

Original: The metrics of the point clouds was shown in Table 4.1 .
Revised: The metrics of the point clouds were shown in Table 1 .

Original: For the inference of the graph representation, the output of the DIST was thresholds before calculating mIoU.
Revised: For the inference of the graph representation, the output of the DIST was thresholded before calculating mIoU.

Original: The threshold was selected by manually picking the best value based on a sub-sample of 10 data sets that were not used for the evaluation.
Revised: The threshold was selected by manually picking the best value based on a sub-sample of 10 datasets that were not used for the evaluation.

Original: The proposed DIST achieved a great leap in performance comparing mIoU of 30% and 113% compared to our baseline Figure 4.1 .
Revised: The proposed DIST achieved a great leap in performance comparing mIoU of 30% and 113% compared to our baseline Figure 3 .

Original: [Table]
Revised: [Table]

Original: The evaluation of the graph instance inference model is shown in Table 4.2 and Table 4.2 .
Revised: The evaluation of the graph instance inference model is shown in Table 2 and Table 3 .

Original: Due to the uniqueness of the EM data, we also compared our DIST framework with the current state-of-the-art method used for membrane and MT automatic segmentation.
Revised: Due to the uniqueness of the EM data, we also compared our DIST framework with the current state-of-the-art method used for membrane and MT automatic segmentation.

Original: On  2D data set we compared DIST to two method: MCF (Chai et al. and distance clustering (DC).
Revised: On the 2D dataset, we compared DIST to two methods: MCF (Chai et al., 2022) and distance clustering (DC).

Original: MCF was recently demonstrated as a workflow for instance segmentation based on iterative fitting of points to spline based on multiple hyperparameters that have to be tuned for each data set.
Revised: MCF was recently demonstrated as a workflow for instance segmentation based on iterative fitting of points to spline based on multiple hyperparameters that have to be tuned for each dataset.

Original: The DC method on the other hand relies on building instances by clustering points based on k NN distances.
Revised: The DC method on the other hand relies on building instances by clustering points based on k NN distances.

Original: We compared our 3D MT data set to MCF and currently used Amira software which producesthe state-of-the-art performance on MT segmentation task (Stalling et al.
Revised: We compared our 3D MT dataset to MCF and currently used Amira software which produces state-of-the-art performance on MT segmentation task (Stalling et al., 2005).

Original: This software deals with MT segmentation by iterative searching of neighboring points within a restricted cone shape area.
Revised: This software deals with MT segmentation by iterative searching of neighboring points within a restricted cone shape area.

Original: The result overwhelmingly shows that DIST makes a huge improvement over currently used methods.
Revised: The result overwhelmingly shows that DIST makes a huge improvement over currently used methods.

Original: DIST achieved the best results for both membrane and MT segmentation.
Revised: DIST achieved the best results for both membrane and MT segmentation.

Original:  Figure F shows further segmentation examples provided by DIST, DC, MCF and Amira.
Revised: Appendix Figure F shows further segmentation examples provided by DIST, DC, MCF and Amira.

Original: Moreover, MT data in comparison to currently state-of-the-art software, Amira, shows remarkable good results ( Table 4.2 and Appendix figure F ).
Revised: Moreover, MT data in comparison to current state-of-the-art software, Amira, shows remarkably good results ( Table 2 and Appendix Figure F ).

Original: 4. ScanNetV2 Data Set
Revised: 4. S CAN N ET V2 DATASET

Original: We also evaluated our DIST model on  synthetic data set to see how our model performs in comparison with other published methods.
Revised: We also evaluated our DIST model on the synthetic dataset to see how our model performs in comparison with other published methods.

Original: First, we evaluated graph prediction performance for ScanNetV2 data sets similar to what we did for biological data.
Revised: First, we evaluated graph prediction performance for ScanNetV2 datasets similar to what we did for biological data.

Original: We observed that our DIST method shows significant performance in predicting graph representation over our baseline by 6.62x.
Revised: We observed that our DIST method shows significant performance in predicting graph representation over our baseline by 6.62x.

Original: Next, we moved to evaluate our DIST model to see how it performs in comparison with other published methods.
Revised: Next, we moved to evaluate our DIST model to see how it performs in comparison with other published methods.

Original: For this we compared our model with SegGroup (Tao et al. , OTOC (Liu et al.
Revised: For this, we compared our model with SegGroup (Tao et al., 2022), and OTOC (Liu et al., 2021).

Original: Bot of this model using point cloud geometry and color features to learn graph representation of the given scene.
Revised: Bot of this model using point cloud geometry and color features to learn graph representation of the given scene per voxel or point cloud grouping.

Original: Additionally, we also compared DIST with the Ins-Conv method (Liu et al. that was published on scan-net 3D instance segmentation benchmark and was noted not to use color for  prediction of instances, which was similar to our approach.
Revised: Additionally, we also compared DIST with the Ins-Conv method (Liu et al., 2022) that was published on scan-net.org 3D semantic-instance segmentation benchmark and was noted not to use color for the prediction of instances, which was similar to our approach.

Original: Comparing the DIST model, we observed that our novel approach achieves a significant leap in performance while at the same time using only geometrical information of the point cloud Table 4.2 and Appendix figure F . 
Revised: Comparing the DIST model, we observed that our novel approach achieves a significant leap in performance while at the same time using only geometrical information of the point cloud Table 3 and Figure F . We also demonstrated that DIST achieved competitive results with the current state-of-the-art model evaluated on the ScanNetV2 3D instance segmentation task while only using the point distances feature Appendix Table G .

Original: [Table]
Revised: [Table]

Revised: comparison for the membrane and MT dataset.

Original:  Ablation Study
Revised:  A BLATION S TUDY

Original: We conducted an ablation study on the same membrane and MT data sets to evaluate how parts of the edge update module improve DIST performance Appendix table G .
Revised: We conducted an ablation study on the same membrane and MT datasets to evaluate how parts of the edge update module improve DIST performance Appendix Table H .

Original: We compared the DIST framework with all edge update modules with DIST with only self-attention of the triangular update mechanism turned on.
Revised: We compared the DIST framework with all edge update modules with DIST with only self-attention of the triangular update mechanism turned on.

Original: The results show that both transformer and triangular multiplicative updates contribute to the final result.
Revised: The results show that both transformer and triangular multiplicative updates contribute to the final result.

Original: We found that DIST with a full edge update module produced the best result for both data sets.
Revised: We found that DIST with a full edge update module produced the best result for both datasets.

Original: We 
Revised: We could also observe that the triangular update added a substantial improvement to DIST in comparison to the transformer update module.

Original: [Table]
Revised: [Table]

Original: a t h t
Revised: a t h t

Original: [Table]
Revised: [Table]

Original: k s h e l f
Revised: B ook s h e l f

Original: C a b i n e t C  ab i n e t
Revised: C a b i n e t C h a

Original:  C o un t e r C u rt a i n
Revised: i r C oun t e r C u r t a i n

Original: D e s k
Revised: D e s k

Original: D oo r
Revised: D oo r

Original: O t e h r f u r
Revised: O t e h rf u r

Original: P i c t u r e
Revised: P i c t u r e

Original: R e f r i g .
Revised: R e fr i g .

Original: Sh o w e
Revised: S ho w e

Original: C u r .
Revised: C u r .

Original: S i n k
Revised: S i nk

Original: S o f a
Revised: S o f a

Original: T a b l e
Revised: T a b l e

Original: T o il e t
Revised: T o il e t

Original: W i nd o w
Revised: W i ndo w

Original: [Table]
Revised: [Table]

Original: could also observe that the triangular update added a substantial improvement to DIST in comparison to the transformer update module.

Original:  Conclusion
Revised:  C ONCLUSION

Original: We propose DIST, a neural network architecture for instance segmentation of point clouds.
Revised: We propose DIST, a neural network architecture for instance segmentation of point clouds.

Original: By using geometric features to learn SO(n) invariant graph representations, we are able to achieve state-of-the-art instance segmentation of biological structures in electron micrographs and tomograms and demonstrate competitive results on natural scene understanding in ScanNetV2.
Revised: By using geometric features to learn SO(n) invariant graph representations, we are able to achieve state-of-the-art instance segmentation of biological structures in electron micrographs and tomograms and demonstrate competitive results on natural scene understanding in ScanNetV2.

Original: By framing the instance segmentation problem as a graph prediction problem where the instances are defined by connected subgraphs, we are able to identify any number of instances without any built in constraints in our network.
Revised: By framing the instance segmentation problem as a graph prediction problem where the instances are defined by connected sub-graphs, we are able to identify any number of instances without any built-in constraints in our network.

Original: Furthermore, we show that using geometrically inspired updates, the triangular update module, was critical for model performance, and that this was enhanced by the inclusion of axial attention modules.
Revised: Furthermore, we show that using geometrically inspired updates, the triangular update module, was critical for model performance and that this was enhanced by the inclusion of axial attention modules.

Original: We expect that this approach to instance segmentation will transform our ability to understand biological structures in the increasing amounts of structural data being generated by electron microscopy, where biomedical researchers are in need to fast and accurate instance segmentation methods.
Revised: We expect that this approach to instance segmentation will transform our ability to understand biological structures in the increasing amounts of structural data being generated by electron microscopy, where biomedical researchers are in need of fast and accurate instance segmentation methods.

Original: In the future, we expect that DIST will underpin filament, membrane, and organelle segmentation software.
Revised: In the future, we expect that DIST will underpin filament, membrane, and organelle segmentation software.

Original: Furthermore, DIST can be applied to other point cloud instance segmentation problems and extends easily to arbitrary dimension point clouds.
Revised: Furthermore, DIST can be applied to other point cloud instance segmentation problems and extends easily to arbitrary dimension point clouds.

Original: This would enable it to be applied to object tracking over time in 3D imaging, for example, which can be represented as a 4D space.
Revised: This would enable it to be applied to object tracking over time in 3D imaging, for example, which can be represented as a 4D space.

Original: DIST can also be extended to include node features, allowing additional semantic information for each point to be passed to the network, further increasing performance. 
Revised: DIST can also be extended to include node features, allowing additional semantic information for each point to be passed to the network, further increasing performance. A P OINT CLOUD PRE - AND POST - PROCESSING

Original: B 
Revised: B I NSTANCE SEGMENTATION METHOD COMPARISON

Revised: [Table] node features. However

Original: [Table]
Revised: [Table]

Revised: the Scan-net.org benchmark collection indicates

Original: Algorithm
Revised: [Table] Ins-Conv [Table] C D ETAIL MODEL ARCHITECTURE Appendix

Revised: D T RIANGULAR MULTIPLICATIVE EDGE FEATURE UPDATE

Revised: Algorithm

Original: Require: edge f eatures edgefeatures ← layerNorm ( edgefeatures )
Revised: Require: edge f eatures edgefeatures ← layerNorm ( edgefeatures )

Original: ▷ Initial normalization of edge features
Revised: ▷ Initial normalization of edge features

Original: Ensure: a = torch.sigmoid ( Linear ( edgefeatures ))
Revised: Ensure: a = torch.sigmoid ( Linear ( edgefeatures ))

Original: ∗ Linear ( edgefeatures ) b = torch.sigmoid
Revised: ∗ Linear ( edgefeatures ) b = torch.sigmoid

Original: ( Linear ( edgefeatures )) ∗ Linear ( edgefeatures ) if axis =
Revised: ( Linear ( edgefeatures )) ∗ Linear ( edgefeatures ) if axis =

Original: = 

Revised: =

Original: then k = einsum ( biko, bjko − > bijo, a, b ) else k = einsum ( bkio, bkjo − > bijo, a, b ) end if o = torch.sigmoid
Revised: then k = einsum ( biko, bjko − > bijo, a, b ) else k = einsum ( bkio, bkjo − > bijo, a, b ) end if o = torch.sigmoid

Original: ( Linear ( edgefeatures )) ∗ Linear ( LayerNorm ( k ))
Revised: ( Linear ( edgefeatures )) ∗ Linear ( LayerNorm ( k ))

Revised: E G REEDY ALGORITHM

Original: Algorithm algorithm for
Revised: Algorithm algorithm for

Original: Require: C kpatch k ← P local
Revised: Require: C kpatch k ← P local

Original: Require: G i,jpatch i ← P locali j ← P localj
Revised: Require: G i,jpatch i ← P locali j ← P localj

Original: Require: IDX kpatch k ← P globalID for coord, graph, index ← C kpatch , G i,jpatch , IDX kpatch do ▷ Adjacency matrix for i, j ← graph do adjacency ← index ki adjacency ← coord i adjacency ← index graph j > = threshold
Revised: Require: IDX kpatch k ← P globalID for coord, graph, index ← C kpatch , G i,jpatch , IDX kpatch do ▷ Adjacency matrix for i, j ← graph do adjacency ← index ki adjacency ← coord i adjacency ← index graph j > = threshold

Original: j adjacency ← graph graph j > = threshold j end for end for segment =
Revised: j adjacency ← graph graph j > = threshold j end for end for segment =

Original: [] ▷ Zero-out greedy algorithm stop =
Revised: [] ▷ Zero-out greedy algorithm stop =

Original: False segment id
Revised: False segment id

Original: =while not stop do ▷ Greedy instance segmenter ids ← len ( adjacency index j ) >
Revised: =while not stop do ▷ Greedy instance segmenter ids ← len ( adjacency index j ) >

Original: =▷ Pick initial point from Adjacency
Revised: =▷ Pick initial point from Adjacency

Original: NewSegment ← ids growing =
Revised: NewSegment ← ids growing =

Original: False while not growing do ▷ Find all nodes associated with initial node size = len ( NewSegment ) for id ← ids do
Revised: False while not growing do ▷ Find all nodes associated with initial node size = len ( NewSegment ) for id ← ids do

Original: Pick all points associated with the initial point
Revised: Pick all points associated with the initial point

Original: Check 1: Check if id is not already on the NewSegment
Revised: Check 1: Check if id is not already on the NewSegment

Original: Check 2: Check if id is reversible connected i ← j and j ← i
Revised: Check 2: Check if id is reversible connected i ← j and j ← i

Original: Check 3: Check if id is not associated to already segmented instance
Revised: Check 3: Check if id is not associated to already segmented instance

Original: Add new nodes to NewSegment end for if len ( NewSegment ) =
Revised: Add new nodes to NewSegment end for if len ( NewSegment ) =

Original: = size then growing =
Revised: = size then growing =

Original: True end if end while
Revised: True end if end while

Original: Sort ( NewSegment )
Revised: Sort ( NewSegment )

Original: ▷ Optional : Sort point in filament
Revised: ▷ Optional : Sort point in filament

Original: Smooth ( NewSegment ) ▷ Optional : Smooth point in filament segment.append ( segment id + NewSegment ) prune ( NewSegment ) ▷ Remove segmented nodes from adjacency if sum ( adjacency ) =
Revised: Smooth ( NewSegment ) ▷ Optional : Smooth point in filament segment.append ( segment id + NewSegment ) prune ( NewSegment ) ▷ Remove segmented nodes from adjacency if sum ( adjacency ) =

Original: = 0 then stop =
Revised: = 0 then stop =

Original: True ▷ Stop segmenter when there no more points else segment id +=end if end while
Revised: True ▷ Stop segmenter when there no more points else segment id +=end if end while

Revised: F C OMPARISON OF DIST INSTANCE SEGMENTATION PERFORMANCE

Revised: G DIST COMPARISON WITH S CAN N ET V2 STATE - OF - THE - ART MODELS .

Revised: [Table]

Original: F Comparison
Revised: P [Table] B a t h t ub B e d

Revised: B ook s h e l f

Revised: C a b i n e t

Revised: C h a

Revised: i r

Revised: C oun t e r

Revised: C u r t a i n

Original: DIST
Revised: D e s k D oo r O t e h rf u r P i c t u r e

Revised: R e fr i g .

Revised: S ho w e

Revised: C u r .

Revised: S i nk

Revised: S o f a

Revised: T a b l e

Revised: T o il e t

Revised: W i ndo w

Revised: [Table]

Original: G Ablation study
Revised: H A BLATION STUDY

Original: [Table] [Table]
Revised: [Table] [Table]